4360 lines
219 KiB
Zig
4360 lines
219 KiB
Zig
//! NOTE: this file is autogenerated, DO NOT MODIFY
|
|
//--------------------------------------------------------------------------------
|
|
// Section: Constants (69)
|
|
//--------------------------------------------------------------------------------
|
|
pub const DTCINSTALL_E_CLIENT_ALREADY_INSTALLED = @as(i32, 384);
|
|
pub const DTCINSTALL_E_SERVER_ALREADY_INSTALLED = @as(i32, 385);
|
|
pub const XA_SWITCH_F_DTC = @as(u32, 1);
|
|
pub const XA_FMTID_DTC = @as(u32, 4478019);
|
|
pub const XA_FMTID_DTC_VER1 = @as(u32, 21255235);
|
|
pub const XIDDATASIZE = @as(u32, 128);
|
|
pub const MAXGTRIDSIZE = @as(u32, 64);
|
|
pub const MAXBQUALSIZE = @as(u32, 64);
|
|
pub const RMNAMESZ = @as(u32, 32);
|
|
pub const MAXINFOSIZE = @as(u32, 256);
|
|
pub const TMNOFLAGS = @as(i32, 0);
|
|
pub const TMREGISTER = @as(i32, 1);
|
|
pub const TMNOMIGRATE = @as(i32, 2);
|
|
pub const TMUSEASYNC = @as(i32, 4);
|
|
pub const TMASYNC = @as(i32, -2147483648);
|
|
pub const TMONEPHASE = @as(i32, 1073741824);
|
|
pub const TMFAIL = @as(i32, 536870912);
|
|
pub const TMNOWAIT = @as(i32, 268435456);
|
|
pub const TMRESUME = @as(i32, 134217728);
|
|
pub const TMSUCCESS = @as(i32, 67108864);
|
|
pub const TMSUSPEND = @as(i32, 33554432);
|
|
pub const TMSTARTRSCAN = @as(i32, 16777216);
|
|
pub const TMENDRSCAN = @as(i32, 8388608);
|
|
pub const TMMULTIPLE = @as(i32, 4194304);
|
|
pub const TMJOIN = @as(i32, 2097152);
|
|
pub const TMMIGRATE = @as(i32, 1048576);
|
|
pub const TM_JOIN = @as(u32, 2);
|
|
pub const TM_RESUME = @as(u32, 1);
|
|
pub const TM_OK = @as(u32, 0);
|
|
pub const TMER_TMERR = @as(i32, -1);
|
|
pub const TMER_INVAL = @as(i32, -2);
|
|
pub const TMER_PROTO = @as(i32, -3);
|
|
pub const XA_RBBASE = @as(u32, 100);
|
|
pub const XA_RBROLLBACK = @as(u32, 100);
|
|
pub const XA_RBCOMMFAIL = @as(u32, 101);
|
|
pub const XA_RBDEADLOCK = @as(u32, 102);
|
|
pub const XA_RBINTEGRITY = @as(u32, 103);
|
|
pub const XA_RBOTHER = @as(u32, 104);
|
|
pub const XA_RBPROTO = @as(u32, 105);
|
|
pub const XA_RBTIMEOUT = @as(u32, 106);
|
|
pub const XA_RBTRANSIENT = @as(u32, 107);
|
|
pub const XA_RBEND = @as(u32, 107);
|
|
pub const XA_NOMIGRATE = @as(u32, 9);
|
|
pub const XA_HEURHAZ = @as(u32, 8);
|
|
pub const XA_HEURCOM = @as(u32, 7);
|
|
pub const XA_HEURRB = @as(u32, 6);
|
|
pub const XA_HEURMIX = @as(u32, 5);
|
|
pub const XA_RETRY = @as(u32, 4);
|
|
pub const XA_RDONLY = @as(u32, 3);
|
|
pub const XA_OK = @as(u32, 0);
|
|
pub const XAER_ASYNC = @as(i32, -2);
|
|
pub const XAER_RMERR = @as(i32, -3);
|
|
pub const XAER_NOTA = @as(i32, -4);
|
|
pub const XAER_INVAL = @as(i32, -5);
|
|
pub const XAER_PROTO = @as(i32, -6);
|
|
pub const XAER_RMFAIL = @as(i32, -7);
|
|
pub const XAER_DUPID = @as(i32, -8);
|
|
pub const XAER_OUTSIDE = @as(i32, -9);
|
|
pub const DTC_INSTALL_OVERWRITE_CLIENT = @as(u32, 1);
|
|
pub const DTC_INSTALL_OVERWRITE_SERVER = @as(u32, 2);
|
|
pub const OLE_TM_CONFIG_VERSION_1 = @as(u32, 1);
|
|
pub const OLE_TM_CONFIG_VERSION_2 = @as(u32, 2);
|
|
pub const OLE_TM_FLAG_NONE = @as(u32, 0);
|
|
pub const OLE_TM_FLAG_NODEMANDSTART = @as(u32, 1);
|
|
pub const OLE_TM_FLAG_NOAGILERECOVERY = @as(u32, 2);
|
|
pub const OLE_TM_FLAG_QUERY_SERVICE_LOCKSTATUS = @as(u32, 2147483648);
|
|
pub const OLE_TM_FLAG_INTERNAL_TO_TM = @as(u32, 1073741824);
|
|
pub const CLSID_MSDtcTransactionManager = Guid.initString("5b18ab61-091d-11d1-97df-00c04fb9618a");
|
|
pub const CLSID_MSDtcTransaction = Guid.initString("39f8d76b-0928-11d1-97df-00c04fb9618a");
|
|
|
|
//--------------------------------------------------------------------------------
|
|
// Section: Types (110)
|
|
//--------------------------------------------------------------------------------
|
|
pub const DTC_STATUS_ = enum(i32) {
|
|
UNKNOWN = 0,
|
|
STARTING = 1,
|
|
STARTED = 2,
|
|
PAUSING = 3,
|
|
PAUSED = 4,
|
|
CONTINUING = 5,
|
|
STOPPING = 6,
|
|
STOPPED = 7,
|
|
E_CANTCONTROL = 8,
|
|
FAILED = 9,
|
|
};
|
|
pub const DTC_STATUS_UNKNOWN = DTC_STATUS_.UNKNOWN;
|
|
pub const DTC_STATUS_STARTING = DTC_STATUS_.STARTING;
|
|
pub const DTC_STATUS_STARTED = DTC_STATUS_.STARTED;
|
|
pub const DTC_STATUS_PAUSING = DTC_STATUS_.PAUSING;
|
|
pub const DTC_STATUS_PAUSED = DTC_STATUS_.PAUSED;
|
|
pub const DTC_STATUS_CONTINUING = DTC_STATUS_.CONTINUING;
|
|
pub const DTC_STATUS_STOPPING = DTC_STATUS_.STOPPING;
|
|
pub const DTC_STATUS_STOPPED = DTC_STATUS_.STOPPED;
|
|
pub const DTC_STATUS_E_CANTCONTROL = DTC_STATUS_.E_CANTCONTROL;
|
|
pub const DTC_STATUS_FAILED = DTC_STATUS_.FAILED;
|
|
|
|
pub const DTC_GET_TRANSACTION_MANAGER = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
pszHost: ?PSTR,
|
|
pszTmName: ?PSTR,
|
|
rid: ?*const Guid,
|
|
dwReserved1: u32,
|
|
wcbReserved2: u16,
|
|
pvReserved2: ?*anyopaque,
|
|
ppvObject: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
pszHost: ?PSTR,
|
|
pszTmName: ?PSTR,
|
|
rid: ?*const Guid,
|
|
dwReserved1: u32,
|
|
wcbReserved2: u16,
|
|
pvReserved2: ?*anyopaque,
|
|
ppvObject: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const DTC_GET_TRANSACTION_MANAGER_EX_A = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
i_pszHost: ?PSTR,
|
|
i_pszTmName: ?PSTR,
|
|
i_riid: ?*const Guid,
|
|
i_grfOptions: u32,
|
|
i_pvConfigParams: ?*anyopaque,
|
|
o_ppvObject: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
i_pszHost: ?PSTR,
|
|
i_pszTmName: ?PSTR,
|
|
i_riid: ?*const Guid,
|
|
i_grfOptions: u32,
|
|
i_pvConfigParams: ?*anyopaque,
|
|
o_ppvObject: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const DTC_GET_TRANSACTION_MANAGER_EX_W = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
i_pwszHost: ?PWSTR,
|
|
i_pwszTmName: ?PWSTR,
|
|
i_riid: ?*const Guid,
|
|
i_grfOptions: u32,
|
|
i_pvConfigParams: ?*anyopaque,
|
|
o_ppvObject: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
i_pwszHost: ?PWSTR,
|
|
i_pwszTmName: ?PWSTR,
|
|
i_riid: ?*const Guid,
|
|
i_grfOptions: u32,
|
|
i_pvConfigParams: ?*anyopaque,
|
|
o_ppvObject: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const DTC_INSTALL_CLIENT = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
i_pszRemoteTmHostName: ?*i8,
|
|
i_dwProtocol: u32,
|
|
i_dwOverwrite: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
i_pszRemoteTmHostName: ?*i8,
|
|
i_dwProtocol: u32,
|
|
i_dwOverwrite: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const BOID = extern struct {
|
|
rgb: [16]u8,
|
|
};
|
|
|
|
pub const TX_MISC_CONSTANTS = enum(i32) {
|
|
C = 40,
|
|
};
|
|
pub const MAX_TRAN_DESC = TX_MISC_CONSTANTS.C;
|
|
|
|
pub const ISOLATIONLEVEL = enum(i32) {
|
|
UNSPECIFIED = -1,
|
|
CHAOS = 16,
|
|
READUNCOMMITTED = 256,
|
|
// BROWSE = 256, this enum value conflicts with READUNCOMMITTED
|
|
CURSORSTABILITY = 4096,
|
|
// READCOMMITTED = 4096, this enum value conflicts with CURSORSTABILITY
|
|
REPEATABLEREAD = 65536,
|
|
SERIALIZABLE = 1048576,
|
|
// ISOLATED = 1048576, this enum value conflicts with SERIALIZABLE
|
|
};
|
|
pub const ISOLATIONLEVEL_UNSPECIFIED = ISOLATIONLEVEL.UNSPECIFIED;
|
|
pub const ISOLATIONLEVEL_CHAOS = ISOLATIONLEVEL.CHAOS;
|
|
pub const ISOLATIONLEVEL_READUNCOMMITTED = ISOLATIONLEVEL.READUNCOMMITTED;
|
|
pub const ISOLATIONLEVEL_BROWSE = ISOLATIONLEVEL.READUNCOMMITTED;
|
|
pub const ISOLATIONLEVEL_CURSORSTABILITY = ISOLATIONLEVEL.CURSORSTABILITY;
|
|
pub const ISOLATIONLEVEL_READCOMMITTED = ISOLATIONLEVEL.CURSORSTABILITY;
|
|
pub const ISOLATIONLEVEL_REPEATABLEREAD = ISOLATIONLEVEL.REPEATABLEREAD;
|
|
pub const ISOLATIONLEVEL_SERIALIZABLE = ISOLATIONLEVEL.SERIALIZABLE;
|
|
pub const ISOLATIONLEVEL_ISOLATED = ISOLATIONLEVEL.SERIALIZABLE;
|
|
|
|
pub const XACTTRANSINFO = extern struct {
|
|
uow: BOID,
|
|
isoLevel: i32,
|
|
isoFlags: u32,
|
|
grfTCSupported: u32,
|
|
grfRMSupported: u32,
|
|
grfTCSupportedRetaining: u32,
|
|
grfRMSupportedRetaining: u32,
|
|
};
|
|
|
|
pub const XACTSTATS = extern struct {
|
|
cOpen: u32,
|
|
cCommitting: u32,
|
|
cCommitted: u32,
|
|
cAborting: u32,
|
|
cAborted: u32,
|
|
cInDoubt: u32,
|
|
cHeuristicDecision: u32,
|
|
timeTransactionsUp: FILETIME,
|
|
};
|
|
|
|
pub const ISOFLAG = enum(i32) {
|
|
RETAIN_COMMIT_DC = 1,
|
|
RETAIN_COMMIT = 2,
|
|
RETAIN_COMMIT_NO = 3,
|
|
RETAIN_ABORT_DC = 4,
|
|
RETAIN_ABORT = 8,
|
|
RETAIN_ABORT_NO = 12,
|
|
RETAIN_DONTCARE = 5,
|
|
RETAIN_BOTH = 10,
|
|
RETAIN_NONE = 15,
|
|
OPTIMISTIC = 16,
|
|
READONLY = 32,
|
|
};
|
|
pub const ISOFLAG_RETAIN_COMMIT_DC = ISOFLAG.RETAIN_COMMIT_DC;
|
|
pub const ISOFLAG_RETAIN_COMMIT = ISOFLAG.RETAIN_COMMIT;
|
|
pub const ISOFLAG_RETAIN_COMMIT_NO = ISOFLAG.RETAIN_COMMIT_NO;
|
|
pub const ISOFLAG_RETAIN_ABORT_DC = ISOFLAG.RETAIN_ABORT_DC;
|
|
pub const ISOFLAG_RETAIN_ABORT = ISOFLAG.RETAIN_ABORT;
|
|
pub const ISOFLAG_RETAIN_ABORT_NO = ISOFLAG.RETAIN_ABORT_NO;
|
|
pub const ISOFLAG_RETAIN_DONTCARE = ISOFLAG.RETAIN_DONTCARE;
|
|
pub const ISOFLAG_RETAIN_BOTH = ISOFLAG.RETAIN_BOTH;
|
|
pub const ISOFLAG_RETAIN_NONE = ISOFLAG.RETAIN_NONE;
|
|
pub const ISOFLAG_OPTIMISTIC = ISOFLAG.OPTIMISTIC;
|
|
pub const ISOFLAG_READONLY = ISOFLAG.READONLY;
|
|
|
|
pub const XACTTC = enum(i32) {
|
|
NONE = 0,
|
|
SYNC_PHASEONE = 1,
|
|
SYNC_PHASETWO = 2,
|
|
// SYNC = 2, this enum value conflicts with SYNC_PHASETWO
|
|
ASYNC_PHASEONE = 4,
|
|
// ASYNC = 4, this enum value conflicts with ASYNC_PHASEONE
|
|
};
|
|
pub const XACTTC_NONE = XACTTC.NONE;
|
|
pub const XACTTC_SYNC_PHASEONE = XACTTC.SYNC_PHASEONE;
|
|
pub const XACTTC_SYNC_PHASETWO = XACTTC.SYNC_PHASETWO;
|
|
pub const XACTTC_SYNC = XACTTC.SYNC_PHASETWO;
|
|
pub const XACTTC_ASYNC_PHASEONE = XACTTC.ASYNC_PHASEONE;
|
|
pub const XACTTC_ASYNC = XACTTC.ASYNC_PHASEONE;
|
|
|
|
pub const XACTRM = enum(i32) {
|
|
OPTIMISTICLASTWINS = 1,
|
|
NOREADONLYPREPARES = 2,
|
|
};
|
|
pub const XACTRM_OPTIMISTICLASTWINS = XACTRM.OPTIMISTICLASTWINS;
|
|
pub const XACTRM_NOREADONLYPREPARES = XACTRM.NOREADONLYPREPARES;
|
|
|
|
pub const XACTCONST = enum(i32) {
|
|
E = 0,
|
|
};
|
|
pub const XACTCONST_TIMEOUTINFINITE = XACTCONST.E;
|
|
|
|
pub const XACTHEURISTIC = enum(i32) {
|
|
ABORT = 1,
|
|
COMMIT = 2,
|
|
DAMAGE = 3,
|
|
DANGER = 4,
|
|
};
|
|
pub const XACTHEURISTIC_ABORT = XACTHEURISTIC.ABORT;
|
|
pub const XACTHEURISTIC_COMMIT = XACTHEURISTIC.COMMIT;
|
|
pub const XACTHEURISTIC_DAMAGE = XACTHEURISTIC.DAMAGE;
|
|
pub const XACTHEURISTIC_DANGER = XACTHEURISTIC.DANGER;
|
|
|
|
pub const XACTSTAT = enum(i32) {
|
|
NONE = 0,
|
|
OPENNORMAL = 1,
|
|
OPENREFUSED = 2,
|
|
PREPARING = 4,
|
|
PREPARED = 8,
|
|
PREPARERETAINING = 16,
|
|
PREPARERETAINED = 32,
|
|
COMMITTING = 64,
|
|
COMMITRETAINING = 128,
|
|
ABORTING = 256,
|
|
ABORTED = 512,
|
|
COMMITTED = 1024,
|
|
HEURISTIC_ABORT = 2048,
|
|
HEURISTIC_COMMIT = 4096,
|
|
HEURISTIC_DAMAGE = 8192,
|
|
HEURISTIC_DANGER = 16384,
|
|
FORCED_ABORT = 32768,
|
|
FORCED_COMMIT = 65536,
|
|
INDOUBT = 131072,
|
|
CLOSED = 262144,
|
|
OPEN = 3,
|
|
NOTPREPARED = 524227,
|
|
ALL = 524287,
|
|
};
|
|
pub const XACTSTAT_NONE = XACTSTAT.NONE;
|
|
pub const XACTSTAT_OPENNORMAL = XACTSTAT.OPENNORMAL;
|
|
pub const XACTSTAT_OPENREFUSED = XACTSTAT.OPENREFUSED;
|
|
pub const XACTSTAT_PREPARING = XACTSTAT.PREPARING;
|
|
pub const XACTSTAT_PREPARED = XACTSTAT.PREPARED;
|
|
pub const XACTSTAT_PREPARERETAINING = XACTSTAT.PREPARERETAINING;
|
|
pub const XACTSTAT_PREPARERETAINED = XACTSTAT.PREPARERETAINED;
|
|
pub const XACTSTAT_COMMITTING = XACTSTAT.COMMITTING;
|
|
pub const XACTSTAT_COMMITRETAINING = XACTSTAT.COMMITRETAINING;
|
|
pub const XACTSTAT_ABORTING = XACTSTAT.ABORTING;
|
|
pub const XACTSTAT_ABORTED = XACTSTAT.ABORTED;
|
|
pub const XACTSTAT_COMMITTED = XACTSTAT.COMMITTED;
|
|
pub const XACTSTAT_HEURISTIC_ABORT = XACTSTAT.HEURISTIC_ABORT;
|
|
pub const XACTSTAT_HEURISTIC_COMMIT = XACTSTAT.HEURISTIC_COMMIT;
|
|
pub const XACTSTAT_HEURISTIC_DAMAGE = XACTSTAT.HEURISTIC_DAMAGE;
|
|
pub const XACTSTAT_HEURISTIC_DANGER = XACTSTAT.HEURISTIC_DANGER;
|
|
pub const XACTSTAT_FORCED_ABORT = XACTSTAT.FORCED_ABORT;
|
|
pub const XACTSTAT_FORCED_COMMIT = XACTSTAT.FORCED_COMMIT;
|
|
pub const XACTSTAT_INDOUBT = XACTSTAT.INDOUBT;
|
|
pub const XACTSTAT_CLOSED = XACTSTAT.CLOSED;
|
|
pub const XACTSTAT_OPEN = XACTSTAT.OPEN;
|
|
pub const XACTSTAT_NOTPREPARED = XACTSTAT.NOTPREPARED;
|
|
pub const XACTSTAT_ALL = XACTSTAT.ALL;
|
|
|
|
pub const XACTOPT = extern struct {
|
|
ulTimeout: u32,
|
|
szDescription: [40]u8,
|
|
};
|
|
|
|
const IID_ITransaction_Value = Guid.initString("0fb15084-af41-11ce-bd2b-204c4f4f5020");
|
|
pub const IID_ITransaction = &IID_ITransaction_Value;
|
|
pub const ITransaction = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Commit: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransaction,
|
|
fRetaining: BOOL,
|
|
grfTC: u32,
|
|
grfRM: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransaction,
|
|
fRetaining: BOOL,
|
|
grfTC: u32,
|
|
grfRM: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Abort: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransaction,
|
|
pboidReason: ?*BOID,
|
|
fRetaining: BOOL,
|
|
fAsync: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransaction,
|
|
pboidReason: ?*BOID,
|
|
fRetaining: BOOL,
|
|
fAsync: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetTransactionInfo: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransaction,
|
|
pinfo: ?*XACTTRANSINFO,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransaction,
|
|
pinfo: ?*XACTTRANSINFO,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransaction_Commit(self: *const T, fRetaining: BOOL, grfTC: u32, grfRM: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransaction.VTable, @ptrCast(self.vtable)).Commit(@as(*const ITransaction, @ptrCast(self)), fRetaining, grfTC, grfRM);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransaction_Abort(self: *const T, pboidReason: ?*BOID, fRetaining: BOOL, fAsync: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransaction.VTable, @ptrCast(self.vtable)).Abort(@as(*const ITransaction, @ptrCast(self)), pboidReason, fRetaining, fAsync);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransaction_GetTransactionInfo(self: *const T, pinfo: ?*XACTTRANSINFO) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransaction.VTable, @ptrCast(self.vtable)).GetTransactionInfo(@as(*const ITransaction, @ptrCast(self)), pinfo);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionCloner_Value = Guid.initString("02656950-2152-11d0-944c-00a0c905416e");
|
|
pub const IID_ITransactionCloner = &IID_ITransactionCloner_Value;
|
|
pub const ITransactionCloner = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: ITransaction.VTable,
|
|
CloneWithCommitDisabled: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionCloner,
|
|
ppITransaction: ?*?*ITransaction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionCloner,
|
|
ppITransaction: ?*?*ITransaction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace ITransaction.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionCloner_CloneWithCommitDisabled(self: *const T, ppITransaction: ?*?*ITransaction) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionCloner.VTable, @ptrCast(self.vtable)).CloneWithCommitDisabled(@as(*const ITransactionCloner, @ptrCast(self)), ppITransaction);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransaction2_Value = Guid.initString("34021548-0065-11d3-bac1-00c04f797be2");
|
|
pub const IID_ITransaction2 = &IID_ITransaction2_Value;
|
|
pub const ITransaction2 = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: ITransactionCloner.VTable,
|
|
GetTransactionInfo2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransaction2,
|
|
pinfo: ?*XACTTRANSINFO,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransaction2,
|
|
pinfo: ?*XACTTRANSINFO,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace ITransactionCloner.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransaction2_GetTransactionInfo2(self: *const T, pinfo: ?*XACTTRANSINFO) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransaction2.VTable, @ptrCast(self.vtable)).GetTransactionInfo2(@as(*const ITransaction2, @ptrCast(self)), pinfo);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionDispenser_Value = Guid.initString("3a6ad9e1-23b9-11cf-ad60-00aa00a74ccd");
|
|
pub const IID_ITransactionDispenser = &IID_ITransactionDispenser_Value;
|
|
pub const ITransactionDispenser = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetOptionsObject: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionDispenser,
|
|
ppOptions: ?*?*ITransactionOptions,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionDispenser,
|
|
ppOptions: ?*?*ITransactionOptions,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
BeginTransaction: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionDispenser,
|
|
punkOuter: ?*IUnknown,
|
|
isoLevel: i32,
|
|
isoFlags: u32,
|
|
pOptions: ?*ITransactionOptions,
|
|
ppTransaction: ?*?*ITransaction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionDispenser,
|
|
punkOuter: ?*IUnknown,
|
|
isoLevel: i32,
|
|
isoFlags: u32,
|
|
pOptions: ?*ITransactionOptions,
|
|
ppTransaction: ?*?*ITransaction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionDispenser_GetOptionsObject(self: *const T, ppOptions: ?*?*ITransactionOptions) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionDispenser.VTable, @ptrCast(self.vtable)).GetOptionsObject(@as(*const ITransactionDispenser, @ptrCast(self)), ppOptions);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionDispenser_BeginTransaction(self: *const T, punkOuter: ?*IUnknown, isoLevel: i32, isoFlags: u32, pOptions: ?*ITransactionOptions, ppTransaction: ?*?*ITransaction) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionDispenser.VTable, @ptrCast(self.vtable)).BeginTransaction(@as(*const ITransactionDispenser, @ptrCast(self)), punkOuter, isoLevel, isoFlags, pOptions, ppTransaction);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionOptions_Value = Guid.initString("3a6ad9e0-23b9-11cf-ad60-00aa00a74ccd");
|
|
pub const IID_ITransactionOptions = &IID_ITransactionOptions_Value;
|
|
pub const ITransactionOptions = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
SetOptions: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionOptions,
|
|
pOptions: ?*XACTOPT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionOptions,
|
|
pOptions: ?*XACTOPT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetOptions: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionOptions,
|
|
pOptions: ?*XACTOPT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionOptions,
|
|
pOptions: ?*XACTOPT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionOptions_SetOptions(self: *const T, pOptions: ?*XACTOPT) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionOptions.VTable, @ptrCast(self.vtable)).SetOptions(@as(*const ITransactionOptions, @ptrCast(self)), pOptions);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionOptions_GetOptions(self: *const T, pOptions: ?*XACTOPT) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionOptions.VTable, @ptrCast(self.vtable)).GetOptions(@as(*const ITransactionOptions, @ptrCast(self)), pOptions);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionOutcomeEvents_Value = Guid.initString("3a6ad9e2-23b9-11cf-ad60-00aa00a74ccd");
|
|
pub const IID_ITransactionOutcomeEvents = &IID_ITransactionOutcomeEvents_Value;
|
|
pub const ITransactionOutcomeEvents = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Committed: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionOutcomeEvents,
|
|
fRetaining: BOOL,
|
|
pNewUOW: ?*BOID,
|
|
hr: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionOutcomeEvents,
|
|
fRetaining: BOOL,
|
|
pNewUOW: ?*BOID,
|
|
hr: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Aborted: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionOutcomeEvents,
|
|
pboidReason: ?*BOID,
|
|
fRetaining: BOOL,
|
|
pNewUOW: ?*BOID,
|
|
hr: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionOutcomeEvents,
|
|
pboidReason: ?*BOID,
|
|
fRetaining: BOOL,
|
|
pNewUOW: ?*BOID,
|
|
hr: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
HeuristicDecision: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionOutcomeEvents,
|
|
dwDecision: u32,
|
|
pboidReason: ?*BOID,
|
|
hr: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionOutcomeEvents,
|
|
dwDecision: u32,
|
|
pboidReason: ?*BOID,
|
|
hr: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Indoubt: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionOutcomeEvents,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionOutcomeEvents,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionOutcomeEvents_Committed(self: *const T, fRetaining: BOOL, pNewUOW: ?*BOID, hr: HRESULT) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionOutcomeEvents.VTable, @ptrCast(self.vtable)).Committed(@as(*const ITransactionOutcomeEvents, @ptrCast(self)), fRetaining, pNewUOW, hr);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionOutcomeEvents_Aborted(self: *const T, pboidReason: ?*BOID, fRetaining: BOOL, pNewUOW: ?*BOID, hr: HRESULT) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionOutcomeEvents.VTable, @ptrCast(self.vtable)).Aborted(@as(*const ITransactionOutcomeEvents, @ptrCast(self)), pboidReason, fRetaining, pNewUOW, hr);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionOutcomeEvents_HeuristicDecision(self: *const T, dwDecision: u32, pboidReason: ?*BOID, hr: HRESULT) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionOutcomeEvents.VTable, @ptrCast(self.vtable)).HeuristicDecision(@as(*const ITransactionOutcomeEvents, @ptrCast(self)), dwDecision, pboidReason, hr);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionOutcomeEvents_Indoubt(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionOutcomeEvents.VTable, @ptrCast(self.vtable)).Indoubt(@as(*const ITransactionOutcomeEvents, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITmNodeName_Value = Guid.initString("30274f88-6ee4-474e-9b95-7807bc9ef8cf");
|
|
pub const IID_ITmNodeName = &IID_ITmNodeName_Value;
|
|
pub const ITmNodeName = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetNodeNameSize: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITmNodeName,
|
|
pcbNodeNameSize: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITmNodeName,
|
|
pcbNodeNameSize: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetNodeName: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITmNodeName,
|
|
cbNodeNameBufferSize: u32,
|
|
pNodeNameBuffer: ?PWSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITmNodeName,
|
|
cbNodeNameBufferSize: u32,
|
|
pNodeNameBuffer: ?PWSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITmNodeName_GetNodeNameSize(self: *const T, pcbNodeNameSize: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const ITmNodeName.VTable, @ptrCast(self.vtable)).GetNodeNameSize(@as(*const ITmNodeName, @ptrCast(self)), pcbNodeNameSize);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITmNodeName_GetNodeName(self: *const T, cbNodeNameBufferSize: u32, pNodeNameBuffer: ?PWSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ITmNodeName.VTable, @ptrCast(self.vtable)).GetNodeName(@as(*const ITmNodeName, @ptrCast(self)), cbNodeNameBufferSize, pNodeNameBuffer);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IKernelTransaction_Value = Guid.initString("79427a2b-f895-40e0-be79-b57dc82ed231");
|
|
pub const IID_IKernelTransaction = &IID_IKernelTransaction_Value;
|
|
pub const IKernelTransaction = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetHandle: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IKernelTransaction,
|
|
pHandle: ?*?HANDLE,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IKernelTransaction,
|
|
pHandle: ?*?HANDLE,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IKernelTransaction_GetHandle(self: *const T, pHandle: ?*?HANDLE) callconv(.Inline) HRESULT {
|
|
return @as(*const IKernelTransaction.VTable, @ptrCast(self.vtable)).GetHandle(@as(*const IKernelTransaction, @ptrCast(self)), pHandle);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionResourceAsync_Value = Guid.initString("69e971f0-23ce-11cf-ad60-00aa00a74ccd");
|
|
pub const IID_ITransactionResourceAsync = &IID_ITransactionResourceAsync_Value;
|
|
pub const ITransactionResourceAsync = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
PrepareRequest: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionResourceAsync,
|
|
fRetaining: BOOL,
|
|
grfRM: u32,
|
|
fWantMoniker: BOOL,
|
|
fSinglePhase: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionResourceAsync,
|
|
fRetaining: BOOL,
|
|
grfRM: u32,
|
|
fWantMoniker: BOOL,
|
|
fSinglePhase: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CommitRequest: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionResourceAsync,
|
|
grfRM: u32,
|
|
pNewUOW: ?*BOID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionResourceAsync,
|
|
grfRM: u32,
|
|
pNewUOW: ?*BOID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
AbortRequest: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionResourceAsync,
|
|
pboidReason: ?*BOID,
|
|
fRetaining: BOOL,
|
|
pNewUOW: ?*BOID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionResourceAsync,
|
|
pboidReason: ?*BOID,
|
|
fRetaining: BOOL,
|
|
pNewUOW: ?*BOID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
TMDown: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionResourceAsync,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionResourceAsync,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionResourceAsync_PrepareRequest(self: *const T, fRetaining: BOOL, grfRM: u32, fWantMoniker: BOOL, fSinglePhase: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionResourceAsync.VTable, @ptrCast(self.vtable)).PrepareRequest(@as(*const ITransactionResourceAsync, @ptrCast(self)), fRetaining, grfRM, fWantMoniker, fSinglePhase);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionResourceAsync_CommitRequest(self: *const T, grfRM: u32, pNewUOW: ?*BOID) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionResourceAsync.VTable, @ptrCast(self.vtable)).CommitRequest(@as(*const ITransactionResourceAsync, @ptrCast(self)), grfRM, pNewUOW);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionResourceAsync_AbortRequest(self: *const T, pboidReason: ?*BOID, fRetaining: BOOL, pNewUOW: ?*BOID) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionResourceAsync.VTable, @ptrCast(self.vtable)).AbortRequest(@as(*const ITransactionResourceAsync, @ptrCast(self)), pboidReason, fRetaining, pNewUOW);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionResourceAsync_TMDown(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionResourceAsync.VTable, @ptrCast(self.vtable)).TMDown(@as(*const ITransactionResourceAsync, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionLastResourceAsync_Value = Guid.initString("c82bd532-5b30-11d3-8a91-00c04f79eb6d");
|
|
pub const IID_ITransactionLastResourceAsync = &IID_ITransactionLastResourceAsync_Value;
|
|
pub const ITransactionLastResourceAsync = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
DelegateCommit: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionLastResourceAsync,
|
|
grfRM: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionLastResourceAsync,
|
|
grfRM: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ForgetRequest: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionLastResourceAsync,
|
|
pNewUOW: ?*BOID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionLastResourceAsync,
|
|
pNewUOW: ?*BOID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionLastResourceAsync_DelegateCommit(self: *const T, grfRM: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionLastResourceAsync.VTable, @ptrCast(self.vtable)).DelegateCommit(@as(*const ITransactionLastResourceAsync, @ptrCast(self)), grfRM);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionLastResourceAsync_ForgetRequest(self: *const T, pNewUOW: ?*BOID) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionLastResourceAsync.VTable, @ptrCast(self.vtable)).ForgetRequest(@as(*const ITransactionLastResourceAsync, @ptrCast(self)), pNewUOW);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionResource_Value = Guid.initString("ee5ff7b3-4572-11d0-9452-00a0c905416e");
|
|
pub const IID_ITransactionResource = &IID_ITransactionResource_Value;
|
|
pub const ITransactionResource = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
PrepareRequest: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionResource,
|
|
fRetaining: BOOL,
|
|
grfRM: u32,
|
|
fWantMoniker: BOOL,
|
|
fSinglePhase: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionResource,
|
|
fRetaining: BOOL,
|
|
grfRM: u32,
|
|
fWantMoniker: BOOL,
|
|
fSinglePhase: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CommitRequest: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionResource,
|
|
grfRM: u32,
|
|
pNewUOW: ?*BOID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionResource,
|
|
grfRM: u32,
|
|
pNewUOW: ?*BOID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
AbortRequest: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionResource,
|
|
pboidReason: ?*BOID,
|
|
fRetaining: BOOL,
|
|
pNewUOW: ?*BOID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionResource,
|
|
pboidReason: ?*BOID,
|
|
fRetaining: BOOL,
|
|
pNewUOW: ?*BOID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
TMDown: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionResource,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionResource,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionResource_PrepareRequest(self: *const T, fRetaining: BOOL, grfRM: u32, fWantMoniker: BOOL, fSinglePhase: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionResource.VTable, @ptrCast(self.vtable)).PrepareRequest(@as(*const ITransactionResource, @ptrCast(self)), fRetaining, grfRM, fWantMoniker, fSinglePhase);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionResource_CommitRequest(self: *const T, grfRM: u32, pNewUOW: ?*BOID) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionResource.VTable, @ptrCast(self.vtable)).CommitRequest(@as(*const ITransactionResource, @ptrCast(self)), grfRM, pNewUOW);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionResource_AbortRequest(self: *const T, pboidReason: ?*BOID, fRetaining: BOOL, pNewUOW: ?*BOID) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionResource.VTable, @ptrCast(self.vtable)).AbortRequest(@as(*const ITransactionResource, @ptrCast(self)), pboidReason, fRetaining, pNewUOW);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionResource_TMDown(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionResource.VTable, @ptrCast(self.vtable)).TMDown(@as(*const ITransactionResource, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionEnlistmentAsync_Value = Guid.initString("0fb15081-af41-11ce-bd2b-204c4f4f5020");
|
|
pub const IID_ITransactionEnlistmentAsync = &IID_ITransactionEnlistmentAsync_Value;
|
|
pub const ITransactionEnlistmentAsync = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
PrepareRequestDone: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionEnlistmentAsync,
|
|
hr: HRESULT,
|
|
pmk: ?*IMoniker,
|
|
pboidReason: ?*BOID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionEnlistmentAsync,
|
|
hr: HRESULT,
|
|
pmk: ?*IMoniker,
|
|
pboidReason: ?*BOID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CommitRequestDone: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionEnlistmentAsync,
|
|
hr: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionEnlistmentAsync,
|
|
hr: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
AbortRequestDone: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionEnlistmentAsync,
|
|
hr: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionEnlistmentAsync,
|
|
hr: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionEnlistmentAsync_PrepareRequestDone(self: *const T, hr: HRESULT, pmk: ?*IMoniker, pboidReason: ?*BOID) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionEnlistmentAsync.VTable, @ptrCast(self.vtable)).PrepareRequestDone(@as(*const ITransactionEnlistmentAsync, @ptrCast(self)), hr, pmk, pboidReason);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionEnlistmentAsync_CommitRequestDone(self: *const T, hr: HRESULT) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionEnlistmentAsync.VTable, @ptrCast(self.vtable)).CommitRequestDone(@as(*const ITransactionEnlistmentAsync, @ptrCast(self)), hr);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionEnlistmentAsync_AbortRequestDone(self: *const T, hr: HRESULT) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionEnlistmentAsync.VTable, @ptrCast(self.vtable)).AbortRequestDone(@as(*const ITransactionEnlistmentAsync, @ptrCast(self)), hr);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionLastEnlistmentAsync_Value = Guid.initString("c82bd533-5b30-11d3-8a91-00c04f79eb6d");
|
|
pub const IID_ITransactionLastEnlistmentAsync = &IID_ITransactionLastEnlistmentAsync_Value;
|
|
pub const ITransactionLastEnlistmentAsync = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
TransactionOutcome: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionLastEnlistmentAsync,
|
|
XactStat: XACTSTAT,
|
|
pboidReason: ?*BOID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionLastEnlistmentAsync,
|
|
XactStat: XACTSTAT,
|
|
pboidReason: ?*BOID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionLastEnlistmentAsync_TransactionOutcome(self: *const T, XactStat: XACTSTAT, pboidReason: ?*BOID) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionLastEnlistmentAsync.VTable, @ptrCast(self.vtable)).TransactionOutcome(@as(*const ITransactionLastEnlistmentAsync, @ptrCast(self)), XactStat, pboidReason);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionExportFactory_Value = Guid.initString("e1cf9b53-8745-11ce-a9ba-00aa006c3706");
|
|
pub const IID_ITransactionExportFactory = &IID_ITransactionExportFactory_Value;
|
|
pub const ITransactionExportFactory = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetRemoteClassId: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionExportFactory,
|
|
pclsid: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionExportFactory,
|
|
pclsid: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Create: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionExportFactory,
|
|
cbWhereabouts: u32,
|
|
rgbWhereabouts: [*:0]u8,
|
|
ppExport: ?*?*ITransactionExport,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionExportFactory,
|
|
cbWhereabouts: u32,
|
|
rgbWhereabouts: [*:0]u8,
|
|
ppExport: ?*?*ITransactionExport,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionExportFactory_GetRemoteClassId(self: *const T, pclsid: ?*Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionExportFactory.VTable, @ptrCast(self.vtable)).GetRemoteClassId(@as(*const ITransactionExportFactory, @ptrCast(self)), pclsid);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionExportFactory_Create(self: *const T, cbWhereabouts: u32, rgbWhereabouts: [*:0]u8, ppExport: ?*?*ITransactionExport) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionExportFactory.VTable, @ptrCast(self.vtable)).Create(@as(*const ITransactionExportFactory, @ptrCast(self)), cbWhereabouts, rgbWhereabouts, ppExport);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionImportWhereabouts_Value = Guid.initString("0141fda4-8fc0-11ce-bd18-204c4f4f5020");
|
|
pub const IID_ITransactionImportWhereabouts = &IID_ITransactionImportWhereabouts_Value;
|
|
pub const ITransactionImportWhereabouts = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetWhereaboutsSize: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionImportWhereabouts,
|
|
pcbWhereabouts: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionImportWhereabouts,
|
|
pcbWhereabouts: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetWhereabouts: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionImportWhereabouts,
|
|
cbWhereabouts: u32,
|
|
rgbWhereabouts: [*:0]u8,
|
|
pcbUsed: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionImportWhereabouts,
|
|
cbWhereabouts: u32,
|
|
rgbWhereabouts: [*:0]u8,
|
|
pcbUsed: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionImportWhereabouts_GetWhereaboutsSize(self: *const T, pcbWhereabouts: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionImportWhereabouts.VTable, @ptrCast(self.vtable)).GetWhereaboutsSize(@as(*const ITransactionImportWhereabouts, @ptrCast(self)), pcbWhereabouts);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionImportWhereabouts_GetWhereabouts(self: *const T, cbWhereabouts: u32, rgbWhereabouts: [*:0]u8, pcbUsed: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionImportWhereabouts.VTable, @ptrCast(self.vtable)).GetWhereabouts(@as(*const ITransactionImportWhereabouts, @ptrCast(self)), cbWhereabouts, rgbWhereabouts, pcbUsed);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionExport_Value = Guid.initString("0141fda5-8fc0-11ce-bd18-204c4f4f5020");
|
|
pub const IID_ITransactionExport = &IID_ITransactionExport_Value;
|
|
pub const ITransactionExport = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Export: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionExport,
|
|
punkTransaction: ?*IUnknown,
|
|
pcbTransactionCookie: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionExport,
|
|
punkTransaction: ?*IUnknown,
|
|
pcbTransactionCookie: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetTransactionCookie: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionExport,
|
|
punkTransaction: ?*IUnknown,
|
|
cbTransactionCookie: u32,
|
|
rgbTransactionCookie: [*:0]u8,
|
|
pcbUsed: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionExport,
|
|
punkTransaction: ?*IUnknown,
|
|
cbTransactionCookie: u32,
|
|
rgbTransactionCookie: [*:0]u8,
|
|
pcbUsed: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionExport_Export(self: *const T, punkTransaction: ?*IUnknown, pcbTransactionCookie: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionExport.VTable, @ptrCast(self.vtable)).Export(@as(*const ITransactionExport, @ptrCast(self)), punkTransaction, pcbTransactionCookie);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionExport_GetTransactionCookie(self: *const T, punkTransaction: ?*IUnknown, cbTransactionCookie: u32, rgbTransactionCookie: [*:0]u8, pcbUsed: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionExport.VTable, @ptrCast(self.vtable)).GetTransactionCookie(@as(*const ITransactionExport, @ptrCast(self)), punkTransaction, cbTransactionCookie, rgbTransactionCookie, pcbUsed);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionImport_Value = Guid.initString("e1cf9b5a-8745-11ce-a9ba-00aa006c3706");
|
|
pub const IID_ITransactionImport = &IID_ITransactionImport_Value;
|
|
pub const ITransactionImport = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Import: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionImport,
|
|
cbTransactionCookie: u32,
|
|
rgbTransactionCookie: [*:0]u8,
|
|
piid: ?*const Guid,
|
|
ppvTransaction: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionImport,
|
|
cbTransactionCookie: u32,
|
|
rgbTransactionCookie: [*:0]u8,
|
|
piid: ?*const Guid,
|
|
ppvTransaction: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionImport_Import(self: *const T, cbTransactionCookie: u32, rgbTransactionCookie: [*:0]u8, piid: ?*const Guid, ppvTransaction: ?*?*anyopaque) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionImport.VTable, @ptrCast(self.vtable)).Import(@as(*const ITransactionImport, @ptrCast(self)), cbTransactionCookie, rgbTransactionCookie, piid, ppvTransaction);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITipTransaction_Value = Guid.initString("17cf72d0-bac5-11d1-b1bf-00c04fc2f3ef");
|
|
pub const IID_ITipTransaction = &IID_ITipTransaction_Value;
|
|
pub const ITipTransaction = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Push: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITipTransaction,
|
|
i_pszRemoteTmUrl: ?*u8,
|
|
o_ppszRemoteTxUrl: ?*?PSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITipTransaction,
|
|
i_pszRemoteTmUrl: ?*u8,
|
|
o_ppszRemoteTxUrl: ?*?PSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetTransactionUrl: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITipTransaction,
|
|
o_ppszLocalTxUrl: ?*?PSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITipTransaction,
|
|
o_ppszLocalTxUrl: ?*?PSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITipTransaction_Push(self: *const T, i_pszRemoteTmUrl: ?*u8, o_ppszRemoteTxUrl: ?*?PSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ITipTransaction.VTable, @ptrCast(self.vtable)).Push(@as(*const ITipTransaction, @ptrCast(self)), i_pszRemoteTmUrl, o_ppszRemoteTxUrl);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITipTransaction_GetTransactionUrl(self: *const T, o_ppszLocalTxUrl: ?*?PSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ITipTransaction.VTable, @ptrCast(self.vtable)).GetTransactionUrl(@as(*const ITipTransaction, @ptrCast(self)), o_ppszLocalTxUrl);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITipHelper_Value = Guid.initString("17cf72d1-bac5-11d1-b1bf-00c04fc2f3ef");
|
|
pub const IID_ITipHelper = &IID_ITipHelper_Value;
|
|
pub const ITipHelper = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Pull: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITipHelper,
|
|
i_pszTxUrl: ?*u8,
|
|
o_ppITransaction: ?*?*ITransaction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITipHelper,
|
|
i_pszTxUrl: ?*u8,
|
|
o_ppITransaction: ?*?*ITransaction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
PullAsync: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITipHelper,
|
|
i_pszTxUrl: ?*u8,
|
|
i_pTipPullSink: ?*ITipPullSink,
|
|
o_ppITransaction: ?*?*ITransaction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITipHelper,
|
|
i_pszTxUrl: ?*u8,
|
|
i_pTipPullSink: ?*ITipPullSink,
|
|
o_ppITransaction: ?*?*ITransaction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetLocalTmUrl: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITipHelper,
|
|
o_ppszLocalTmUrl: ?*?*u8,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITipHelper,
|
|
o_ppszLocalTmUrl: ?*?*u8,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITipHelper_Pull(self: *const T, i_pszTxUrl: ?*u8, o_ppITransaction: ?*?*ITransaction) callconv(.Inline) HRESULT {
|
|
return @as(*const ITipHelper.VTable, @ptrCast(self.vtable)).Pull(@as(*const ITipHelper, @ptrCast(self)), i_pszTxUrl, o_ppITransaction);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITipHelper_PullAsync(self: *const T, i_pszTxUrl: ?*u8, i_pTipPullSink: ?*ITipPullSink, o_ppITransaction: ?*?*ITransaction) callconv(.Inline) HRESULT {
|
|
return @as(*const ITipHelper.VTable, @ptrCast(self.vtable)).PullAsync(@as(*const ITipHelper, @ptrCast(self)), i_pszTxUrl, i_pTipPullSink, o_ppITransaction);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITipHelper_GetLocalTmUrl(self: *const T, o_ppszLocalTmUrl: ?*?*u8) callconv(.Inline) HRESULT {
|
|
return @as(*const ITipHelper.VTable, @ptrCast(self.vtable)).GetLocalTmUrl(@as(*const ITipHelper, @ptrCast(self)), o_ppszLocalTmUrl);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITipPullSink_Value = Guid.initString("17cf72d2-bac5-11d1-b1bf-00c04fc2f3ef");
|
|
pub const IID_ITipPullSink = &IID_ITipPullSink_Value;
|
|
pub const ITipPullSink = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
PullComplete: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITipPullSink,
|
|
i_hrPull: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITipPullSink,
|
|
i_hrPull: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITipPullSink_PullComplete(self: *const T, i_hrPull: HRESULT) callconv(.Inline) HRESULT {
|
|
return @as(*const ITipPullSink.VTable, @ptrCast(self.vtable)).PullComplete(@as(*const ITipPullSink, @ptrCast(self)), i_hrPull);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IDtcNetworkAccessConfig_Value = Guid.initString("9797c15d-a428-4291-87b6-0995031a678d");
|
|
pub const IID_IDtcNetworkAccessConfig = &IID_IDtcNetworkAccessConfig_Value;
|
|
pub const IDtcNetworkAccessConfig = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetAnyNetworkAccess: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
pbAnyNetworkAccess: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
pbAnyNetworkAccess: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetAnyNetworkAccess: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
bAnyNetworkAccess: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
bAnyNetworkAccess: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetNetworkAdministrationAccess: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
pbNetworkAdministrationAccess: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
pbNetworkAdministrationAccess: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetNetworkAdministrationAccess: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
bNetworkAdministrationAccess: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
bNetworkAdministrationAccess: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetNetworkTransactionAccess: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
pbNetworkTransactionAccess: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
pbNetworkTransactionAccess: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetNetworkTransactionAccess: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
bNetworkTransactionAccess: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
bNetworkTransactionAccess: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetNetworkClientAccess: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
pbNetworkClientAccess: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
pbNetworkClientAccess: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetNetworkClientAccess: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
bNetworkClientAccess: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
bNetworkClientAccess: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetNetworkTIPAccess: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
pbNetworkTIPAccess: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
pbNetworkTIPAccess: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetNetworkTIPAccess: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
bNetworkTIPAccess: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
bNetworkTIPAccess: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetXAAccess: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
pbXAAccess: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
pbXAAccess: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetXAAccess: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
bXAAccess: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
bXAAccess: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
RestartDtcService: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcNetworkAccessConfig,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcNetworkAccessConfig_GetAnyNetworkAccess(self: *const T, pbAnyNetworkAccess: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).GetAnyNetworkAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), pbAnyNetworkAccess);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcNetworkAccessConfig_SetAnyNetworkAccess(self: *const T, bAnyNetworkAccess: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).SetAnyNetworkAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), bAnyNetworkAccess);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcNetworkAccessConfig_GetNetworkAdministrationAccess(self: *const T, pbNetworkAdministrationAccess: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).GetNetworkAdministrationAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), pbNetworkAdministrationAccess);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcNetworkAccessConfig_SetNetworkAdministrationAccess(self: *const T, bNetworkAdministrationAccess: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).SetNetworkAdministrationAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), bNetworkAdministrationAccess);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcNetworkAccessConfig_GetNetworkTransactionAccess(self: *const T, pbNetworkTransactionAccess: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).GetNetworkTransactionAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), pbNetworkTransactionAccess);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcNetworkAccessConfig_SetNetworkTransactionAccess(self: *const T, bNetworkTransactionAccess: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).SetNetworkTransactionAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), bNetworkTransactionAccess);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcNetworkAccessConfig_GetNetworkClientAccess(self: *const T, pbNetworkClientAccess: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).GetNetworkClientAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), pbNetworkClientAccess);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcNetworkAccessConfig_SetNetworkClientAccess(self: *const T, bNetworkClientAccess: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).SetNetworkClientAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), bNetworkClientAccess);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcNetworkAccessConfig_GetNetworkTIPAccess(self: *const T, pbNetworkTIPAccess: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).GetNetworkTIPAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), pbNetworkTIPAccess);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcNetworkAccessConfig_SetNetworkTIPAccess(self: *const T, bNetworkTIPAccess: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).SetNetworkTIPAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), bNetworkTIPAccess);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcNetworkAccessConfig_GetXAAccess(self: *const T, pbXAAccess: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).GetXAAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), pbXAAccess);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcNetworkAccessConfig_SetXAAccess(self: *const T, bXAAccess: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).SetXAAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), bXAAccess);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcNetworkAccessConfig_RestartDtcService(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).RestartDtcService(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
pub const AUTHENTICATION_LEVEL = enum(i32) {
|
|
NO_AUTHENTICATION_REQUIRED = 0,
|
|
INCOMING_AUTHENTICATION_REQUIRED = 1,
|
|
MUTUAL_AUTHENTICATION_REQUIRED = 2,
|
|
};
|
|
pub const NO_AUTHENTICATION_REQUIRED = AUTHENTICATION_LEVEL.NO_AUTHENTICATION_REQUIRED;
|
|
pub const INCOMING_AUTHENTICATION_REQUIRED = AUTHENTICATION_LEVEL.INCOMING_AUTHENTICATION_REQUIRED;
|
|
pub const MUTUAL_AUTHENTICATION_REQUIRED = AUTHENTICATION_LEVEL.MUTUAL_AUTHENTICATION_REQUIRED;
|
|
|
|
const IID_IDtcNetworkAccessConfig2_Value = Guid.initString("a7aa013b-eb7d-4f42-b41c-b2dec09ae034");
|
|
pub const IID_IDtcNetworkAccessConfig2 = &IID_IDtcNetworkAccessConfig2_Value;
|
|
pub const IDtcNetworkAccessConfig2 = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDtcNetworkAccessConfig.VTable,
|
|
GetNetworkInboundAccess: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcNetworkAccessConfig2,
|
|
pbInbound: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcNetworkAccessConfig2,
|
|
pbInbound: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetNetworkOutboundAccess: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcNetworkAccessConfig2,
|
|
pbOutbound: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcNetworkAccessConfig2,
|
|
pbOutbound: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetNetworkInboundAccess: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcNetworkAccessConfig2,
|
|
bInbound: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcNetworkAccessConfig2,
|
|
bInbound: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetNetworkOutboundAccess: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcNetworkAccessConfig2,
|
|
bOutbound: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcNetworkAccessConfig2,
|
|
bOutbound: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetAuthenticationLevel: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcNetworkAccessConfig2,
|
|
pAuthLevel: ?*AUTHENTICATION_LEVEL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcNetworkAccessConfig2,
|
|
pAuthLevel: ?*AUTHENTICATION_LEVEL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetAuthenticationLevel: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcNetworkAccessConfig2,
|
|
AuthLevel: AUTHENTICATION_LEVEL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcNetworkAccessConfig2,
|
|
AuthLevel: AUTHENTICATION_LEVEL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDtcNetworkAccessConfig.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcNetworkAccessConfig2_GetNetworkInboundAccess(self: *const T, pbInbound: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcNetworkAccessConfig2.VTable, @ptrCast(self.vtable)).GetNetworkInboundAccess(@as(*const IDtcNetworkAccessConfig2, @ptrCast(self)), pbInbound);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcNetworkAccessConfig2_GetNetworkOutboundAccess(self: *const T, pbOutbound: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcNetworkAccessConfig2.VTable, @ptrCast(self.vtable)).GetNetworkOutboundAccess(@as(*const IDtcNetworkAccessConfig2, @ptrCast(self)), pbOutbound);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcNetworkAccessConfig2_SetNetworkInboundAccess(self: *const T, bInbound: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcNetworkAccessConfig2.VTable, @ptrCast(self.vtable)).SetNetworkInboundAccess(@as(*const IDtcNetworkAccessConfig2, @ptrCast(self)), bInbound);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcNetworkAccessConfig2_SetNetworkOutboundAccess(self: *const T, bOutbound: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcNetworkAccessConfig2.VTable, @ptrCast(self.vtable)).SetNetworkOutboundAccess(@as(*const IDtcNetworkAccessConfig2, @ptrCast(self)), bOutbound);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcNetworkAccessConfig2_GetAuthenticationLevel(self: *const T, pAuthLevel: ?*AUTHENTICATION_LEVEL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcNetworkAccessConfig2.VTable, @ptrCast(self.vtable)).GetAuthenticationLevel(@as(*const IDtcNetworkAccessConfig2, @ptrCast(self)), pAuthLevel);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcNetworkAccessConfig2_SetAuthenticationLevel(self: *const T, AuthLevel: AUTHENTICATION_LEVEL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcNetworkAccessConfig2.VTable, @ptrCast(self.vtable)).SetAuthenticationLevel(@as(*const IDtcNetworkAccessConfig2, @ptrCast(self)), AuthLevel);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IDtcNetworkAccessConfig3_Value = Guid.initString("76e4b4f3-2ca5-466b-89d5-fd218ee75b49");
|
|
pub const IID_IDtcNetworkAccessConfig3 = &IID_IDtcNetworkAccessConfig3_Value;
|
|
pub const IDtcNetworkAccessConfig3 = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDtcNetworkAccessConfig2.VTable,
|
|
GetLUAccess: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcNetworkAccessConfig3,
|
|
pbLUAccess: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcNetworkAccessConfig3,
|
|
pbLUAccess: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetLUAccess: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcNetworkAccessConfig3,
|
|
bLUAccess: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcNetworkAccessConfig3,
|
|
bLUAccess: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDtcNetworkAccessConfig2.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcNetworkAccessConfig3_GetLUAccess(self: *const T, pbLUAccess: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcNetworkAccessConfig3.VTable, @ptrCast(self.vtable)).GetLUAccess(@as(*const IDtcNetworkAccessConfig3, @ptrCast(self)), pbLUAccess);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcNetworkAccessConfig3_SetLUAccess(self: *const T, bLUAccess: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcNetworkAccessConfig3.VTable, @ptrCast(self.vtable)).SetLUAccess(@as(*const IDtcNetworkAccessConfig3, @ptrCast(self)), bLUAccess);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
pub const xid_t = extern struct {
|
|
formatID: i32,
|
|
gtrid_length: i32,
|
|
bqual_length: i32,
|
|
data: [128]CHAR,
|
|
};
|
|
|
|
pub const xa_switch_t = extern struct {
|
|
name: [32]CHAR,
|
|
flags: i32,
|
|
version: i32,
|
|
xa_open_entry: isize,
|
|
xa_close_entry: isize,
|
|
xa_start_entry: isize,
|
|
xa_end_entry: isize,
|
|
xa_rollback_entry: isize,
|
|
xa_prepare_entry: isize,
|
|
xa_commit_entry: isize,
|
|
xa_recover_entry: isize,
|
|
xa_forget_entry: isize,
|
|
xa_complete_entry: isize,
|
|
};
|
|
|
|
pub const XA_OPEN_EPT = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
param0: ?PSTR,
|
|
param1: i32,
|
|
param2: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) i32,
|
|
else => *const fn(
|
|
param0: ?PSTR,
|
|
param1: i32,
|
|
param2: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) i32,
|
|
} ;
|
|
|
|
pub const XA_CLOSE_EPT = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
param0: ?PSTR,
|
|
param1: i32,
|
|
param2: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) i32,
|
|
else => *const fn(
|
|
param0: ?PSTR,
|
|
param1: i32,
|
|
param2: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) i32,
|
|
} ;
|
|
|
|
pub const XA_START_EPT = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
param0: ?*xid_t,
|
|
param1: i32,
|
|
param2: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) i32,
|
|
else => *const fn(
|
|
param0: ?*xid_t,
|
|
param1: i32,
|
|
param2: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) i32,
|
|
} ;
|
|
|
|
pub const XA_END_EPT = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
param0: ?*xid_t,
|
|
param1: i32,
|
|
param2: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) i32,
|
|
else => *const fn(
|
|
param0: ?*xid_t,
|
|
param1: i32,
|
|
param2: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) i32,
|
|
} ;
|
|
|
|
pub const XA_ROLLBACK_EPT = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
param0: ?*xid_t,
|
|
param1: i32,
|
|
param2: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) i32,
|
|
else => *const fn(
|
|
param0: ?*xid_t,
|
|
param1: i32,
|
|
param2: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) i32,
|
|
} ;
|
|
|
|
pub const XA_PREPARE_EPT = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
param0: ?*xid_t,
|
|
param1: i32,
|
|
param2: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) i32,
|
|
else => *const fn(
|
|
param0: ?*xid_t,
|
|
param1: i32,
|
|
param2: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) i32,
|
|
} ;
|
|
|
|
pub const XA_COMMIT_EPT = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
param0: ?*xid_t,
|
|
param1: i32,
|
|
param2: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) i32,
|
|
else => *const fn(
|
|
param0: ?*xid_t,
|
|
param1: i32,
|
|
param2: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) i32,
|
|
} ;
|
|
|
|
pub const XA_RECOVER_EPT = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
param0: ?*xid_t,
|
|
param1: i32,
|
|
param2: i32,
|
|
param3: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) i32,
|
|
else => *const fn(
|
|
param0: ?*xid_t,
|
|
param1: i32,
|
|
param2: i32,
|
|
param3: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) i32,
|
|
} ;
|
|
|
|
pub const XA_FORGET_EPT = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
param0: ?*xid_t,
|
|
param1: i32,
|
|
param2: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) i32,
|
|
else => *const fn(
|
|
param0: ?*xid_t,
|
|
param1: i32,
|
|
param2: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) i32,
|
|
} ;
|
|
|
|
pub const XA_COMPLETE_EPT = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
param0: ?*i32,
|
|
param1: ?*i32,
|
|
param2: i32,
|
|
param3: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) i32,
|
|
else => *const fn(
|
|
param0: ?*i32,
|
|
param1: ?*i32,
|
|
param2: i32,
|
|
param3: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) i32,
|
|
} ;
|
|
|
|
const IID_IDtcToXaMapper_Value = Guid.initString("64ffabe0-7ce9-11d0-8ce6-00c04fdc877e");
|
|
pub const IID_IDtcToXaMapper = &IID_IDtcToXaMapper_Value;
|
|
pub const IDtcToXaMapper = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
RequestNewResourceManager: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcToXaMapper,
|
|
pszDSN: ?PSTR,
|
|
pszClientDllName: ?PSTR,
|
|
pdwRMCookie: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcToXaMapper,
|
|
pszDSN: ?PSTR,
|
|
pszClientDllName: ?PSTR,
|
|
pdwRMCookie: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
TranslateTridToXid: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcToXaMapper,
|
|
pdwITransaction: ?*u32,
|
|
dwRMCookie: u32,
|
|
pXid: ?*xid_t,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcToXaMapper,
|
|
pdwITransaction: ?*u32,
|
|
dwRMCookie: u32,
|
|
pXid: ?*xid_t,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
EnlistResourceManager: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcToXaMapper,
|
|
dwRMCookie: u32,
|
|
pdwITransaction: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcToXaMapper,
|
|
dwRMCookie: u32,
|
|
pdwITransaction: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ReleaseResourceManager: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcToXaMapper,
|
|
dwRMCookie: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcToXaMapper,
|
|
dwRMCookie: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcToXaMapper_RequestNewResourceManager(self: *const T, pszDSN: ?PSTR, pszClientDllName: ?PSTR, pdwRMCookie: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcToXaMapper.VTable, @ptrCast(self.vtable)).RequestNewResourceManager(@as(*const IDtcToXaMapper, @ptrCast(self)), pszDSN, pszClientDllName, pdwRMCookie);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcToXaMapper_TranslateTridToXid(self: *const T, pdwITransaction: ?*u32, dwRMCookie: u32, pXid: ?*xid_t) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcToXaMapper.VTable, @ptrCast(self.vtable)).TranslateTridToXid(@as(*const IDtcToXaMapper, @ptrCast(self)), pdwITransaction, dwRMCookie, pXid);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcToXaMapper_EnlistResourceManager(self: *const T, dwRMCookie: u32, pdwITransaction: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcToXaMapper.VTable, @ptrCast(self.vtable)).EnlistResourceManager(@as(*const IDtcToXaMapper, @ptrCast(self)), dwRMCookie, pdwITransaction);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcToXaMapper_ReleaseResourceManager(self: *const T, dwRMCookie: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcToXaMapper.VTable, @ptrCast(self.vtable)).ReleaseResourceManager(@as(*const IDtcToXaMapper, @ptrCast(self)), dwRMCookie);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IDtcToXaHelperFactory_Value = Guid.initString("a9861610-304a-11d1-9813-00a0c905416e");
|
|
pub const IID_IDtcToXaHelperFactory = &IID_IDtcToXaHelperFactory_Value;
|
|
pub const IDtcToXaHelperFactory = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Create: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcToXaHelperFactory,
|
|
pszDSN: ?PSTR,
|
|
pszClientDllName: ?PSTR,
|
|
pguidRm: ?*Guid,
|
|
ppXaHelper: ?*?*IDtcToXaHelper,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcToXaHelperFactory,
|
|
pszDSN: ?PSTR,
|
|
pszClientDllName: ?PSTR,
|
|
pguidRm: ?*Guid,
|
|
ppXaHelper: ?*?*IDtcToXaHelper,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcToXaHelperFactory_Create(self: *const T, pszDSN: ?PSTR, pszClientDllName: ?PSTR, pguidRm: ?*Guid, ppXaHelper: ?*?*IDtcToXaHelper) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcToXaHelperFactory.VTable, @ptrCast(self.vtable)).Create(@as(*const IDtcToXaHelperFactory, @ptrCast(self)), pszDSN, pszClientDllName, pguidRm, ppXaHelper);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IDtcToXaHelper_Value = Guid.initString("a9861611-304a-11d1-9813-00a0c905416e");
|
|
pub const IID_IDtcToXaHelper = &IID_IDtcToXaHelper_Value;
|
|
pub const IDtcToXaHelper = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Close: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcToXaHelper,
|
|
i_fDoRecovery: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcToXaHelper,
|
|
i_fDoRecovery: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
TranslateTridToXid: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcToXaHelper,
|
|
pITransaction: ?*ITransaction,
|
|
pguidBqual: ?*Guid,
|
|
pXid: ?*xid_t,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcToXaHelper,
|
|
pITransaction: ?*ITransaction,
|
|
pguidBqual: ?*Guid,
|
|
pXid: ?*xid_t,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcToXaHelper_Close(self: *const T, i_fDoRecovery: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcToXaHelper.VTable, @ptrCast(self.vtable)).Close(@as(*const IDtcToXaHelper, @ptrCast(self)), i_fDoRecovery);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcToXaHelper_TranslateTridToXid(self: *const T, pITransaction: ?*ITransaction, pguidBqual: ?*Guid, pXid: ?*xid_t) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcToXaHelper.VTable, @ptrCast(self.vtable)).TranslateTridToXid(@as(*const IDtcToXaHelper, @ptrCast(self)), pITransaction, pguidBqual, pXid);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IDtcToXaHelperSinglePipe_Value = Guid.initString("47ed4971-53b3-11d1-bbb9-00c04fd658f6");
|
|
pub const IID_IDtcToXaHelperSinglePipe = &IID_IDtcToXaHelperSinglePipe_Value;
|
|
pub const IDtcToXaHelperSinglePipe = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
XARMCreate: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcToXaHelperSinglePipe,
|
|
pszDSN: ?PSTR,
|
|
pszClientDll: ?PSTR,
|
|
pdwRMCookie: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcToXaHelperSinglePipe,
|
|
pszDSN: ?PSTR,
|
|
pszClientDll: ?PSTR,
|
|
pdwRMCookie: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ConvertTridToXID: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcToXaHelperSinglePipe,
|
|
pdwITrans: ?*u32,
|
|
dwRMCookie: u32,
|
|
pxid: ?*xid_t,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcToXaHelperSinglePipe,
|
|
pdwITrans: ?*u32,
|
|
dwRMCookie: u32,
|
|
pxid: ?*xid_t,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
EnlistWithRM: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcToXaHelperSinglePipe,
|
|
dwRMCookie: u32,
|
|
i_pITransaction: ?*ITransaction,
|
|
i_pITransRes: ?*ITransactionResourceAsync,
|
|
o_ppITransEnslitment: ?*?*ITransactionEnlistmentAsync,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcToXaHelperSinglePipe,
|
|
dwRMCookie: u32,
|
|
i_pITransaction: ?*ITransaction,
|
|
i_pITransRes: ?*ITransactionResourceAsync,
|
|
o_ppITransEnslitment: ?*?*ITransactionEnlistmentAsync,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ReleaseRMCookie: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcToXaHelperSinglePipe,
|
|
i_dwRMCookie: u32,
|
|
i_fNormal: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const IDtcToXaHelperSinglePipe,
|
|
i_dwRMCookie: u32,
|
|
i_fNormal: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcToXaHelperSinglePipe_XARMCreate(self: *const T, pszDSN: ?PSTR, pszClientDll: ?PSTR, pdwRMCookie: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcToXaHelperSinglePipe.VTable, @ptrCast(self.vtable)).XARMCreate(@as(*const IDtcToXaHelperSinglePipe, @ptrCast(self)), pszDSN, pszClientDll, pdwRMCookie);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcToXaHelperSinglePipe_ConvertTridToXID(self: *const T, pdwITrans: ?*u32, dwRMCookie: u32, pxid: ?*xid_t) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcToXaHelperSinglePipe.VTable, @ptrCast(self.vtable)).ConvertTridToXID(@as(*const IDtcToXaHelperSinglePipe, @ptrCast(self)), pdwITrans, dwRMCookie, pxid);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcToXaHelperSinglePipe_EnlistWithRM(self: *const T, dwRMCookie: u32, i_pITransaction: ?*ITransaction, i_pITransRes: ?*ITransactionResourceAsync, o_ppITransEnslitment: ?*?*ITransactionEnlistmentAsync) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcToXaHelperSinglePipe.VTable, @ptrCast(self.vtable)).EnlistWithRM(@as(*const IDtcToXaHelperSinglePipe, @ptrCast(self)), dwRMCookie, i_pITransaction, i_pITransRes, o_ppITransEnslitment);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcToXaHelperSinglePipe_ReleaseRMCookie(self: *const T, i_dwRMCookie: u32, i_fNormal: BOOL) callconv(.Inline) void {
|
|
return @as(*const IDtcToXaHelperSinglePipe.VTable, @ptrCast(self.vtable)).ReleaseRMCookie(@as(*const IDtcToXaHelperSinglePipe, @ptrCast(self)), i_dwRMCookie, i_fNormal);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
pub const APPLICATIONTYPE = enum(i32) {
|
|
LOCAL_APPLICATIONTYPE = 0,
|
|
CLUSTERRESOURCE_APPLICATIONTYPE = 1,
|
|
};
|
|
pub const LOCAL_APPLICATIONTYPE = APPLICATIONTYPE.LOCAL_APPLICATIONTYPE;
|
|
pub const CLUSTERRESOURCE_APPLICATIONTYPE = APPLICATIONTYPE.CLUSTERRESOURCE_APPLICATIONTYPE;
|
|
|
|
pub const OLE_TM_CONFIG_PARAMS_V1 = extern struct {
|
|
dwVersion: u32,
|
|
dwcConcurrencyHint: u32,
|
|
};
|
|
|
|
pub const OLE_TM_CONFIG_PARAMS_V2 = extern struct {
|
|
dwVersion: u32,
|
|
dwcConcurrencyHint: u32,
|
|
applicationType: APPLICATIONTYPE,
|
|
clusterResourceId: Guid,
|
|
};
|
|
|
|
pub const XACT_DTC_CONSTANTS = enum(i32) {
|
|
XACT_E_CONNECTION_REQUEST_DENIED = -2147168000,
|
|
XACT_E_TOOMANY_ENLISTMENTS = -2147167999,
|
|
XACT_E_DUPLICATE_GUID = -2147167998,
|
|
XACT_E_NOTSINGLEPHASE = -2147167997,
|
|
XACT_E_RECOVERYALREADYDONE = -2147167996,
|
|
XACT_E_PROTOCOL = -2147167995,
|
|
XACT_E_RM_FAILURE = -2147167994,
|
|
XACT_E_RECOVERY_FAILED = -2147167993,
|
|
XACT_E_LU_NOT_FOUND = -2147167992,
|
|
XACT_E_DUPLICATE_LU = -2147167991,
|
|
XACT_E_LU_NOT_CONNECTED = -2147167990,
|
|
XACT_E_DUPLICATE_TRANSID = -2147167989,
|
|
XACT_E_LU_BUSY = -2147167988,
|
|
XACT_E_LU_NO_RECOVERY_PROCESS = -2147167987,
|
|
XACT_E_LU_DOWN = -2147167986,
|
|
XACT_E_LU_RECOVERING = -2147167985,
|
|
XACT_E_LU_RECOVERY_MISMATCH = -2147167984,
|
|
XACT_E_RM_UNAVAILABLE = -2147167983,
|
|
XACT_E_LRMRECOVERYALREADYDONE = -2147167982,
|
|
XACT_E_NOLASTRESOURCEINTERFACE = -2147167981,
|
|
XACT_S_NONOTIFY = 315648,
|
|
XACT_OK_NONOTIFY = 315649,
|
|
dwUSER_MS_SQLSERVER = 65535,
|
|
};
|
|
pub const XACT_E_CONNECTION_REQUEST_DENIED = XACT_DTC_CONSTANTS.XACT_E_CONNECTION_REQUEST_DENIED;
|
|
pub const XACT_E_TOOMANY_ENLISTMENTS = XACT_DTC_CONSTANTS.XACT_E_TOOMANY_ENLISTMENTS;
|
|
pub const XACT_E_DUPLICATE_GUID = XACT_DTC_CONSTANTS.XACT_E_DUPLICATE_GUID;
|
|
pub const XACT_E_NOTSINGLEPHASE = XACT_DTC_CONSTANTS.XACT_E_NOTSINGLEPHASE;
|
|
pub const XACT_E_RECOVERYALREADYDONE = XACT_DTC_CONSTANTS.XACT_E_RECOVERYALREADYDONE;
|
|
pub const XACT_E_PROTOCOL = XACT_DTC_CONSTANTS.XACT_E_PROTOCOL;
|
|
pub const XACT_E_RM_FAILURE = XACT_DTC_CONSTANTS.XACT_E_RM_FAILURE;
|
|
pub const XACT_E_RECOVERY_FAILED = XACT_DTC_CONSTANTS.XACT_E_RECOVERY_FAILED;
|
|
pub const XACT_E_LU_NOT_FOUND = XACT_DTC_CONSTANTS.XACT_E_LU_NOT_FOUND;
|
|
pub const XACT_E_DUPLICATE_LU = XACT_DTC_CONSTANTS.XACT_E_DUPLICATE_LU;
|
|
pub const XACT_E_LU_NOT_CONNECTED = XACT_DTC_CONSTANTS.XACT_E_LU_NOT_CONNECTED;
|
|
pub const XACT_E_DUPLICATE_TRANSID = XACT_DTC_CONSTANTS.XACT_E_DUPLICATE_TRANSID;
|
|
pub const XACT_E_LU_BUSY = XACT_DTC_CONSTANTS.XACT_E_LU_BUSY;
|
|
pub const XACT_E_LU_NO_RECOVERY_PROCESS = XACT_DTC_CONSTANTS.XACT_E_LU_NO_RECOVERY_PROCESS;
|
|
pub const XACT_E_LU_DOWN = XACT_DTC_CONSTANTS.XACT_E_LU_DOWN;
|
|
pub const XACT_E_LU_RECOVERING = XACT_DTC_CONSTANTS.XACT_E_LU_RECOVERING;
|
|
pub const XACT_E_LU_RECOVERY_MISMATCH = XACT_DTC_CONSTANTS.XACT_E_LU_RECOVERY_MISMATCH;
|
|
pub const XACT_E_RM_UNAVAILABLE = XACT_DTC_CONSTANTS.XACT_E_RM_UNAVAILABLE;
|
|
pub const XACT_E_LRMRECOVERYALREADYDONE = XACT_DTC_CONSTANTS.XACT_E_LRMRECOVERYALREADYDONE;
|
|
pub const XACT_E_NOLASTRESOURCEINTERFACE = XACT_DTC_CONSTANTS.XACT_E_NOLASTRESOURCEINTERFACE;
|
|
pub const XACT_S_NONOTIFY = XACT_DTC_CONSTANTS.XACT_S_NONOTIFY;
|
|
pub const XACT_OK_NONOTIFY = XACT_DTC_CONSTANTS.XACT_OK_NONOTIFY;
|
|
pub const dwUSER_MS_SQLSERVER = XACT_DTC_CONSTANTS.dwUSER_MS_SQLSERVER;
|
|
|
|
const IID_IXATransLookup_Value = Guid.initString("f3b1f131-eeda-11ce-aed4-00aa0051e2c4");
|
|
pub const IID_IXATransLookup = &IID_IXATransLookup_Value;
|
|
pub const IXATransLookup = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Lookup: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IXATransLookup,
|
|
ppTransaction: ?*?*ITransaction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IXATransLookup,
|
|
ppTransaction: ?*?*ITransaction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IXATransLookup_Lookup(self: *const T, ppTransaction: ?*?*ITransaction) callconv(.Inline) HRESULT {
|
|
return @as(*const IXATransLookup.VTable, @ptrCast(self.vtable)).Lookup(@as(*const IXATransLookup, @ptrCast(self)), ppTransaction);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IXATransLookup2_Value = Guid.initString("bf193c85-0d1a-4290-b88f-d2cb8873d1e7");
|
|
pub const IID_IXATransLookup2 = &IID_IXATransLookup2_Value;
|
|
pub const IXATransLookup2 = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Lookup: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IXATransLookup2,
|
|
pXID: ?*xid_t,
|
|
ppTransaction: ?*?*ITransaction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IXATransLookup2,
|
|
pXID: ?*xid_t,
|
|
ppTransaction: ?*?*ITransaction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IXATransLookup2_Lookup(self: *const T, pXID: ?*xid_t, ppTransaction: ?*?*ITransaction) callconv(.Inline) HRESULT {
|
|
return @as(*const IXATransLookup2.VTable, @ptrCast(self.vtable)).Lookup(@as(*const IXATransLookup2, @ptrCast(self)), pXID, ppTransaction);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IResourceManagerSink_Value = Guid.initString("0d563181-defb-11ce-aed1-00aa0051e2c4");
|
|
pub const IID_IResourceManagerSink = &IID_IResourceManagerSink_Value;
|
|
pub const IResourceManagerSink = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
TMDown: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IResourceManagerSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IResourceManagerSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IResourceManagerSink_TMDown(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IResourceManagerSink.VTable, @ptrCast(self.vtable)).TMDown(@as(*const IResourceManagerSink, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IResourceManager_Value = Guid.initString("13741d21-87eb-11ce-8081-0080c758527e");
|
|
pub const IID_IResourceManager = &IID_IResourceManager_Value;
|
|
pub const IResourceManager = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Enlist: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IResourceManager,
|
|
pTransaction: ?*ITransaction,
|
|
pRes: ?*ITransactionResourceAsync,
|
|
pUOW: ?*BOID,
|
|
pisoLevel: ?*i32,
|
|
ppEnlist: ?*?*ITransactionEnlistmentAsync,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IResourceManager,
|
|
pTransaction: ?*ITransaction,
|
|
pRes: ?*ITransactionResourceAsync,
|
|
pUOW: ?*BOID,
|
|
pisoLevel: ?*i32,
|
|
ppEnlist: ?*?*ITransactionEnlistmentAsync,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Reenlist: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IResourceManager,
|
|
pPrepInfo: [*:0]u8,
|
|
cbPrepInfo: u32,
|
|
lTimeout: u32,
|
|
pXactStat: ?*XACTSTAT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IResourceManager,
|
|
pPrepInfo: [*:0]u8,
|
|
cbPrepInfo: u32,
|
|
lTimeout: u32,
|
|
pXactStat: ?*XACTSTAT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ReenlistmentComplete: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IResourceManager,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IResourceManager,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetDistributedTransactionManager: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IResourceManager,
|
|
iid: ?*const Guid,
|
|
ppvObject: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IResourceManager,
|
|
iid: ?*const Guid,
|
|
ppvObject: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IResourceManager_Enlist(self: *const T, pTransaction: ?*ITransaction, pRes: ?*ITransactionResourceAsync, pUOW: ?*BOID, pisoLevel: ?*i32, ppEnlist: ?*?*ITransactionEnlistmentAsync) callconv(.Inline) HRESULT {
|
|
return @as(*const IResourceManager.VTable, @ptrCast(self.vtable)).Enlist(@as(*const IResourceManager, @ptrCast(self)), pTransaction, pRes, pUOW, pisoLevel, ppEnlist);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IResourceManager_Reenlist(self: *const T, pPrepInfo: [*:0]u8, cbPrepInfo: u32, lTimeout: u32, pXactStat: ?*XACTSTAT) callconv(.Inline) HRESULT {
|
|
return @as(*const IResourceManager.VTable, @ptrCast(self.vtable)).Reenlist(@as(*const IResourceManager, @ptrCast(self)), pPrepInfo, cbPrepInfo, lTimeout, pXactStat);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IResourceManager_ReenlistmentComplete(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IResourceManager.VTable, @ptrCast(self.vtable)).ReenlistmentComplete(@as(*const IResourceManager, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IResourceManager_GetDistributedTransactionManager(self: *const T, iid: ?*const Guid, ppvObject: ?*?*anyopaque) callconv(.Inline) HRESULT {
|
|
return @as(*const IResourceManager.VTable, @ptrCast(self.vtable)).GetDistributedTransactionManager(@as(*const IResourceManager, @ptrCast(self)), iid, ppvObject);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ILastResourceManager_Value = Guid.initString("4d964ad4-5b33-11d3-8a91-00c04f79eb6d");
|
|
pub const IID_ILastResourceManager = &IID_ILastResourceManager_Value;
|
|
pub const ILastResourceManager = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
TransactionCommitted: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ILastResourceManager,
|
|
pPrepInfo: [*:0]u8,
|
|
cbPrepInfo: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ILastResourceManager,
|
|
pPrepInfo: [*:0]u8,
|
|
cbPrepInfo: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
RecoveryDone: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ILastResourceManager,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ILastResourceManager,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ILastResourceManager_TransactionCommitted(self: *const T, pPrepInfo: [*:0]u8, cbPrepInfo: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const ILastResourceManager.VTable, @ptrCast(self.vtable)).TransactionCommitted(@as(*const ILastResourceManager, @ptrCast(self)), pPrepInfo, cbPrepInfo);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ILastResourceManager_RecoveryDone(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ILastResourceManager.VTable, @ptrCast(self.vtable)).RecoveryDone(@as(*const ILastResourceManager, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IResourceManager2_Value = Guid.initString("d136c69a-f749-11d1-8f47-00c04f8ee57d");
|
|
pub const IID_IResourceManager2 = &IID_IResourceManager2_Value;
|
|
pub const IResourceManager2 = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IResourceManager.VTable,
|
|
Enlist2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IResourceManager2,
|
|
pTransaction: ?*ITransaction,
|
|
pResAsync: ?*ITransactionResourceAsync,
|
|
pUOW: ?*BOID,
|
|
pisoLevel: ?*i32,
|
|
pXid: ?*xid_t,
|
|
ppEnlist: ?*?*ITransactionEnlistmentAsync,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IResourceManager2,
|
|
pTransaction: ?*ITransaction,
|
|
pResAsync: ?*ITransactionResourceAsync,
|
|
pUOW: ?*BOID,
|
|
pisoLevel: ?*i32,
|
|
pXid: ?*xid_t,
|
|
ppEnlist: ?*?*ITransactionEnlistmentAsync,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Reenlist2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IResourceManager2,
|
|
pXid: ?*xid_t,
|
|
dwTimeout: u32,
|
|
pXactStat: ?*XACTSTAT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IResourceManager2,
|
|
pXid: ?*xid_t,
|
|
dwTimeout: u32,
|
|
pXactStat: ?*XACTSTAT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IResourceManager.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IResourceManager2_Enlist2(self: *const T, pTransaction: ?*ITransaction, pResAsync: ?*ITransactionResourceAsync, pUOW: ?*BOID, pisoLevel: ?*i32, pXid: ?*xid_t, ppEnlist: ?*?*ITransactionEnlistmentAsync) callconv(.Inline) HRESULT {
|
|
return @as(*const IResourceManager2.VTable, @ptrCast(self.vtable)).Enlist2(@as(*const IResourceManager2, @ptrCast(self)), pTransaction, pResAsync, pUOW, pisoLevel, pXid, ppEnlist);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IResourceManager2_Reenlist2(self: *const T, pXid: ?*xid_t, dwTimeout: u32, pXactStat: ?*XACTSTAT) callconv(.Inline) HRESULT {
|
|
return @as(*const IResourceManager2.VTable, @ptrCast(self.vtable)).Reenlist2(@as(*const IResourceManager2, @ptrCast(self)), pXid, dwTimeout, pXactStat);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IResourceManagerRejoinable_Value = Guid.initString("6f6de620-b5df-4f3e-9cfa-c8aebd05172b");
|
|
pub const IID_IResourceManagerRejoinable = &IID_IResourceManagerRejoinable_Value;
|
|
pub const IResourceManagerRejoinable = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IResourceManager2.VTable,
|
|
Rejoin: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IResourceManagerRejoinable,
|
|
pPrepInfo: [*:0]u8,
|
|
cbPrepInfo: u32,
|
|
lTimeout: u32,
|
|
pXactStat: ?*XACTSTAT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IResourceManagerRejoinable,
|
|
pPrepInfo: [*:0]u8,
|
|
cbPrepInfo: u32,
|
|
lTimeout: u32,
|
|
pXactStat: ?*XACTSTAT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IResourceManager2.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IResourceManagerRejoinable_Rejoin(self: *const T, pPrepInfo: [*:0]u8, cbPrepInfo: u32, lTimeout: u32, pXactStat: ?*XACTSTAT) callconv(.Inline) HRESULT {
|
|
return @as(*const IResourceManagerRejoinable.VTable, @ptrCast(self.vtable)).Rejoin(@as(*const IResourceManagerRejoinable, @ptrCast(self)), pPrepInfo, cbPrepInfo, lTimeout, pXactStat);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IXAConfig_Value = Guid.initString("c8a6e3a1-9a8c-11cf-a308-00a0c905416e");
|
|
pub const IID_IXAConfig = &IID_IXAConfig_Value;
|
|
pub const IXAConfig = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Initialize: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IXAConfig,
|
|
clsidHelperDll: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IXAConfig,
|
|
clsidHelperDll: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Terminate: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IXAConfig,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IXAConfig,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IXAConfig_Initialize(self: *const T, clsidHelperDll: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IXAConfig.VTable, @ptrCast(self.vtable)).Initialize(@as(*const IXAConfig, @ptrCast(self)), clsidHelperDll);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IXAConfig_Terminate(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IXAConfig.VTable, @ptrCast(self.vtable)).Terminate(@as(*const IXAConfig, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IRMHelper_Value = Guid.initString("e793f6d1-f53d-11cf-a60d-00a0c905416e");
|
|
pub const IID_IRMHelper = &IID_IRMHelper_Value;
|
|
pub const IRMHelper = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
RMCount: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRMHelper,
|
|
dwcTotalNumberOfRMs: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRMHelper,
|
|
dwcTotalNumberOfRMs: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
RMInfo: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRMHelper,
|
|
pXa_Switch: ?*xa_switch_t,
|
|
fCDeclCallingConv: BOOL,
|
|
pszOpenString: ?PSTR,
|
|
pszCloseString: ?PSTR,
|
|
guidRMRecovery: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRMHelper,
|
|
pXa_Switch: ?*xa_switch_t,
|
|
fCDeclCallingConv: BOOL,
|
|
pszOpenString: ?PSTR,
|
|
pszCloseString: ?PSTR,
|
|
guidRMRecovery: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IRMHelper_RMCount(self: *const T, dwcTotalNumberOfRMs: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IRMHelper.VTable, @ptrCast(self.vtable)).RMCount(@as(*const IRMHelper, @ptrCast(self)), dwcTotalNumberOfRMs);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IRMHelper_RMInfo(self: *const T, pXa_Switch: ?*xa_switch_t, fCDeclCallingConv: BOOL, pszOpenString: ?PSTR, pszCloseString: ?PSTR, guidRMRecovery: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IRMHelper.VTable, @ptrCast(self.vtable)).RMInfo(@as(*const IRMHelper, @ptrCast(self)), pXa_Switch, fCDeclCallingConv, pszOpenString, pszCloseString, guidRMRecovery);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IXAObtainRMInfo_Value = Guid.initString("e793f6d2-f53d-11cf-a60d-00a0c905416e");
|
|
pub const IID_IXAObtainRMInfo = &IID_IXAObtainRMInfo_Value;
|
|
pub const IXAObtainRMInfo = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
ObtainRMInfo: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IXAObtainRMInfo,
|
|
pIRMHelper: ?*IRMHelper,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IXAObtainRMInfo,
|
|
pIRMHelper: ?*IRMHelper,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IXAObtainRMInfo_ObtainRMInfo(self: *const T, pIRMHelper: ?*IRMHelper) callconv(.Inline) HRESULT {
|
|
return @as(*const IXAObtainRMInfo.VTable, @ptrCast(self.vtable)).ObtainRMInfo(@as(*const IXAObtainRMInfo, @ptrCast(self)), pIRMHelper);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IResourceManagerFactory_Value = Guid.initString("13741d20-87eb-11ce-8081-0080c758527e");
|
|
pub const IID_IResourceManagerFactory = &IID_IResourceManagerFactory_Value;
|
|
pub const IResourceManagerFactory = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Create: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IResourceManagerFactory,
|
|
pguidRM: ?*Guid,
|
|
pszRMName: ?PSTR,
|
|
pIResMgrSink: ?*IResourceManagerSink,
|
|
ppResMgr: ?*?*IResourceManager,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IResourceManagerFactory,
|
|
pguidRM: ?*Guid,
|
|
pszRMName: ?PSTR,
|
|
pIResMgrSink: ?*IResourceManagerSink,
|
|
ppResMgr: ?*?*IResourceManager,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IResourceManagerFactory_Create(self: *const T, pguidRM: ?*Guid, pszRMName: ?PSTR, pIResMgrSink: ?*IResourceManagerSink, ppResMgr: ?*?*IResourceManager) callconv(.Inline) HRESULT {
|
|
return @as(*const IResourceManagerFactory.VTable, @ptrCast(self.vtable)).Create(@as(*const IResourceManagerFactory, @ptrCast(self)), pguidRM, pszRMName, pIResMgrSink, ppResMgr);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IResourceManagerFactory2_Value = Guid.initString("6b369c21-fbd2-11d1-8f47-00c04f8ee57d");
|
|
pub const IID_IResourceManagerFactory2 = &IID_IResourceManagerFactory2_Value;
|
|
pub const IResourceManagerFactory2 = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IResourceManagerFactory.VTable,
|
|
CreateEx: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IResourceManagerFactory2,
|
|
pguidRM: ?*Guid,
|
|
pszRMName: ?PSTR,
|
|
pIResMgrSink: ?*IResourceManagerSink,
|
|
riidRequested: ?*const Guid,
|
|
ppvResMgr: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IResourceManagerFactory2,
|
|
pguidRM: ?*Guid,
|
|
pszRMName: ?PSTR,
|
|
pIResMgrSink: ?*IResourceManagerSink,
|
|
riidRequested: ?*const Guid,
|
|
ppvResMgr: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IResourceManagerFactory.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IResourceManagerFactory2_CreateEx(self: *const T, pguidRM: ?*Guid, pszRMName: ?PSTR, pIResMgrSink: ?*IResourceManagerSink, riidRequested: ?*const Guid, ppvResMgr: ?*?*anyopaque) callconv(.Inline) HRESULT {
|
|
return @as(*const IResourceManagerFactory2.VTable, @ptrCast(self.vtable)).CreateEx(@as(*const IResourceManagerFactory2, @ptrCast(self)), pguidRM, pszRMName, pIResMgrSink, riidRequested, ppvResMgr);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IPrepareInfo_Value = Guid.initString("80c7bfd0-87ee-11ce-8081-0080c758527e");
|
|
pub const IID_IPrepareInfo = &IID_IPrepareInfo_Value;
|
|
pub const IPrepareInfo = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetPrepareInfoSize: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IPrepareInfo,
|
|
pcbPrepInfo: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IPrepareInfo,
|
|
pcbPrepInfo: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetPrepareInfo: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IPrepareInfo,
|
|
pPrepInfo: ?*u8,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IPrepareInfo,
|
|
pPrepInfo: ?*u8,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IPrepareInfo_GetPrepareInfoSize(self: *const T, pcbPrepInfo: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IPrepareInfo.VTable, @ptrCast(self.vtable)).GetPrepareInfoSize(@as(*const IPrepareInfo, @ptrCast(self)), pcbPrepInfo);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IPrepareInfo_GetPrepareInfo(self: *const T, pPrepInfo: ?*u8) callconv(.Inline) HRESULT {
|
|
return @as(*const IPrepareInfo.VTable, @ptrCast(self.vtable)).GetPrepareInfo(@as(*const IPrepareInfo, @ptrCast(self)), pPrepInfo);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IPrepareInfo2_Value = Guid.initString("5fab2547-9779-11d1-b886-00c04fb9618a");
|
|
pub const IID_IPrepareInfo2 = &IID_IPrepareInfo2_Value;
|
|
pub const IPrepareInfo2 = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetPrepareInfoSize: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IPrepareInfo2,
|
|
pcbPrepInfo: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IPrepareInfo2,
|
|
pcbPrepInfo: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetPrepareInfo: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IPrepareInfo2,
|
|
cbPrepareInfo: u32,
|
|
pPrepInfo: [*:0]u8,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IPrepareInfo2,
|
|
cbPrepareInfo: u32,
|
|
pPrepInfo: [*:0]u8,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IPrepareInfo2_GetPrepareInfoSize(self: *const T, pcbPrepInfo: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IPrepareInfo2.VTable, @ptrCast(self.vtable)).GetPrepareInfoSize(@as(*const IPrepareInfo2, @ptrCast(self)), pcbPrepInfo);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IPrepareInfo2_GetPrepareInfo(self: *const T, cbPrepareInfo: u32, pPrepInfo: [*:0]u8) callconv(.Inline) HRESULT {
|
|
return @as(*const IPrepareInfo2.VTable, @ptrCast(self.vtable)).GetPrepareInfo(@as(*const IPrepareInfo2, @ptrCast(self)), cbPrepareInfo, pPrepInfo);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IGetDispenser_Value = Guid.initString("c23cc370-87ef-11ce-8081-0080c758527e");
|
|
pub const IID_IGetDispenser = &IID_IGetDispenser_Value;
|
|
pub const IGetDispenser = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetDispenser: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IGetDispenser,
|
|
iid: ?*const Guid,
|
|
ppvObject: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IGetDispenser,
|
|
iid: ?*const Guid,
|
|
ppvObject: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IGetDispenser_GetDispenser(self: *const T, iid: ?*const Guid, ppvObject: ?*?*anyopaque) callconv(.Inline) HRESULT {
|
|
return @as(*const IGetDispenser.VTable, @ptrCast(self.vtable)).GetDispenser(@as(*const IGetDispenser, @ptrCast(self)), iid, ppvObject);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionVoterBallotAsync2_Value = Guid.initString("5433376c-414d-11d3-b206-00c04fc2f3ef");
|
|
pub const IID_ITransactionVoterBallotAsync2 = &IID_ITransactionVoterBallotAsync2_Value;
|
|
pub const ITransactionVoterBallotAsync2 = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
VoteRequestDone: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionVoterBallotAsync2,
|
|
hr: HRESULT,
|
|
pboidReason: ?*BOID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionVoterBallotAsync2,
|
|
hr: HRESULT,
|
|
pboidReason: ?*BOID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionVoterBallotAsync2_VoteRequestDone(self: *const T, hr: HRESULT, pboidReason: ?*BOID) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionVoterBallotAsync2.VTable, @ptrCast(self.vtable)).VoteRequestDone(@as(*const ITransactionVoterBallotAsync2, @ptrCast(self)), hr, pboidReason);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionVoterNotifyAsync2_Value = Guid.initString("5433376b-414d-11d3-b206-00c04fc2f3ef");
|
|
pub const IID_ITransactionVoterNotifyAsync2 = &IID_ITransactionVoterNotifyAsync2_Value;
|
|
pub const ITransactionVoterNotifyAsync2 = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: ITransactionOutcomeEvents.VTable,
|
|
VoteRequest: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionVoterNotifyAsync2,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionVoterNotifyAsync2,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace ITransactionOutcomeEvents.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionVoterNotifyAsync2_VoteRequest(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionVoterNotifyAsync2.VTable, @ptrCast(self.vtable)).VoteRequest(@as(*const ITransactionVoterNotifyAsync2, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionVoterFactory2_Value = Guid.initString("5433376a-414d-11d3-b206-00c04fc2f3ef");
|
|
pub const IID_ITransactionVoterFactory2 = &IID_ITransactionVoterFactory2_Value;
|
|
pub const ITransactionVoterFactory2 = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Create: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionVoterFactory2,
|
|
pTransaction: ?*ITransaction,
|
|
pVoterNotify: ?*ITransactionVoterNotifyAsync2,
|
|
ppVoterBallot: ?*?*ITransactionVoterBallotAsync2,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionVoterFactory2,
|
|
pTransaction: ?*ITransaction,
|
|
pVoterNotify: ?*ITransactionVoterNotifyAsync2,
|
|
ppVoterBallot: ?*?*ITransactionVoterBallotAsync2,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionVoterFactory2_Create(self: *const T, pTransaction: ?*ITransaction, pVoterNotify: ?*ITransactionVoterNotifyAsync2, ppVoterBallot: ?*?*ITransactionVoterBallotAsync2) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionVoterFactory2.VTable, @ptrCast(self.vtable)).Create(@as(*const ITransactionVoterFactory2, @ptrCast(self)), pTransaction, pVoterNotify, ppVoterBallot);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionPhase0EnlistmentAsync_Value = Guid.initString("82dc88e1-a954-11d1-8f88-00600895e7d5");
|
|
pub const IID_ITransactionPhase0EnlistmentAsync = &IID_ITransactionPhase0EnlistmentAsync_Value;
|
|
pub const ITransactionPhase0EnlistmentAsync = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Enable: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionPhase0EnlistmentAsync,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionPhase0EnlistmentAsync,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
WaitForEnlistment: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionPhase0EnlistmentAsync,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionPhase0EnlistmentAsync,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Phase0Done: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionPhase0EnlistmentAsync,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionPhase0EnlistmentAsync,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Unenlist: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionPhase0EnlistmentAsync,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionPhase0EnlistmentAsync,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetTransaction: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionPhase0EnlistmentAsync,
|
|
ppITransaction: ?*?*ITransaction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionPhase0EnlistmentAsync,
|
|
ppITransaction: ?*?*ITransaction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionPhase0EnlistmentAsync_Enable(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionPhase0EnlistmentAsync.VTable, @ptrCast(self.vtable)).Enable(@as(*const ITransactionPhase0EnlistmentAsync, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionPhase0EnlistmentAsync_WaitForEnlistment(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionPhase0EnlistmentAsync.VTable, @ptrCast(self.vtable)).WaitForEnlistment(@as(*const ITransactionPhase0EnlistmentAsync, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionPhase0EnlistmentAsync_Phase0Done(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionPhase0EnlistmentAsync.VTable, @ptrCast(self.vtable)).Phase0Done(@as(*const ITransactionPhase0EnlistmentAsync, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionPhase0EnlistmentAsync_Unenlist(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionPhase0EnlistmentAsync.VTable, @ptrCast(self.vtable)).Unenlist(@as(*const ITransactionPhase0EnlistmentAsync, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionPhase0EnlistmentAsync_GetTransaction(self: *const T, ppITransaction: ?*?*ITransaction) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionPhase0EnlistmentAsync.VTable, @ptrCast(self.vtable)).GetTransaction(@as(*const ITransactionPhase0EnlistmentAsync, @ptrCast(self)), ppITransaction);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionPhase0NotifyAsync_Value = Guid.initString("ef081809-0c76-11d2-87a6-00c04f990f34");
|
|
pub const IID_ITransactionPhase0NotifyAsync = &IID_ITransactionPhase0NotifyAsync_Value;
|
|
pub const ITransactionPhase0NotifyAsync = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Phase0Request: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionPhase0NotifyAsync,
|
|
fAbortingHint: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionPhase0NotifyAsync,
|
|
fAbortingHint: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
EnlistCompleted: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionPhase0NotifyAsync,
|
|
status: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionPhase0NotifyAsync,
|
|
status: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionPhase0NotifyAsync_Phase0Request(self: *const T, fAbortingHint: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionPhase0NotifyAsync.VTable, @ptrCast(self.vtable)).Phase0Request(@as(*const ITransactionPhase0NotifyAsync, @ptrCast(self)), fAbortingHint);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionPhase0NotifyAsync_EnlistCompleted(self: *const T, status: HRESULT) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionPhase0NotifyAsync.VTable, @ptrCast(self.vtable)).EnlistCompleted(@as(*const ITransactionPhase0NotifyAsync, @ptrCast(self)), status);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionPhase0Factory_Value = Guid.initString("82dc88e0-a954-11d1-8f88-00600895e7d5");
|
|
pub const IID_ITransactionPhase0Factory = &IID_ITransactionPhase0Factory_Value;
|
|
pub const ITransactionPhase0Factory = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Create: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionPhase0Factory,
|
|
pPhase0Notify: ?*ITransactionPhase0NotifyAsync,
|
|
ppPhase0Enlistment: ?*?*ITransactionPhase0EnlistmentAsync,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionPhase0Factory,
|
|
pPhase0Notify: ?*ITransactionPhase0NotifyAsync,
|
|
ppPhase0Enlistment: ?*?*ITransactionPhase0EnlistmentAsync,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionPhase0Factory_Create(self: *const T, pPhase0Notify: ?*ITransactionPhase0NotifyAsync, ppPhase0Enlistment: ?*?*ITransactionPhase0EnlistmentAsync) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionPhase0Factory.VTable, @ptrCast(self.vtable)).Create(@as(*const ITransactionPhase0Factory, @ptrCast(self)), pPhase0Notify, ppPhase0Enlistment);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionTransmitter_Value = Guid.initString("59313e01-b36c-11cf-a539-00aa006887c3");
|
|
pub const IID_ITransactionTransmitter = &IID_ITransactionTransmitter_Value;
|
|
pub const ITransactionTransmitter = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Set: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionTransmitter,
|
|
pTransaction: ?*ITransaction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionTransmitter,
|
|
pTransaction: ?*ITransaction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetPropagationTokenSize: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionTransmitter,
|
|
pcbToken: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionTransmitter,
|
|
pcbToken: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
MarshalPropagationToken: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionTransmitter,
|
|
cbToken: u32,
|
|
rgbToken: [*:0]u8,
|
|
pcbUsed: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionTransmitter,
|
|
cbToken: u32,
|
|
rgbToken: [*:0]u8,
|
|
pcbUsed: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
UnmarshalReturnToken: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionTransmitter,
|
|
cbReturnToken: u32,
|
|
rgbReturnToken: [*:0]u8,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionTransmitter,
|
|
cbReturnToken: u32,
|
|
rgbReturnToken: [*:0]u8,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Reset: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionTransmitter,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionTransmitter,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionTransmitter_Set(self: *const T, pTransaction: ?*ITransaction) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionTransmitter.VTable, @ptrCast(self.vtable)).Set(@as(*const ITransactionTransmitter, @ptrCast(self)), pTransaction);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionTransmitter_GetPropagationTokenSize(self: *const T, pcbToken: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionTransmitter.VTable, @ptrCast(self.vtable)).GetPropagationTokenSize(@as(*const ITransactionTransmitter, @ptrCast(self)), pcbToken);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionTransmitter_MarshalPropagationToken(self: *const T, cbToken: u32, rgbToken: [*:0]u8, pcbUsed: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionTransmitter.VTable, @ptrCast(self.vtable)).MarshalPropagationToken(@as(*const ITransactionTransmitter, @ptrCast(self)), cbToken, rgbToken, pcbUsed);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionTransmitter_UnmarshalReturnToken(self: *const T, cbReturnToken: u32, rgbReturnToken: [*:0]u8) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionTransmitter.VTable, @ptrCast(self.vtable)).UnmarshalReturnToken(@as(*const ITransactionTransmitter, @ptrCast(self)), cbReturnToken, rgbReturnToken);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionTransmitter_Reset(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionTransmitter.VTable, @ptrCast(self.vtable)).Reset(@as(*const ITransactionTransmitter, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionTransmitterFactory_Value = Guid.initString("59313e00-b36c-11cf-a539-00aa006887c3");
|
|
pub const IID_ITransactionTransmitterFactory = &IID_ITransactionTransmitterFactory_Value;
|
|
pub const ITransactionTransmitterFactory = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Create: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionTransmitterFactory,
|
|
ppTransmitter: ?*?*ITransactionTransmitter,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionTransmitterFactory,
|
|
ppTransmitter: ?*?*ITransactionTransmitter,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionTransmitterFactory_Create(self: *const T, ppTransmitter: ?*?*ITransactionTransmitter) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionTransmitterFactory.VTable, @ptrCast(self.vtable)).Create(@as(*const ITransactionTransmitterFactory, @ptrCast(self)), ppTransmitter);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionReceiver_Value = Guid.initString("59313e03-b36c-11cf-a539-00aa006887c3");
|
|
pub const IID_ITransactionReceiver = &IID_ITransactionReceiver_Value;
|
|
pub const ITransactionReceiver = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
UnmarshalPropagationToken: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionReceiver,
|
|
cbToken: u32,
|
|
rgbToken: [*:0]u8,
|
|
ppTransaction: ?*?*ITransaction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionReceiver,
|
|
cbToken: u32,
|
|
rgbToken: [*:0]u8,
|
|
ppTransaction: ?*?*ITransaction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetReturnTokenSize: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionReceiver,
|
|
pcbReturnToken: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionReceiver,
|
|
pcbReturnToken: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
MarshalReturnToken: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionReceiver,
|
|
cbReturnToken: u32,
|
|
rgbReturnToken: [*:0]u8,
|
|
pcbUsed: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionReceiver,
|
|
cbReturnToken: u32,
|
|
rgbReturnToken: [*:0]u8,
|
|
pcbUsed: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Reset: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionReceiver,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionReceiver,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionReceiver_UnmarshalPropagationToken(self: *const T, cbToken: u32, rgbToken: [*:0]u8, ppTransaction: ?*?*ITransaction) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionReceiver.VTable, @ptrCast(self.vtable)).UnmarshalPropagationToken(@as(*const ITransactionReceiver, @ptrCast(self)), cbToken, rgbToken, ppTransaction);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionReceiver_GetReturnTokenSize(self: *const T, pcbReturnToken: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionReceiver.VTable, @ptrCast(self.vtable)).GetReturnTokenSize(@as(*const ITransactionReceiver, @ptrCast(self)), pcbReturnToken);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionReceiver_MarshalReturnToken(self: *const T, cbReturnToken: u32, rgbReturnToken: [*:0]u8, pcbUsed: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionReceiver.VTable, @ptrCast(self.vtable)).MarshalReturnToken(@as(*const ITransactionReceiver, @ptrCast(self)), cbReturnToken, rgbReturnToken, pcbUsed);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionReceiver_Reset(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionReceiver.VTable, @ptrCast(self.vtable)).Reset(@as(*const ITransactionReceiver, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITransactionReceiverFactory_Value = Guid.initString("59313e02-b36c-11cf-a539-00aa006887c3");
|
|
pub const IID_ITransactionReceiverFactory = &IID_ITransactionReceiverFactory_Value;
|
|
pub const ITransactionReceiverFactory = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Create: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionReceiverFactory,
|
|
ppReceiver: ?*?*ITransactionReceiver,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionReceiverFactory,
|
|
ppReceiver: ?*?*ITransactionReceiver,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionReceiverFactory_Create(self: *const T, ppReceiver: ?*?*ITransactionReceiver) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionReceiverFactory.VTable, @ptrCast(self.vtable)).Create(@as(*const ITransactionReceiverFactory, @ptrCast(self)), ppReceiver);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
pub const _ProxyConfigParams = extern struct {
|
|
wcThreadsMax: u16,
|
|
};
|
|
|
|
const IID_IDtcLuConfigure_Value = Guid.initString("4131e760-1aea-11d0-944b-00a0c905416e");
|
|
pub const IID_IDtcLuConfigure = &IID_IDtcLuConfigure_Value;
|
|
pub const IDtcLuConfigure = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Add: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuConfigure,
|
|
pucLuPair: [*:0]u8,
|
|
cbLuPair: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuConfigure,
|
|
pucLuPair: [*:0]u8,
|
|
cbLuPair: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Delete: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuConfigure,
|
|
pucLuPair: [*:0]u8,
|
|
cbLuPair: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuConfigure,
|
|
pucLuPair: [*:0]u8,
|
|
cbLuPair: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuConfigure_Add(self: *const T, pucLuPair: [*:0]u8, cbLuPair: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuConfigure.VTable, @ptrCast(self.vtable)).Add(@as(*const IDtcLuConfigure, @ptrCast(self)), pucLuPair, cbLuPair);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuConfigure_Delete(self: *const T, pucLuPair: [*:0]u8, cbLuPair: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuConfigure.VTable, @ptrCast(self.vtable)).Delete(@as(*const IDtcLuConfigure, @ptrCast(self)), pucLuPair, cbLuPair);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IDtcLuRecovery_Value = Guid.initString("ac2b8ad2-d6f0-11d0-b386-00a0c9083365");
|
|
pub const IID_IDtcLuRecovery = &IID_IDtcLuRecovery_Value;
|
|
pub const IDtcLuRecovery = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IDtcLuRecoveryFactory_Value = Guid.initString("4131e762-1aea-11d0-944b-00a0c905416e");
|
|
pub const IID_IDtcLuRecoveryFactory = &IID_IDtcLuRecoveryFactory_Value;
|
|
pub const IDtcLuRecoveryFactory = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Create: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryFactory,
|
|
pucLuPair: [*:0]u8,
|
|
cbLuPair: u32,
|
|
ppRecovery: ?*?*IDtcLuRecovery,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryFactory,
|
|
pucLuPair: [*:0]u8,
|
|
cbLuPair: u32,
|
|
ppRecovery: ?*?*IDtcLuRecovery,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryFactory_Create(self: *const T, pucLuPair: [*:0]u8, cbLuPair: u32, ppRecovery: ?*?*IDtcLuRecovery) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryFactory.VTable, @ptrCast(self.vtable)).Create(@as(*const IDtcLuRecoveryFactory, @ptrCast(self)), pucLuPair, cbLuPair, ppRecovery);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
pub const _DtcLu_LocalRecovery_Work = enum(i32) {
|
|
CHECKLUSTATUS = 1,
|
|
TRANS = 2,
|
|
TMDOWN = 3,
|
|
};
|
|
pub const DTCINITIATEDRECOVERYWORK_CHECKLUSTATUS = _DtcLu_LocalRecovery_Work.CHECKLUSTATUS;
|
|
pub const DTCINITIATEDRECOVERYWORK_TRANS = _DtcLu_LocalRecovery_Work.TRANS;
|
|
pub const DTCINITIATEDRECOVERYWORK_TMDOWN = _DtcLu_LocalRecovery_Work.TMDOWN;
|
|
|
|
pub const _DtcLu_Xln = enum(i32) {
|
|
COLD = 1,
|
|
WARM = 2,
|
|
};
|
|
pub const DTCLUXLN_COLD = _DtcLu_Xln.COLD;
|
|
pub const DTCLUXLN_WARM = _DtcLu_Xln.WARM;
|
|
|
|
pub const _DtcLu_Xln_Confirmation = enum(i32) {
|
|
CONFIRM = 1,
|
|
LOGNAMEMISMATCH = 2,
|
|
COLDWARMMISMATCH = 3,
|
|
OBSOLETE = 4,
|
|
};
|
|
pub const DTCLUXLNCONFIRMATION_CONFIRM = _DtcLu_Xln_Confirmation.CONFIRM;
|
|
pub const DTCLUXLNCONFIRMATION_LOGNAMEMISMATCH = _DtcLu_Xln_Confirmation.LOGNAMEMISMATCH;
|
|
pub const DTCLUXLNCONFIRMATION_COLDWARMMISMATCH = _DtcLu_Xln_Confirmation.COLDWARMMISMATCH;
|
|
pub const DTCLUXLNCONFIRMATION_OBSOLETE = _DtcLu_Xln_Confirmation.OBSOLETE;
|
|
|
|
pub const _DtcLu_Xln_Response = enum(i32) {
|
|
OK_SENDOURXLNBACK = 1,
|
|
OK_SENDCONFIRMATION = 2,
|
|
LOGNAMEMISMATCH = 3,
|
|
COLDWARMMISMATCH = 4,
|
|
};
|
|
pub const DTCLUXLNRESPONSE_OK_SENDOURXLNBACK = _DtcLu_Xln_Response.OK_SENDOURXLNBACK;
|
|
pub const DTCLUXLNRESPONSE_OK_SENDCONFIRMATION = _DtcLu_Xln_Response.OK_SENDCONFIRMATION;
|
|
pub const DTCLUXLNRESPONSE_LOGNAMEMISMATCH = _DtcLu_Xln_Response.LOGNAMEMISMATCH;
|
|
pub const DTCLUXLNRESPONSE_COLDWARMMISMATCH = _DtcLu_Xln_Response.COLDWARMMISMATCH;
|
|
|
|
pub const _DtcLu_Xln_Error = enum(i32) {
|
|
PROTOCOL = 1,
|
|
LOGNAMEMISMATCH = 2,
|
|
COLDWARMMISMATCH = 3,
|
|
};
|
|
pub const DTCLUXLNERROR_PROTOCOL = _DtcLu_Xln_Error.PROTOCOL;
|
|
pub const DTCLUXLNERROR_LOGNAMEMISMATCH = _DtcLu_Xln_Error.LOGNAMEMISMATCH;
|
|
pub const DTCLUXLNERROR_COLDWARMMISMATCH = _DtcLu_Xln_Error.COLDWARMMISMATCH;
|
|
|
|
pub const _DtcLu_CompareState = enum(i32) {
|
|
COMMITTED = 1,
|
|
HEURISTICCOMMITTED = 2,
|
|
HEURISTICMIXED = 3,
|
|
HEURISTICRESET = 4,
|
|
INDOUBT = 5,
|
|
RESET = 6,
|
|
};
|
|
pub const DTCLUCOMPARESTATE_COMMITTED = _DtcLu_CompareState.COMMITTED;
|
|
pub const DTCLUCOMPARESTATE_HEURISTICCOMMITTED = _DtcLu_CompareState.HEURISTICCOMMITTED;
|
|
pub const DTCLUCOMPARESTATE_HEURISTICMIXED = _DtcLu_CompareState.HEURISTICMIXED;
|
|
pub const DTCLUCOMPARESTATE_HEURISTICRESET = _DtcLu_CompareState.HEURISTICRESET;
|
|
pub const DTCLUCOMPARESTATE_INDOUBT = _DtcLu_CompareState.INDOUBT;
|
|
pub const DTCLUCOMPARESTATE_RESET = _DtcLu_CompareState.RESET;
|
|
|
|
pub const _DtcLu_CompareStates_Confirmation = enum(i32) {
|
|
CONFIRM = 1,
|
|
PROTOCOL = 2,
|
|
};
|
|
pub const DTCLUCOMPARESTATESCONFIRMATION_CONFIRM = _DtcLu_CompareStates_Confirmation.CONFIRM;
|
|
pub const DTCLUCOMPARESTATESCONFIRMATION_PROTOCOL = _DtcLu_CompareStates_Confirmation.PROTOCOL;
|
|
|
|
pub const _DtcLu_CompareStates_Error = enum(i32) {
|
|
L = 1,
|
|
};
|
|
pub const DTCLUCOMPARESTATESERROR_PROTOCOL = _DtcLu_CompareStates_Error.L;
|
|
|
|
pub const _DtcLu_CompareStates_Response = enum(i32) {
|
|
OK = 1,
|
|
PROTOCOL = 2,
|
|
};
|
|
pub const DTCLUCOMPARESTATESRESPONSE_OK = _DtcLu_CompareStates_Response.OK;
|
|
pub const DTCLUCOMPARESTATESRESPONSE_PROTOCOL = _DtcLu_CompareStates_Response.PROTOCOL;
|
|
|
|
const IID_IDtcLuRecoveryInitiatedByDtcTransWork_Value = Guid.initString("4131e765-1aea-11d0-944b-00a0c905416e");
|
|
pub const IID_IDtcLuRecoveryInitiatedByDtcTransWork = &IID_IDtcLuRecoveryInitiatedByDtcTransWork_Value;
|
|
pub const IDtcLuRecoveryInitiatedByDtcTransWork = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetLogNameSizes: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
pcbOurLogName: ?*u32,
|
|
pcbRemoteLogName: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
pcbOurLogName: ?*u32,
|
|
pcbRemoteLogName: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetOurXln: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
pXln: ?*_DtcLu_Xln,
|
|
pOurLogName: ?*u8,
|
|
pRemoteLogName: ?*u8,
|
|
pdwProtocol: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
pXln: ?*_DtcLu_Xln,
|
|
pOurLogName: ?*u8,
|
|
pRemoteLogName: ?*u8,
|
|
pdwProtocol: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
HandleConfirmationFromOurXln: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
Confirmation: _DtcLu_Xln_Confirmation,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
Confirmation: _DtcLu_Xln_Confirmation,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
HandleTheirXlnResponse: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
Xln: _DtcLu_Xln,
|
|
pRemoteLogName: ?*u8,
|
|
cbRemoteLogName: u32,
|
|
dwProtocol: u32,
|
|
pConfirmation: ?*_DtcLu_Xln_Confirmation,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
Xln: _DtcLu_Xln,
|
|
pRemoteLogName: ?*u8,
|
|
cbRemoteLogName: u32,
|
|
dwProtocol: u32,
|
|
pConfirmation: ?*_DtcLu_Xln_Confirmation,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
HandleErrorFromOurXln: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
Error: _DtcLu_Xln_Error,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
Error: _DtcLu_Xln_Error,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CheckForCompareStates: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
fCompareStates: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
fCompareStates: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetOurTransIdSize: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
pcbOurTransId: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
pcbOurTransId: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetOurCompareStates: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
pOurTransId: ?*u8,
|
|
pCompareState: ?*_DtcLu_CompareState,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
pOurTransId: ?*u8,
|
|
pCompareState: ?*_DtcLu_CompareState,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
HandleTheirCompareStatesResponse: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
CompareState: _DtcLu_CompareState,
|
|
pConfirmation: ?*_DtcLu_CompareStates_Confirmation,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
CompareState: _DtcLu_CompareState,
|
|
pConfirmation: ?*_DtcLu_CompareStates_Confirmation,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
HandleErrorFromOurCompareStates: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
Error: _DtcLu_CompareStates_Error,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
Error: _DtcLu_CompareStates_Error,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ConversationLost: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetRecoverySeqNum: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
plRecoverySeqNum: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
plRecoverySeqNum: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ObsoleteRecoverySeqNum: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
lNewRecoverySeqNum: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
|
|
lNewRecoverySeqNum: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByDtcTransWork_GetLogNameSizes(self: *const T, pcbOurLogName: ?*u32, pcbRemoteLogName: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).GetLogNameSizes(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), pcbOurLogName, pcbRemoteLogName);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByDtcTransWork_GetOurXln(self: *const T, pXln: ?*_DtcLu_Xln, pOurLogName: ?*u8, pRemoteLogName: ?*u8, pdwProtocol: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).GetOurXln(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), pXln, pOurLogName, pRemoteLogName, pdwProtocol);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByDtcTransWork_HandleConfirmationFromOurXln(self: *const T, Confirmation: _DtcLu_Xln_Confirmation) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).HandleConfirmationFromOurXln(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), Confirmation);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByDtcTransWork_HandleTheirXlnResponse(self: *const T, Xln: _DtcLu_Xln, pRemoteLogName: ?*u8, cbRemoteLogName: u32, dwProtocol: u32, pConfirmation: ?*_DtcLu_Xln_Confirmation) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).HandleTheirXlnResponse(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), Xln, pRemoteLogName, cbRemoteLogName, dwProtocol, pConfirmation);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByDtcTransWork_HandleErrorFromOurXln(self: *const T, Error: _DtcLu_Xln_Error) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).HandleErrorFromOurXln(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), Error);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByDtcTransWork_CheckForCompareStates(self: *const T, fCompareStates: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).CheckForCompareStates(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), fCompareStates);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByDtcTransWork_GetOurTransIdSize(self: *const T, pcbOurTransId: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).GetOurTransIdSize(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), pcbOurTransId);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByDtcTransWork_GetOurCompareStates(self: *const T, pOurTransId: ?*u8, pCompareState: ?*_DtcLu_CompareState) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).GetOurCompareStates(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), pOurTransId, pCompareState);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByDtcTransWork_HandleTheirCompareStatesResponse(self: *const T, CompareState: _DtcLu_CompareState, pConfirmation: ?*_DtcLu_CompareStates_Confirmation) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).HandleTheirCompareStatesResponse(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), CompareState, pConfirmation);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByDtcTransWork_HandleErrorFromOurCompareStates(self: *const T, Error: _DtcLu_CompareStates_Error) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).HandleErrorFromOurCompareStates(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), Error);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByDtcTransWork_ConversationLost(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).ConversationLost(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByDtcTransWork_GetRecoverySeqNum(self: *const T, plRecoverySeqNum: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).GetRecoverySeqNum(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), plRecoverySeqNum);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByDtcTransWork_ObsoleteRecoverySeqNum(self: *const T, lNewRecoverySeqNum: i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).ObsoleteRecoverySeqNum(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), lNewRecoverySeqNum);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IDtcLuRecoveryInitiatedByDtcStatusWork_Value = Guid.initString("4131e766-1aea-11d0-944b-00a0c905416e");
|
|
pub const IID_IDtcLuRecoveryInitiatedByDtcStatusWork = &IID_IDtcLuRecoveryInitiatedByDtcStatusWork_Value;
|
|
pub const IDtcLuRecoveryInitiatedByDtcStatusWork = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
HandleCheckLuStatus: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcStatusWork,
|
|
lRecoverySeqNum: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtcStatusWork,
|
|
lRecoverySeqNum: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByDtcStatusWork_HandleCheckLuStatus(self: *const T, lRecoverySeqNum: i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByDtcStatusWork.VTable, @ptrCast(self.vtable)).HandleCheckLuStatus(@as(*const IDtcLuRecoveryInitiatedByDtcStatusWork, @ptrCast(self)), lRecoverySeqNum);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IDtcLuRecoveryInitiatedByDtc_Value = Guid.initString("4131e764-1aea-11d0-944b-00a0c905416e");
|
|
pub const IID_IDtcLuRecoveryInitiatedByDtc = &IID_IDtcLuRecoveryInitiatedByDtc_Value;
|
|
pub const IDtcLuRecoveryInitiatedByDtc = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetWork: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtc,
|
|
pWork: ?*_DtcLu_LocalRecovery_Work,
|
|
ppv: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByDtc,
|
|
pWork: ?*_DtcLu_LocalRecovery_Work,
|
|
ppv: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByDtc_GetWork(self: *const T, pWork: ?*_DtcLu_LocalRecovery_Work, ppv: ?*?*anyopaque) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByDtc.VTable, @ptrCast(self.vtable)).GetWork(@as(*const IDtcLuRecoveryInitiatedByDtc, @ptrCast(self)), pWork, ppv);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IDtcLuRecoveryInitiatedByLuWork_Value = Guid.initString("ac2b8ad1-d6f0-11d0-b386-00a0c9083365");
|
|
pub const IID_IDtcLuRecoveryInitiatedByLuWork = &IID_IDtcLuRecoveryInitiatedByLuWork_Value;
|
|
pub const IDtcLuRecoveryInitiatedByLuWork = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
HandleTheirXln: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByLuWork,
|
|
lRecoverySeqNum: i32,
|
|
Xln: _DtcLu_Xln,
|
|
pRemoteLogName: ?*u8,
|
|
cbRemoteLogName: u32,
|
|
pOurLogName: ?*u8,
|
|
cbOurLogName: u32,
|
|
dwProtocol: u32,
|
|
pResponse: ?*_DtcLu_Xln_Response,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByLuWork,
|
|
lRecoverySeqNum: i32,
|
|
Xln: _DtcLu_Xln,
|
|
pRemoteLogName: ?*u8,
|
|
cbRemoteLogName: u32,
|
|
pOurLogName: ?*u8,
|
|
cbOurLogName: u32,
|
|
dwProtocol: u32,
|
|
pResponse: ?*_DtcLu_Xln_Response,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetOurLogNameSize: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByLuWork,
|
|
pcbOurLogName: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByLuWork,
|
|
pcbOurLogName: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetOurXln: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByLuWork,
|
|
pXln: ?*_DtcLu_Xln,
|
|
pOurLogName: ?*u8,
|
|
pdwProtocol: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByLuWork,
|
|
pXln: ?*_DtcLu_Xln,
|
|
pOurLogName: ?*u8,
|
|
pdwProtocol: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
HandleConfirmationOfOurXln: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByLuWork,
|
|
Confirmation: _DtcLu_Xln_Confirmation,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByLuWork,
|
|
Confirmation: _DtcLu_Xln_Confirmation,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
HandleTheirCompareStates: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByLuWork,
|
|
pRemoteTransId: ?*u8,
|
|
cbRemoteTransId: u32,
|
|
CompareState: _DtcLu_CompareState,
|
|
pResponse: ?*_DtcLu_CompareStates_Response,
|
|
pCompareState: ?*_DtcLu_CompareState,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByLuWork,
|
|
pRemoteTransId: ?*u8,
|
|
cbRemoteTransId: u32,
|
|
CompareState: _DtcLu_CompareState,
|
|
pResponse: ?*_DtcLu_CompareStates_Response,
|
|
pCompareState: ?*_DtcLu_CompareState,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
HandleConfirmationOfOurCompareStates: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByLuWork,
|
|
Confirmation: _DtcLu_CompareStates_Confirmation,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByLuWork,
|
|
Confirmation: _DtcLu_CompareStates_Confirmation,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
HandleErrorFromOurCompareStates: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByLuWork,
|
|
Error: _DtcLu_CompareStates_Error,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByLuWork,
|
|
Error: _DtcLu_CompareStates_Error,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ConversationLost: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByLuWork,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByLuWork,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByLuWork_HandleTheirXln(self: *const T, lRecoverySeqNum: i32, Xln: _DtcLu_Xln, pRemoteLogName: ?*u8, cbRemoteLogName: u32, pOurLogName: ?*u8, cbOurLogName: u32, dwProtocol: u32, pResponse: ?*_DtcLu_Xln_Response) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByLuWork.VTable, @ptrCast(self.vtable)).HandleTheirXln(@as(*const IDtcLuRecoveryInitiatedByLuWork, @ptrCast(self)), lRecoverySeqNum, Xln, pRemoteLogName, cbRemoteLogName, pOurLogName, cbOurLogName, dwProtocol, pResponse);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByLuWork_GetOurLogNameSize(self: *const T, pcbOurLogName: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByLuWork.VTable, @ptrCast(self.vtable)).GetOurLogNameSize(@as(*const IDtcLuRecoveryInitiatedByLuWork, @ptrCast(self)), pcbOurLogName);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByLuWork_GetOurXln(self: *const T, pXln: ?*_DtcLu_Xln, pOurLogName: ?*u8, pdwProtocol: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByLuWork.VTable, @ptrCast(self.vtable)).GetOurXln(@as(*const IDtcLuRecoveryInitiatedByLuWork, @ptrCast(self)), pXln, pOurLogName, pdwProtocol);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByLuWork_HandleConfirmationOfOurXln(self: *const T, Confirmation: _DtcLu_Xln_Confirmation) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByLuWork.VTable, @ptrCast(self.vtable)).HandleConfirmationOfOurXln(@as(*const IDtcLuRecoveryInitiatedByLuWork, @ptrCast(self)), Confirmation);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByLuWork_HandleTheirCompareStates(self: *const T, pRemoteTransId: ?*u8, cbRemoteTransId: u32, CompareState: _DtcLu_CompareState, pResponse: ?*_DtcLu_CompareStates_Response, pCompareState: ?*_DtcLu_CompareState) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByLuWork.VTable, @ptrCast(self.vtable)).HandleTheirCompareStates(@as(*const IDtcLuRecoveryInitiatedByLuWork, @ptrCast(self)), pRemoteTransId, cbRemoteTransId, CompareState, pResponse, pCompareState);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByLuWork_HandleConfirmationOfOurCompareStates(self: *const T, Confirmation: _DtcLu_CompareStates_Confirmation) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByLuWork.VTable, @ptrCast(self.vtable)).HandleConfirmationOfOurCompareStates(@as(*const IDtcLuRecoveryInitiatedByLuWork, @ptrCast(self)), Confirmation);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByLuWork_HandleErrorFromOurCompareStates(self: *const T, Error: _DtcLu_CompareStates_Error) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByLuWork.VTable, @ptrCast(self.vtable)).HandleErrorFromOurCompareStates(@as(*const IDtcLuRecoveryInitiatedByLuWork, @ptrCast(self)), Error);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByLuWork_ConversationLost(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByLuWork.VTable, @ptrCast(self.vtable)).ConversationLost(@as(*const IDtcLuRecoveryInitiatedByLuWork, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IDtcLuRecoveryInitiatedByLu_Value = Guid.initString("4131e768-1aea-11d0-944b-00a0c905416e");
|
|
pub const IID_IDtcLuRecoveryInitiatedByLu = &IID_IDtcLuRecoveryInitiatedByLu_Value;
|
|
pub const IDtcLuRecoveryInitiatedByLu = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetObjectToHandleWorkFromLu: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRecoveryInitiatedByLu,
|
|
ppWork: ?*?*IDtcLuRecoveryInitiatedByLuWork,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRecoveryInitiatedByLu,
|
|
ppWork: ?*?*IDtcLuRecoveryInitiatedByLuWork,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRecoveryInitiatedByLu_GetObjectToHandleWorkFromLu(self: *const T, ppWork: ?*?*IDtcLuRecoveryInitiatedByLuWork) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRecoveryInitiatedByLu.VTable, @ptrCast(self.vtable)).GetObjectToHandleWorkFromLu(@as(*const IDtcLuRecoveryInitiatedByLu, @ptrCast(self)), ppWork);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IDtcLuRmEnlistment_Value = Guid.initString("4131e769-1aea-11d0-944b-00a0c905416e");
|
|
pub const IID_IDtcLuRmEnlistment = &IID_IDtcLuRmEnlistment_Value;
|
|
pub const IDtcLuRmEnlistment = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Unplug: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRmEnlistment,
|
|
fConversationLost: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRmEnlistment,
|
|
fConversationLost: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
BackedOut: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRmEnlistment,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRmEnlistment,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
BackOut: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRmEnlistment,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRmEnlistment,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Committed: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRmEnlistment,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRmEnlistment,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Forget: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRmEnlistment,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRmEnlistment,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
RequestCommit: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRmEnlistment,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRmEnlistment,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRmEnlistment_Unplug(self: *const T, fConversationLost: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRmEnlistment.VTable, @ptrCast(self.vtable)).Unplug(@as(*const IDtcLuRmEnlistment, @ptrCast(self)), fConversationLost);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRmEnlistment_BackedOut(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRmEnlistment.VTable, @ptrCast(self.vtable)).BackedOut(@as(*const IDtcLuRmEnlistment, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRmEnlistment_BackOut(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRmEnlistment.VTable, @ptrCast(self.vtable)).BackOut(@as(*const IDtcLuRmEnlistment, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRmEnlistment_Committed(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRmEnlistment.VTable, @ptrCast(self.vtable)).Committed(@as(*const IDtcLuRmEnlistment, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRmEnlistment_Forget(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRmEnlistment.VTable, @ptrCast(self.vtable)).Forget(@as(*const IDtcLuRmEnlistment, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRmEnlistment_RequestCommit(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRmEnlistment.VTable, @ptrCast(self.vtable)).RequestCommit(@as(*const IDtcLuRmEnlistment, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IDtcLuRmEnlistmentSink_Value = Guid.initString("4131e770-1aea-11d0-944b-00a0c905416e");
|
|
pub const IID_IDtcLuRmEnlistmentSink = &IID_IDtcLuRmEnlistmentSink_Value;
|
|
pub const IDtcLuRmEnlistmentSink = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
AckUnplug: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRmEnlistmentSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRmEnlistmentSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
TmDown: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRmEnlistmentSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRmEnlistmentSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SessionLost: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRmEnlistmentSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRmEnlistmentSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
BackedOut: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRmEnlistmentSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRmEnlistmentSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
BackOut: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRmEnlistmentSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRmEnlistmentSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Committed: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRmEnlistmentSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRmEnlistmentSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Forget: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRmEnlistmentSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRmEnlistmentSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Prepare: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRmEnlistmentSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRmEnlistmentSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
RequestCommit: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRmEnlistmentSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRmEnlistmentSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRmEnlistmentSink_AckUnplug(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRmEnlistmentSink.VTable, @ptrCast(self.vtable)).AckUnplug(@as(*const IDtcLuRmEnlistmentSink, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRmEnlistmentSink_TmDown(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRmEnlistmentSink.VTable, @ptrCast(self.vtable)).TmDown(@as(*const IDtcLuRmEnlistmentSink, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRmEnlistmentSink_SessionLost(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRmEnlistmentSink.VTable, @ptrCast(self.vtable)).SessionLost(@as(*const IDtcLuRmEnlistmentSink, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRmEnlistmentSink_BackedOut(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRmEnlistmentSink.VTable, @ptrCast(self.vtable)).BackedOut(@as(*const IDtcLuRmEnlistmentSink, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRmEnlistmentSink_BackOut(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRmEnlistmentSink.VTable, @ptrCast(self.vtable)).BackOut(@as(*const IDtcLuRmEnlistmentSink, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRmEnlistmentSink_Committed(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRmEnlistmentSink.VTable, @ptrCast(self.vtable)).Committed(@as(*const IDtcLuRmEnlistmentSink, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRmEnlistmentSink_Forget(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRmEnlistmentSink.VTable, @ptrCast(self.vtable)).Forget(@as(*const IDtcLuRmEnlistmentSink, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRmEnlistmentSink_Prepare(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRmEnlistmentSink.VTable, @ptrCast(self.vtable)).Prepare(@as(*const IDtcLuRmEnlistmentSink, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRmEnlistmentSink_RequestCommit(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRmEnlistmentSink.VTable, @ptrCast(self.vtable)).RequestCommit(@as(*const IDtcLuRmEnlistmentSink, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IDtcLuRmEnlistmentFactory_Value = Guid.initString("4131e771-1aea-11d0-944b-00a0c905416e");
|
|
pub const IID_IDtcLuRmEnlistmentFactory = &IID_IDtcLuRmEnlistmentFactory_Value;
|
|
pub const IDtcLuRmEnlistmentFactory = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Create: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuRmEnlistmentFactory,
|
|
pucLuPair: ?*u8,
|
|
cbLuPair: u32,
|
|
pITransaction: ?*ITransaction,
|
|
pTransId: ?*u8,
|
|
cbTransId: u32,
|
|
pRmEnlistmentSink: ?*IDtcLuRmEnlistmentSink,
|
|
ppRmEnlistment: ?*?*IDtcLuRmEnlistment,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuRmEnlistmentFactory,
|
|
pucLuPair: ?*u8,
|
|
cbLuPair: u32,
|
|
pITransaction: ?*ITransaction,
|
|
pTransId: ?*u8,
|
|
cbTransId: u32,
|
|
pRmEnlistmentSink: ?*IDtcLuRmEnlistmentSink,
|
|
ppRmEnlistment: ?*?*IDtcLuRmEnlistment,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuRmEnlistmentFactory_Create(self: *const T, pucLuPair: ?*u8, cbLuPair: u32, pITransaction: ?*ITransaction, pTransId: ?*u8, cbTransId: u32, pRmEnlistmentSink: ?*IDtcLuRmEnlistmentSink, ppRmEnlistment: ?*?*IDtcLuRmEnlistment) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuRmEnlistmentFactory.VTable, @ptrCast(self.vtable)).Create(@as(*const IDtcLuRmEnlistmentFactory, @ptrCast(self)), pucLuPair, cbLuPair, pITransaction, pTransId, cbTransId, pRmEnlistmentSink, ppRmEnlistment);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IDtcLuSubordinateDtc_Value = Guid.initString("4131e773-1aea-11d0-944b-00a0c905416e");
|
|
pub const IID_IDtcLuSubordinateDtc = &IID_IDtcLuSubordinateDtc_Value;
|
|
pub const IDtcLuSubordinateDtc = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Unplug: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuSubordinateDtc,
|
|
fConversationLost: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuSubordinateDtc,
|
|
fConversationLost: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
BackedOut: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuSubordinateDtc,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuSubordinateDtc,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
BackOut: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuSubordinateDtc,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuSubordinateDtc,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Committed: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuSubordinateDtc,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuSubordinateDtc,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Forget: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuSubordinateDtc,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuSubordinateDtc,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Prepare: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuSubordinateDtc,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuSubordinateDtc,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
RequestCommit: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuSubordinateDtc,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuSubordinateDtc,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuSubordinateDtc_Unplug(self: *const T, fConversationLost: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuSubordinateDtc.VTable, @ptrCast(self.vtable)).Unplug(@as(*const IDtcLuSubordinateDtc, @ptrCast(self)), fConversationLost);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuSubordinateDtc_BackedOut(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuSubordinateDtc.VTable, @ptrCast(self.vtable)).BackedOut(@as(*const IDtcLuSubordinateDtc, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuSubordinateDtc_BackOut(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuSubordinateDtc.VTable, @ptrCast(self.vtable)).BackOut(@as(*const IDtcLuSubordinateDtc, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuSubordinateDtc_Committed(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuSubordinateDtc.VTable, @ptrCast(self.vtable)).Committed(@as(*const IDtcLuSubordinateDtc, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuSubordinateDtc_Forget(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuSubordinateDtc.VTable, @ptrCast(self.vtable)).Forget(@as(*const IDtcLuSubordinateDtc, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuSubordinateDtc_Prepare(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuSubordinateDtc.VTable, @ptrCast(self.vtable)).Prepare(@as(*const IDtcLuSubordinateDtc, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuSubordinateDtc_RequestCommit(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuSubordinateDtc.VTable, @ptrCast(self.vtable)).RequestCommit(@as(*const IDtcLuSubordinateDtc, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IDtcLuSubordinateDtcSink_Value = Guid.initString("4131e774-1aea-11d0-944b-00a0c905416e");
|
|
pub const IID_IDtcLuSubordinateDtcSink = &IID_IDtcLuSubordinateDtcSink_Value;
|
|
pub const IDtcLuSubordinateDtcSink = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
AckUnplug: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuSubordinateDtcSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuSubordinateDtcSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
TmDown: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuSubordinateDtcSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuSubordinateDtcSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SessionLost: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuSubordinateDtcSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuSubordinateDtcSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
BackedOut: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuSubordinateDtcSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuSubordinateDtcSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
BackOut: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuSubordinateDtcSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuSubordinateDtcSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Committed: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuSubordinateDtcSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuSubordinateDtcSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Forget: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuSubordinateDtcSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuSubordinateDtcSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
RequestCommit: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuSubordinateDtcSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuSubordinateDtcSink,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuSubordinateDtcSink_AckUnplug(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuSubordinateDtcSink.VTable, @ptrCast(self.vtable)).AckUnplug(@as(*const IDtcLuSubordinateDtcSink, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuSubordinateDtcSink_TmDown(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuSubordinateDtcSink.VTable, @ptrCast(self.vtable)).TmDown(@as(*const IDtcLuSubordinateDtcSink, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuSubordinateDtcSink_SessionLost(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuSubordinateDtcSink.VTable, @ptrCast(self.vtable)).SessionLost(@as(*const IDtcLuSubordinateDtcSink, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuSubordinateDtcSink_BackedOut(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuSubordinateDtcSink.VTable, @ptrCast(self.vtable)).BackedOut(@as(*const IDtcLuSubordinateDtcSink, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuSubordinateDtcSink_BackOut(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuSubordinateDtcSink.VTable, @ptrCast(self.vtable)).BackOut(@as(*const IDtcLuSubordinateDtcSink, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuSubordinateDtcSink_Committed(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuSubordinateDtcSink.VTable, @ptrCast(self.vtable)).Committed(@as(*const IDtcLuSubordinateDtcSink, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuSubordinateDtcSink_Forget(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuSubordinateDtcSink.VTable, @ptrCast(self.vtable)).Forget(@as(*const IDtcLuSubordinateDtcSink, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuSubordinateDtcSink_RequestCommit(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuSubordinateDtcSink.VTable, @ptrCast(self.vtable)).RequestCommit(@as(*const IDtcLuSubordinateDtcSink, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IDtcLuSubordinateDtcFactory_Value = Guid.initString("4131e775-1aea-11d0-944b-00a0c905416e");
|
|
pub const IID_IDtcLuSubordinateDtcFactory = &IID_IDtcLuSubordinateDtcFactory_Value;
|
|
pub const IDtcLuSubordinateDtcFactory = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Create: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDtcLuSubordinateDtcFactory,
|
|
pucLuPair: ?*u8,
|
|
cbLuPair: u32,
|
|
punkTransactionOuter: ?*IUnknown,
|
|
isoLevel: i32,
|
|
isoFlags: u32,
|
|
pOptions: ?*ITransactionOptions,
|
|
ppTransaction: ?*?*ITransaction,
|
|
pTransId: ?*u8,
|
|
cbTransId: u32,
|
|
pSubordinateDtcSink: ?*IDtcLuSubordinateDtcSink,
|
|
ppSubordinateDtc: ?*?*IDtcLuSubordinateDtc,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDtcLuSubordinateDtcFactory,
|
|
pucLuPair: ?*u8,
|
|
cbLuPair: u32,
|
|
punkTransactionOuter: ?*IUnknown,
|
|
isoLevel: i32,
|
|
isoFlags: u32,
|
|
pOptions: ?*ITransactionOptions,
|
|
ppTransaction: ?*?*ITransaction,
|
|
pTransId: ?*u8,
|
|
cbTransId: u32,
|
|
pSubordinateDtcSink: ?*IDtcLuSubordinateDtcSink,
|
|
ppSubordinateDtc: ?*?*IDtcLuSubordinateDtc,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IUnknown.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDtcLuSubordinateDtcFactory_Create(self: *const T, pucLuPair: ?*u8, cbLuPair: u32, punkTransactionOuter: ?*IUnknown, isoLevel: i32, isoFlags: u32, pOptions: ?*ITransactionOptions, ppTransaction: ?*?*ITransaction, pTransId: ?*u8, cbTransId: u32, pSubordinateDtcSink: ?*IDtcLuSubordinateDtcSink, ppSubordinateDtc: ?*?*IDtcLuSubordinateDtc) callconv(.Inline) HRESULT {
|
|
return @as(*const IDtcLuSubordinateDtcFactory.VTable, @ptrCast(self.vtable)).Create(@as(*const IDtcLuSubordinateDtcFactory, @ptrCast(self)), pucLuPair, cbLuPair, punkTransactionOuter, isoLevel, isoFlags, pOptions, ppTransaction, pTransId, cbTransId, pSubordinateDtcSink, ppSubordinateDtc);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
// Section: Functions (4)
|
|
//--------------------------------------------------------------------------------
|
|
pub extern "xolehlp" fn DtcGetTransactionManager(
|
|
i_pszHost: ?PSTR,
|
|
i_pszTmName: ?PSTR,
|
|
i_riid: ?*const Guid,
|
|
i_dwReserved1: u32,
|
|
i_wcbReserved2: u16,
|
|
// TODO: what to do with BytesParamIndex 4?
|
|
i_pvReserved2: ?*anyopaque,
|
|
o_ppvObject: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
pub extern "xolehlp" fn DtcGetTransactionManagerC(
|
|
i_pszHost: ?PSTR,
|
|
i_pszTmName: ?PSTR,
|
|
i_riid: ?*const Guid,
|
|
i_dwReserved1: u32,
|
|
i_wcbReserved2: u16,
|
|
// TODO: what to do with BytesParamIndex 4?
|
|
i_pvReserved2: ?*anyopaque,
|
|
o_ppvObject: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
pub extern "xolehlp" fn DtcGetTransactionManagerExA(
|
|
i_pszHost: ?PSTR,
|
|
i_pszTmName: ?PSTR,
|
|
i_riid: ?*const Guid,
|
|
i_grfOptions: u32,
|
|
i_pvConfigParams: ?*anyopaque,
|
|
o_ppvObject: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
pub extern "xolehlp" fn DtcGetTransactionManagerExW(
|
|
i_pwszHost: ?PWSTR,
|
|
i_pwszTmName: ?PWSTR,
|
|
i_riid: ?*const Guid,
|
|
i_grfOptions: u32,
|
|
i_pvConfigParams: ?*anyopaque,
|
|
o_ppvObject: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
// Section: Unicode Aliases (2)
|
|
//--------------------------------------------------------------------------------
|
|
const thismodule = @This();
|
|
pub usingnamespace switch (@import("../zig.zig").unicode_mode) {
|
|
.ansi => struct {
|
|
pub const DTC_GET_TRANSACTION_MANAGER_EX_ = thismodule.DTC_GET_TRANSACTION_MANAGER_EX_A;
|
|
pub const DtcGetTransactionManagerEx = thismodule.DtcGetTransactionManagerExA;
|
|
},
|
|
.wide => struct {
|
|
pub const DTC_GET_TRANSACTION_MANAGER_EX_ = thismodule.DTC_GET_TRANSACTION_MANAGER_EX_W;
|
|
pub const DtcGetTransactionManagerEx = thismodule.DtcGetTransactionManagerExW;
|
|
},
|
|
.unspecified => if (@import("builtin").is_test) struct {
|
|
pub const DTC_GET_TRANSACTION_MANAGER_EX_ = *opaque{};
|
|
pub const DtcGetTransactionManagerEx = *opaque{};
|
|
} else struct {
|
|
pub const DTC_GET_TRANSACTION_MANAGER_EX_ = @compileError("'DTC_GET_TRANSACTION_MANAGER_EX_' requires that UNICODE be set to true or false in the root module");
|
|
pub const DtcGetTransactionManagerEx = @compileError("'DtcGetTransactionManagerEx' requires that UNICODE be set to true or false in the root module");
|
|
},
|
|
};
|
|
//--------------------------------------------------------------------------------
|
|
// Section: Imports (10)
|
|
//--------------------------------------------------------------------------------
|
|
const Guid = @import("../zig.zig").Guid;
|
|
const BOOL = @import("../foundation.zig").BOOL;
|
|
const CHAR = @import("../foundation.zig").CHAR;
|
|
const FILETIME = @import("../foundation.zig").FILETIME;
|
|
const HANDLE = @import("../foundation.zig").HANDLE;
|
|
const HRESULT = @import("../foundation.zig").HRESULT;
|
|
const IMoniker = @import("../system/com.zig").IMoniker;
|
|
const IUnknown = @import("../system/com.zig").IUnknown;
|
|
const PSTR = @import("../foundation.zig").PSTR;
|
|
const PWSTR = @import("../foundation.zig").PWSTR;
|
|
|
|
test {
|
|
// The following '_ = <FuncPtrType>' lines are a workaround for https://github.com/ziglang/zig/issues/4476
|
|
if (@hasDecl(@This(), "DTC_GET_TRANSACTION_MANAGER")) { _ = DTC_GET_TRANSACTION_MANAGER; }
|
|
if (@hasDecl(@This(), "DTC_GET_TRANSACTION_MANAGER_EX_A")) { _ = DTC_GET_TRANSACTION_MANAGER_EX_A; }
|
|
if (@hasDecl(@This(), "DTC_GET_TRANSACTION_MANAGER_EX_W")) { _ = DTC_GET_TRANSACTION_MANAGER_EX_W; }
|
|
if (@hasDecl(@This(), "DTC_INSTALL_CLIENT")) { _ = DTC_INSTALL_CLIENT; }
|
|
if (@hasDecl(@This(), "XA_OPEN_EPT")) { _ = XA_OPEN_EPT; }
|
|
if (@hasDecl(@This(), "XA_CLOSE_EPT")) { _ = XA_CLOSE_EPT; }
|
|
if (@hasDecl(@This(), "XA_START_EPT")) { _ = XA_START_EPT; }
|
|
if (@hasDecl(@This(), "XA_END_EPT")) { _ = XA_END_EPT; }
|
|
if (@hasDecl(@This(), "XA_ROLLBACK_EPT")) { _ = XA_ROLLBACK_EPT; }
|
|
if (@hasDecl(@This(), "XA_PREPARE_EPT")) { _ = XA_PREPARE_EPT; }
|
|
if (@hasDecl(@This(), "XA_COMMIT_EPT")) { _ = XA_COMMIT_EPT; }
|
|
if (@hasDecl(@This(), "XA_RECOVER_EPT")) { _ = XA_RECOVER_EPT; }
|
|
if (@hasDecl(@This(), "XA_FORGET_EPT")) { _ = XA_FORGET_EPT; }
|
|
if (@hasDecl(@This(), "XA_COMPLETE_EPT")) { _ = XA_COMPLETE_EPT; }
|
|
|
|
@setEvalBranchQuota(
|
|
comptime @import("std").meta.declarations(@This()).len * 3
|
|
);
|
|
|
|
// reference all the pub declarations
|
|
if (!@import("builtin").is_test) return;
|
|
inline for (comptime @import("std").meta.declarations(@This())) |decl| {
|
|
_ = @field(@This(), decl.name);
|
|
}
|
|
}
|