1512 lines
78 KiB
Zig
1512 lines
78 KiB
Zig
//! NOTE: this file is autogenerated, DO NOT MODIFY
|
|
//--------------------------------------------------------------------------------
|
|
// Section: Constants (24)
|
|
//--------------------------------------------------------------------------------
|
|
pub const RDCE_TABLE_FULL = @as(u32, 2147745793);
|
|
pub const RDCE_TABLE_CORRUPT = @as(u32, 2147745794);
|
|
pub const MSRDC_SIGNATURE_HASHSIZE = @as(u32, 16);
|
|
pub const SimilarityFileIdMinSize = @as(u32, 4);
|
|
pub const SimilarityFileIdMaxSize = @as(u32, 32);
|
|
pub const MSRDC_VERSION = @as(u32, 65536);
|
|
pub const MSRDC_MINIMUM_COMPATIBLE_APP_VERSION = @as(u32, 65536);
|
|
pub const MSRDC_MINIMUM_DEPTH = @as(u32, 1);
|
|
pub const MSRDC_MAXIMUM_DEPTH = @as(u32, 8);
|
|
pub const MSRDC_MINIMUM_COMPAREBUFFER = @as(u32, 100000);
|
|
pub const MSRDC_MAXIMUM_COMPAREBUFFER = @as(u32, 1073741824);
|
|
pub const MSRDC_DEFAULT_COMPAREBUFFER = @as(u32, 3200000);
|
|
pub const MSRDC_MINIMUM_INPUTBUFFERSIZE = @as(u32, 1024);
|
|
pub const MSRDC_MINIMUM_HORIZONSIZE = @as(u32, 128);
|
|
pub const MSRDC_MAXIMUM_HORIZONSIZE = @as(u32, 16384);
|
|
pub const MSRDC_MINIMUM_HASHWINDOWSIZE = @as(u32, 2);
|
|
pub const MSRDC_MAXIMUM_HASHWINDOWSIZE = @as(u32, 96);
|
|
pub const MSRDC_DEFAULT_HASHWINDOWSIZE_1 = @as(u32, 48);
|
|
pub const MSRDC_DEFAULT_HORIZONSIZE_1 = @as(u32, 1024);
|
|
pub const MSRDC_DEFAULT_HASHWINDOWSIZE_N = @as(u32, 2);
|
|
pub const MSRDC_DEFAULT_HORIZONSIZE_N = @as(u32, 128);
|
|
pub const MSRDC_MAXIMUM_TRAITVALUE = @as(u32, 63);
|
|
pub const MSRDC_MINIMUM_MATCHESREQUIRED = @as(u32, 1);
|
|
pub const MSRDC_MAXIMUM_MATCHESREQUIRED = @as(u32, 16);
|
|
|
|
//--------------------------------------------------------------------------------
|
|
// Section: Types (48)
|
|
//--------------------------------------------------------------------------------
|
|
const CLSID_RdcLibrary_Value = Guid.initString("96236a85-9dbc-11da-9e3f-0011114ae311");
|
|
pub const CLSID_RdcLibrary = &CLSID_RdcLibrary_Value;
|
|
|
|
const CLSID_RdcGeneratorParameters_Value = Guid.initString("96236a86-9dbc-11da-9e3f-0011114ae311");
|
|
pub const CLSID_RdcGeneratorParameters = &CLSID_RdcGeneratorParameters_Value;
|
|
|
|
const CLSID_RdcGeneratorFilterMaxParameters_Value = Guid.initString("96236a87-9dbc-11da-9e3f-0011114ae311");
|
|
pub const CLSID_RdcGeneratorFilterMaxParameters = &CLSID_RdcGeneratorFilterMaxParameters_Value;
|
|
|
|
const CLSID_RdcGenerator_Value = Guid.initString("96236a88-9dbc-11da-9e3f-0011114ae311");
|
|
pub const CLSID_RdcGenerator = &CLSID_RdcGenerator_Value;
|
|
|
|
const CLSID_RdcFileReader_Value = Guid.initString("96236a89-9dbc-11da-9e3f-0011114ae311");
|
|
pub const CLSID_RdcFileReader = &CLSID_RdcFileReader_Value;
|
|
|
|
const CLSID_RdcSignatureReader_Value = Guid.initString("96236a8a-9dbc-11da-9e3f-0011114ae311");
|
|
pub const CLSID_RdcSignatureReader = &CLSID_RdcSignatureReader_Value;
|
|
|
|
const CLSID_RdcComparator_Value = Guid.initString("96236a8b-9dbc-11da-9e3f-0011114ae311");
|
|
pub const CLSID_RdcComparator = &CLSID_RdcComparator_Value;
|
|
|
|
const CLSID_SimilarityReportProgress_Value = Guid.initString("96236a8d-9dbc-11da-9e3f-0011114ae311");
|
|
pub const CLSID_SimilarityReportProgress = &CLSID_SimilarityReportProgress_Value;
|
|
|
|
const CLSID_SimilarityTableDumpState_Value = Guid.initString("96236a8e-9dbc-11da-9e3f-0011114ae311");
|
|
pub const CLSID_SimilarityTableDumpState = &CLSID_SimilarityTableDumpState_Value;
|
|
|
|
const CLSID_SimilarityTraitsTable_Value = Guid.initString("96236a8f-9dbc-11da-9e3f-0011114ae311");
|
|
pub const CLSID_SimilarityTraitsTable = &CLSID_SimilarityTraitsTable_Value;
|
|
|
|
const CLSID_SimilarityFileIdTable_Value = Guid.initString("96236a90-9dbc-11da-9e3f-0011114ae311");
|
|
pub const CLSID_SimilarityFileIdTable = &CLSID_SimilarityFileIdTable_Value;
|
|
|
|
const CLSID_Similarity_Value = Guid.initString("96236a91-9dbc-11da-9e3f-0011114ae311");
|
|
pub const CLSID_Similarity = &CLSID_Similarity_Value;
|
|
|
|
const CLSID_RdcSimilarityGenerator_Value = Guid.initString("96236a92-9dbc-11da-9e3f-0011114ae311");
|
|
pub const CLSID_RdcSimilarityGenerator = &CLSID_RdcSimilarityGenerator_Value;
|
|
|
|
const CLSID_FindSimilarResults_Value = Guid.initString("96236a93-9dbc-11da-9e3f-0011114ae311");
|
|
pub const CLSID_FindSimilarResults = &CLSID_FindSimilarResults_Value;
|
|
|
|
const CLSID_SimilarityTraitsMapping_Value = Guid.initString("96236a94-9dbc-11da-9e3f-0011114ae311");
|
|
pub const CLSID_SimilarityTraitsMapping = &CLSID_SimilarityTraitsMapping_Value;
|
|
|
|
const CLSID_SimilarityTraitsMappedView_Value = Guid.initString("96236a95-9dbc-11da-9e3f-0011114ae311");
|
|
pub const CLSID_SimilarityTraitsMappedView = &CLSID_SimilarityTraitsMappedView_Value;
|
|
|
|
pub const RDC_ErrorCode = enum(i32) {
|
|
NoError = 0,
|
|
HeaderVersionNewer = 1,
|
|
HeaderVersionOlder = 2,
|
|
HeaderMissingOrCorrupt = 3,
|
|
HeaderWrongType = 4,
|
|
DataMissingOrCorrupt = 5,
|
|
DataTooManyRecords = 6,
|
|
FileChecksumMismatch = 7,
|
|
ApplicationError = 8,
|
|
Aborted = 9,
|
|
Win32Error = 10,
|
|
};
|
|
pub const RDC_NoError = RDC_ErrorCode.NoError;
|
|
pub const RDC_HeaderVersionNewer = RDC_ErrorCode.HeaderVersionNewer;
|
|
pub const RDC_HeaderVersionOlder = RDC_ErrorCode.HeaderVersionOlder;
|
|
pub const RDC_HeaderMissingOrCorrupt = RDC_ErrorCode.HeaderMissingOrCorrupt;
|
|
pub const RDC_HeaderWrongType = RDC_ErrorCode.HeaderWrongType;
|
|
pub const RDC_DataMissingOrCorrupt = RDC_ErrorCode.DataMissingOrCorrupt;
|
|
pub const RDC_DataTooManyRecords = RDC_ErrorCode.DataTooManyRecords;
|
|
pub const RDC_FileChecksumMismatch = RDC_ErrorCode.FileChecksumMismatch;
|
|
pub const RDC_ApplicationError = RDC_ErrorCode.ApplicationError;
|
|
pub const RDC_Aborted = RDC_ErrorCode.Aborted;
|
|
pub const RDC_Win32Error = RDC_ErrorCode.Win32Error;
|
|
|
|
pub const GeneratorParametersType = enum(i32) {
|
|
Unused = 0,
|
|
FilterMax = 1,
|
|
};
|
|
pub const RDCGENTYPE_Unused = GeneratorParametersType.Unused;
|
|
pub const RDCGENTYPE_FilterMax = GeneratorParametersType.FilterMax;
|
|
|
|
pub const RdcNeedType = enum(i32) {
|
|
SOURCE = 0,
|
|
TARGET = 1,
|
|
SEED = 2,
|
|
SEED_MAX = 255,
|
|
};
|
|
pub const RDCNEED_SOURCE = RdcNeedType.SOURCE;
|
|
pub const RDCNEED_TARGET = RdcNeedType.TARGET;
|
|
pub const RDCNEED_SEED = RdcNeedType.SEED;
|
|
pub const RDCNEED_SEED_MAX = RdcNeedType.SEED_MAX;
|
|
|
|
pub const RdcNeed = extern struct {
|
|
m_BlockType: RdcNeedType,
|
|
m_FileOffset: u64,
|
|
m_BlockLength: u64,
|
|
};
|
|
|
|
pub const RdcBufferPointer = extern struct {
|
|
m_Size: u32,
|
|
m_Used: u32,
|
|
m_Data: ?*u8,
|
|
};
|
|
|
|
pub const RdcNeedPointer = extern struct {
|
|
m_Size: u32,
|
|
m_Used: u32,
|
|
m_Data: ?*RdcNeed,
|
|
};
|
|
|
|
pub const RdcSignature = extern struct {
|
|
m_Signature: [16]u8,
|
|
m_BlockLength: u16,
|
|
};
|
|
|
|
pub const RdcSignaturePointer = extern struct {
|
|
m_Size: u32,
|
|
m_Used: u32,
|
|
m_Data: ?*RdcSignature,
|
|
};
|
|
|
|
pub const RdcCreatedTables = enum(i32) {
|
|
InvalidOrUnknown = 0,
|
|
Existing = 1,
|
|
New = 2,
|
|
};
|
|
pub const RDCTABLE_InvalidOrUnknown = RdcCreatedTables.InvalidOrUnknown;
|
|
pub const RDCTABLE_Existing = RdcCreatedTables.Existing;
|
|
pub const RDCTABLE_New = RdcCreatedTables.New;
|
|
|
|
pub const RdcMappingAccessMode = enum(i32) {
|
|
Undefined = 0,
|
|
ReadOnly = 1,
|
|
ReadWrite = 2,
|
|
};
|
|
pub const RDCMAPPING_Undefined = RdcMappingAccessMode.Undefined;
|
|
pub const RDCMAPPING_ReadOnly = RdcMappingAccessMode.ReadOnly;
|
|
pub const RDCMAPPING_ReadWrite = RdcMappingAccessMode.ReadWrite;
|
|
|
|
pub const SimilarityMappedViewInfo = extern struct {
|
|
m_Data: ?*u8,
|
|
m_Length: u32,
|
|
};
|
|
|
|
pub const SimilarityData = extern struct {
|
|
m_Data: [16]u8,
|
|
};
|
|
|
|
pub const FindSimilarFileIndexResults = extern struct {
|
|
m_FileIndex: u32,
|
|
m_MatchCount: u32,
|
|
};
|
|
|
|
pub const SimilarityDumpData = extern struct {
|
|
m_FileIndex: u32,
|
|
m_Data: SimilarityData,
|
|
};
|
|
|
|
pub const SimilarityFileId = extern struct {
|
|
m_FileId: [32]u8,
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows6.0.6000'
|
|
const IID_IRdcGeneratorParameters_Value = Guid.initString("96236a71-9dbc-11da-9e3f-0011114ae311");
|
|
pub const IID_IRdcGeneratorParameters = &IID_IRdcGeneratorParameters_Value;
|
|
pub const IRdcGeneratorParameters = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetGeneratorParametersType: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcGeneratorParameters,
|
|
parametersType: ?*GeneratorParametersType,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcGeneratorParameters,
|
|
parametersType: ?*GeneratorParametersType,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetParametersVersion: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcGeneratorParameters,
|
|
currentVersion: ?*u32,
|
|
minimumCompatibleAppVersion: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcGeneratorParameters,
|
|
currentVersion: ?*u32,
|
|
minimumCompatibleAppVersion: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetSerializeSize: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcGeneratorParameters,
|
|
size: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcGeneratorParameters,
|
|
size: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Serialize: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcGeneratorParameters,
|
|
size: u32,
|
|
parametersBlob: ?*u8,
|
|
bytesWritten: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcGeneratorParameters,
|
|
size: u32,
|
|
parametersBlob: ?*u8,
|
|
bytesWritten: ?*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 IRdcGeneratorParameters_GetGeneratorParametersType(self: *const T, parametersType: ?*GeneratorParametersType) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcGeneratorParameters.VTable, @ptrCast(self.vtable)).GetGeneratorParametersType(@as(*const IRdcGeneratorParameters, @ptrCast(self)), parametersType);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IRdcGeneratorParameters_GetParametersVersion(self: *const T, currentVersion: ?*u32, minimumCompatibleAppVersion: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcGeneratorParameters.VTable, @ptrCast(self.vtable)).GetParametersVersion(@as(*const IRdcGeneratorParameters, @ptrCast(self)), currentVersion, minimumCompatibleAppVersion);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IRdcGeneratorParameters_GetSerializeSize(self: *const T, size: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcGeneratorParameters.VTable, @ptrCast(self.vtable)).GetSerializeSize(@as(*const IRdcGeneratorParameters, @ptrCast(self)), size);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IRdcGeneratorParameters_Serialize(self: *const T, size: u32, parametersBlob: ?*u8, bytesWritten: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcGeneratorParameters.VTable, @ptrCast(self.vtable)).Serialize(@as(*const IRdcGeneratorParameters, @ptrCast(self)), size, parametersBlob, bytesWritten);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows6.0.6000'
|
|
const IID_IRdcGeneratorFilterMaxParameters_Value = Guid.initString("96236a72-9dbc-11da-9e3f-0011114ae311");
|
|
pub const IID_IRdcGeneratorFilterMaxParameters = &IID_IRdcGeneratorFilterMaxParameters_Value;
|
|
pub const IRdcGeneratorFilterMaxParameters = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetHorizonSize: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcGeneratorFilterMaxParameters,
|
|
horizonSize: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcGeneratorFilterMaxParameters,
|
|
horizonSize: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetHorizonSize: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcGeneratorFilterMaxParameters,
|
|
horizonSize: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcGeneratorFilterMaxParameters,
|
|
horizonSize: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetHashWindowSize: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcGeneratorFilterMaxParameters,
|
|
hashWindowSize: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcGeneratorFilterMaxParameters,
|
|
hashWindowSize: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetHashWindowSize: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcGeneratorFilterMaxParameters,
|
|
hashWindowSize: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcGeneratorFilterMaxParameters,
|
|
hashWindowSize: 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 IRdcGeneratorFilterMaxParameters_GetHorizonSize(self: *const T, horizonSize: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcGeneratorFilterMaxParameters.VTable, @ptrCast(self.vtable)).GetHorizonSize(@as(*const IRdcGeneratorFilterMaxParameters, @ptrCast(self)), horizonSize);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IRdcGeneratorFilterMaxParameters_SetHorizonSize(self: *const T, horizonSize: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcGeneratorFilterMaxParameters.VTable, @ptrCast(self.vtable)).SetHorizonSize(@as(*const IRdcGeneratorFilterMaxParameters, @ptrCast(self)), horizonSize);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IRdcGeneratorFilterMaxParameters_GetHashWindowSize(self: *const T, hashWindowSize: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcGeneratorFilterMaxParameters.VTable, @ptrCast(self.vtable)).GetHashWindowSize(@as(*const IRdcGeneratorFilterMaxParameters, @ptrCast(self)), hashWindowSize);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IRdcGeneratorFilterMaxParameters_SetHashWindowSize(self: *const T, hashWindowSize: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcGeneratorFilterMaxParameters.VTable, @ptrCast(self.vtable)).SetHashWindowSize(@as(*const IRdcGeneratorFilterMaxParameters, @ptrCast(self)), hashWindowSize);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows6.0.6000'
|
|
const IID_IRdcGenerator_Value = Guid.initString("96236a73-9dbc-11da-9e3f-0011114ae311");
|
|
pub const IID_IRdcGenerator = &IID_IRdcGenerator_Value;
|
|
pub const IRdcGenerator = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetGeneratorParameters: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcGenerator,
|
|
level: u32,
|
|
iGeneratorParameters: ?*?*IRdcGeneratorParameters,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcGenerator,
|
|
level: u32,
|
|
iGeneratorParameters: ?*?*IRdcGeneratorParameters,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Process: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcGenerator,
|
|
endOfInput: BOOL,
|
|
endOfOutput: ?*BOOL,
|
|
inputBuffer: ?*RdcBufferPointer,
|
|
depth: u32,
|
|
outputBuffers: [*]?*RdcBufferPointer,
|
|
rdc_ErrorCode: ?*RDC_ErrorCode,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcGenerator,
|
|
endOfInput: BOOL,
|
|
endOfOutput: ?*BOOL,
|
|
inputBuffer: ?*RdcBufferPointer,
|
|
depth: u32,
|
|
outputBuffers: [*]?*RdcBufferPointer,
|
|
rdc_ErrorCode: ?*RDC_ErrorCode,
|
|
) 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 IRdcGenerator_GetGeneratorParameters(self: *const T, level: u32, iGeneratorParameters: ?*?*IRdcGeneratorParameters) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcGenerator.VTable, @ptrCast(self.vtable)).GetGeneratorParameters(@as(*const IRdcGenerator, @ptrCast(self)), level, iGeneratorParameters);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IRdcGenerator_Process(self: *const T, endOfInput: BOOL, endOfOutput: ?*BOOL, inputBuffer: ?*RdcBufferPointer, depth: u32, outputBuffers: [*]?*RdcBufferPointer, rdc_ErrorCode: ?*RDC_ErrorCode) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcGenerator.VTable, @ptrCast(self.vtable)).Process(@as(*const IRdcGenerator, @ptrCast(self)), endOfInput, endOfOutput, inputBuffer, depth, outputBuffers, rdc_ErrorCode);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows6.0.6000'
|
|
const IID_IRdcFileReader_Value = Guid.initString("96236a74-9dbc-11da-9e3f-0011114ae311");
|
|
pub const IID_IRdcFileReader = &IID_IRdcFileReader_Value;
|
|
pub const IRdcFileReader = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetFileSize: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcFileReader,
|
|
fileSize: ?*u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcFileReader,
|
|
fileSize: ?*u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Read: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcFileReader,
|
|
offsetFileStart: u64,
|
|
bytesToRead: u32,
|
|
bytesActuallyRead: ?*u32,
|
|
buffer: ?*u8,
|
|
eof: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcFileReader,
|
|
offsetFileStart: u64,
|
|
bytesToRead: u32,
|
|
bytesActuallyRead: ?*u32,
|
|
buffer: ?*u8,
|
|
eof: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetFilePosition: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcFileReader,
|
|
offsetFromStart: ?*u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcFileReader,
|
|
offsetFromStart: ?*u64,
|
|
) 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 IRdcFileReader_GetFileSize(self: *const T, fileSize: ?*u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcFileReader.VTable, @ptrCast(self.vtable)).GetFileSize(@as(*const IRdcFileReader, @ptrCast(self)), fileSize);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IRdcFileReader_Read(self: *const T, offsetFileStart: u64, bytesToRead: u32, bytesActuallyRead: ?*u32, buffer: ?*u8, eof: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcFileReader.VTable, @ptrCast(self.vtable)).Read(@as(*const IRdcFileReader, @ptrCast(self)), offsetFileStart, bytesToRead, bytesActuallyRead, buffer, eof);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IRdcFileReader_GetFilePosition(self: *const T, offsetFromStart: ?*u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcFileReader.VTable, @ptrCast(self.vtable)).GetFilePosition(@as(*const IRdcFileReader, @ptrCast(self)), offsetFromStart);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows6.0.6000'
|
|
const IID_IRdcFileWriter_Value = Guid.initString("96236a75-9dbc-11da-9e3f-0011114ae311");
|
|
pub const IID_IRdcFileWriter = &IID_IRdcFileWriter_Value;
|
|
pub const IRdcFileWriter = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IRdcFileReader.VTable,
|
|
Write: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcFileWriter,
|
|
offsetFileStart: u64,
|
|
bytesToWrite: u32,
|
|
buffer: ?*u8,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcFileWriter,
|
|
offsetFileStart: u64,
|
|
bytesToWrite: u32,
|
|
buffer: ?*u8,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Truncate: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcFileWriter,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcFileWriter,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
DeleteOnClose: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcFileWriter,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcFileWriter,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IRdcFileReader.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IRdcFileWriter_Write(self: *const T, offsetFileStart: u64, bytesToWrite: u32, buffer: ?*u8) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcFileWriter.VTable, @ptrCast(self.vtable)).Write(@as(*const IRdcFileWriter, @ptrCast(self)), offsetFileStart, bytesToWrite, buffer);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IRdcFileWriter_Truncate(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcFileWriter.VTable, @ptrCast(self.vtable)).Truncate(@as(*const IRdcFileWriter, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IRdcFileWriter_DeleteOnClose(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcFileWriter.VTable, @ptrCast(self.vtable)).DeleteOnClose(@as(*const IRdcFileWriter, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows6.0.6000'
|
|
const IID_IRdcSignatureReader_Value = Guid.initString("96236a76-9dbc-11da-9e3f-0011114ae311");
|
|
pub const IID_IRdcSignatureReader = &IID_IRdcSignatureReader_Value;
|
|
pub const IRdcSignatureReader = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
ReadHeader: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcSignatureReader,
|
|
rdc_ErrorCode: ?*RDC_ErrorCode,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcSignatureReader,
|
|
rdc_ErrorCode: ?*RDC_ErrorCode,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ReadSignatures: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcSignatureReader,
|
|
rdcSignaturePointer: ?*RdcSignaturePointer,
|
|
endOfOutput: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcSignatureReader,
|
|
rdcSignaturePointer: ?*RdcSignaturePointer,
|
|
endOfOutput: ?*BOOL,
|
|
) 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 IRdcSignatureReader_ReadHeader(self: *const T, rdc_ErrorCode: ?*RDC_ErrorCode) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcSignatureReader.VTable, @ptrCast(self.vtable)).ReadHeader(@as(*const IRdcSignatureReader, @ptrCast(self)), rdc_ErrorCode);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IRdcSignatureReader_ReadSignatures(self: *const T, rdcSignaturePointer: ?*RdcSignaturePointer, endOfOutput: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcSignatureReader.VTable, @ptrCast(self.vtable)).ReadSignatures(@as(*const IRdcSignatureReader, @ptrCast(self)), rdcSignaturePointer, endOfOutput);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows6.0.6000'
|
|
const IID_IRdcComparator_Value = Guid.initString("96236a77-9dbc-11da-9e3f-0011114ae311");
|
|
pub const IID_IRdcComparator = &IID_IRdcComparator_Value;
|
|
pub const IRdcComparator = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Process: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcComparator,
|
|
endOfInput: BOOL,
|
|
endOfOutput: ?*BOOL,
|
|
inputBuffer: ?*RdcBufferPointer,
|
|
outputBuffer: ?*RdcNeedPointer,
|
|
rdc_ErrorCode: ?*RDC_ErrorCode,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcComparator,
|
|
endOfInput: BOOL,
|
|
endOfOutput: ?*BOOL,
|
|
inputBuffer: ?*RdcBufferPointer,
|
|
outputBuffer: ?*RdcNeedPointer,
|
|
rdc_ErrorCode: ?*RDC_ErrorCode,
|
|
) 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 IRdcComparator_Process(self: *const T, endOfInput: BOOL, endOfOutput: ?*BOOL, inputBuffer: ?*RdcBufferPointer, outputBuffer: ?*RdcNeedPointer, rdc_ErrorCode: ?*RDC_ErrorCode) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcComparator.VTable, @ptrCast(self.vtable)).Process(@as(*const IRdcComparator, @ptrCast(self)), endOfInput, endOfOutput, inputBuffer, outputBuffer, rdc_ErrorCode);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows6.0.6000'
|
|
const IID_IRdcLibrary_Value = Guid.initString("96236a78-9dbc-11da-9e3f-0011114ae311");
|
|
pub const IID_IRdcLibrary = &IID_IRdcLibrary_Value;
|
|
pub const IRdcLibrary = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
ComputeDefaultRecursionDepth: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcLibrary,
|
|
fileSize: u64,
|
|
depth: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcLibrary,
|
|
fileSize: u64,
|
|
depth: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CreateGeneratorParameters: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcLibrary,
|
|
parametersType: GeneratorParametersType,
|
|
level: u32,
|
|
iGeneratorParameters: ?*?*IRdcGeneratorParameters,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcLibrary,
|
|
parametersType: GeneratorParametersType,
|
|
level: u32,
|
|
iGeneratorParameters: ?*?*IRdcGeneratorParameters,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OpenGeneratorParameters: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcLibrary,
|
|
size: u32,
|
|
parametersBlob: ?*const u8,
|
|
iGeneratorParameters: ?*?*IRdcGeneratorParameters,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcLibrary,
|
|
size: u32,
|
|
parametersBlob: ?*const u8,
|
|
iGeneratorParameters: ?*?*IRdcGeneratorParameters,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CreateGenerator: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcLibrary,
|
|
depth: u32,
|
|
iGeneratorParametersArray: [*]?*IRdcGeneratorParameters,
|
|
iGenerator: ?*?*IRdcGenerator,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcLibrary,
|
|
depth: u32,
|
|
iGeneratorParametersArray: [*]?*IRdcGeneratorParameters,
|
|
iGenerator: ?*?*IRdcGenerator,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CreateComparator: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcLibrary,
|
|
iSeedSignaturesFile: ?*IRdcFileReader,
|
|
comparatorBufferSize: u32,
|
|
iComparator: ?*?*IRdcComparator,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcLibrary,
|
|
iSeedSignaturesFile: ?*IRdcFileReader,
|
|
comparatorBufferSize: u32,
|
|
iComparator: ?*?*IRdcComparator,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CreateSignatureReader: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcLibrary,
|
|
iFileReader: ?*IRdcFileReader,
|
|
iSignatureReader: ?*?*IRdcSignatureReader,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcLibrary,
|
|
iFileReader: ?*IRdcFileReader,
|
|
iSignatureReader: ?*?*IRdcSignatureReader,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetRDCVersion: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcLibrary,
|
|
currentVersion: ?*u32,
|
|
minimumCompatibleAppVersion: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcLibrary,
|
|
currentVersion: ?*u32,
|
|
minimumCompatibleAppVersion: ?*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 IRdcLibrary_ComputeDefaultRecursionDepth(self: *const T, fileSize: u64, depth: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcLibrary.VTable, @ptrCast(self.vtable)).ComputeDefaultRecursionDepth(@as(*const IRdcLibrary, @ptrCast(self)), fileSize, depth);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IRdcLibrary_CreateGeneratorParameters(self: *const T, parametersType: GeneratorParametersType, level: u32, iGeneratorParameters: ?*?*IRdcGeneratorParameters) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcLibrary.VTable, @ptrCast(self.vtable)).CreateGeneratorParameters(@as(*const IRdcLibrary, @ptrCast(self)), parametersType, level, iGeneratorParameters);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IRdcLibrary_OpenGeneratorParameters(self: *const T, size: u32, parametersBlob: ?*const u8, iGeneratorParameters: ?*?*IRdcGeneratorParameters) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcLibrary.VTable, @ptrCast(self.vtable)).OpenGeneratorParameters(@as(*const IRdcLibrary, @ptrCast(self)), size, parametersBlob, iGeneratorParameters);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IRdcLibrary_CreateGenerator(self: *const T, depth: u32, iGeneratorParametersArray: [*]?*IRdcGeneratorParameters, iGenerator: ?*?*IRdcGenerator) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcLibrary.VTable, @ptrCast(self.vtable)).CreateGenerator(@as(*const IRdcLibrary, @ptrCast(self)), depth, iGeneratorParametersArray, iGenerator);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IRdcLibrary_CreateComparator(self: *const T, iSeedSignaturesFile: ?*IRdcFileReader, comparatorBufferSize: u32, iComparator: ?*?*IRdcComparator) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcLibrary.VTable, @ptrCast(self.vtable)).CreateComparator(@as(*const IRdcLibrary, @ptrCast(self)), iSeedSignaturesFile, comparatorBufferSize, iComparator);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IRdcLibrary_CreateSignatureReader(self: *const T, iFileReader: ?*IRdcFileReader, iSignatureReader: ?*?*IRdcSignatureReader) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcLibrary.VTable, @ptrCast(self.vtable)).CreateSignatureReader(@as(*const IRdcLibrary, @ptrCast(self)), iFileReader, iSignatureReader);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IRdcLibrary_GetRDCVersion(self: *const T, currentVersion: ?*u32, minimumCompatibleAppVersion: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcLibrary.VTable, @ptrCast(self.vtable)).GetRDCVersion(@as(*const IRdcLibrary, @ptrCast(self)), currentVersion, minimumCompatibleAppVersion);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows6.0.6000'
|
|
const IID_ISimilarityReportProgress_Value = Guid.initString("96236a7a-9dbc-11da-9e3f-0011114ae311");
|
|
pub const IID_ISimilarityReportProgress = &IID_ISimilarityReportProgress_Value;
|
|
pub const ISimilarityReportProgress = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
ReportProgress: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityReportProgress,
|
|
percentCompleted: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityReportProgress,
|
|
percentCompleted: 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 ISimilarityReportProgress_ReportProgress(self: *const T, percentCompleted: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityReportProgress.VTable, @ptrCast(self.vtable)).ReportProgress(@as(*const ISimilarityReportProgress, @ptrCast(self)), percentCompleted);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows6.0.6000'
|
|
const IID_ISimilarityTableDumpState_Value = Guid.initString("96236a7b-9dbc-11da-9e3f-0011114ae311");
|
|
pub const IID_ISimilarityTableDumpState = &IID_ISimilarityTableDumpState_Value;
|
|
pub const ISimilarityTableDumpState = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetNextData: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityTableDumpState,
|
|
resultsSize: u32,
|
|
resultsUsed: ?*u32,
|
|
eof: ?*BOOL,
|
|
results: ?*SimilarityDumpData,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityTableDumpState,
|
|
resultsSize: u32,
|
|
resultsUsed: ?*u32,
|
|
eof: ?*BOOL,
|
|
results: ?*SimilarityDumpData,
|
|
) 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 ISimilarityTableDumpState_GetNextData(self: *const T, resultsSize: u32, resultsUsed: ?*u32, eof: ?*BOOL, results: ?*SimilarityDumpData) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityTableDumpState.VTable, @ptrCast(self.vtable)).GetNextData(@as(*const ISimilarityTableDumpState, @ptrCast(self)), resultsSize, resultsUsed, eof, results);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows6.0.6000'
|
|
const IID_ISimilarityTraitsMappedView_Value = Guid.initString("96236a7c-9dbc-11da-9e3f-0011114ae311");
|
|
pub const IID_ISimilarityTraitsMappedView = &IID_ISimilarityTraitsMappedView_Value;
|
|
pub const ISimilarityTraitsMappedView = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Flush: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityTraitsMappedView,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityTraitsMappedView,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Unmap: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityTraitsMappedView,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityTraitsMappedView,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Get: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityTraitsMappedView,
|
|
index: u64,
|
|
dirty: BOOL,
|
|
numElements: u32,
|
|
viewInfo: ?*SimilarityMappedViewInfo,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityTraitsMappedView,
|
|
index: u64,
|
|
dirty: BOOL,
|
|
numElements: u32,
|
|
viewInfo: ?*SimilarityMappedViewInfo,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetView: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityTraitsMappedView,
|
|
mappedPageBegin: ?*const ?*u8,
|
|
mappedPageEnd: ?*const ?*u8,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const ISimilarityTraitsMappedView,
|
|
mappedPageBegin: ?*const ?*u8,
|
|
mappedPageEnd: ?*const ?*u8,
|
|
) 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 ISimilarityTraitsMappedView_Flush(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityTraitsMappedView.VTable, @ptrCast(self.vtable)).Flush(@as(*const ISimilarityTraitsMappedView, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarityTraitsMappedView_Unmap(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityTraitsMappedView.VTable, @ptrCast(self.vtable)).Unmap(@as(*const ISimilarityTraitsMappedView, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarityTraitsMappedView_Get(self: *const T, index: u64, dirty: BOOL, numElements: u32, viewInfo: ?*SimilarityMappedViewInfo) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityTraitsMappedView.VTable, @ptrCast(self.vtable)).Get(@as(*const ISimilarityTraitsMappedView, @ptrCast(self)), index, dirty, numElements, viewInfo);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarityTraitsMappedView_GetView(self: *const T, mappedPageBegin: ?*const ?*u8, mappedPageEnd: ?*const ?*u8) callconv(.Inline) void {
|
|
return @as(*const ISimilarityTraitsMappedView.VTable, @ptrCast(self.vtable)).GetView(@as(*const ISimilarityTraitsMappedView, @ptrCast(self)), mappedPageBegin, mappedPageEnd);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows6.0.6000'
|
|
const IID_ISimilarityTraitsMapping_Value = Guid.initString("96236a7d-9dbc-11da-9e3f-0011114ae311");
|
|
pub const IID_ISimilarityTraitsMapping = &IID_ISimilarityTraitsMapping_Value;
|
|
pub const ISimilarityTraitsMapping = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
CloseMapping: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityTraitsMapping,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const ISimilarityTraitsMapping,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
SetFileSize: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityTraitsMapping,
|
|
fileSize: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityTraitsMapping,
|
|
fileSize: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetFileSize: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityTraitsMapping,
|
|
fileSize: ?*u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityTraitsMapping,
|
|
fileSize: ?*u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OpenMapping: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityTraitsMapping,
|
|
accessMode: RdcMappingAccessMode,
|
|
begin: u64,
|
|
end: u64,
|
|
actualEnd: ?*u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityTraitsMapping,
|
|
accessMode: RdcMappingAccessMode,
|
|
begin: u64,
|
|
end: u64,
|
|
actualEnd: ?*u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ResizeMapping: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityTraitsMapping,
|
|
accessMode: RdcMappingAccessMode,
|
|
begin: u64,
|
|
end: u64,
|
|
actualEnd: ?*u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityTraitsMapping,
|
|
accessMode: RdcMappingAccessMode,
|
|
begin: u64,
|
|
end: u64,
|
|
actualEnd: ?*u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetPageSize: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityTraitsMapping,
|
|
pageSize: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const ISimilarityTraitsMapping,
|
|
pageSize: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
CreateView: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityTraitsMapping,
|
|
minimumMappedPages: u32,
|
|
accessMode: RdcMappingAccessMode,
|
|
mappedView: ?*?*ISimilarityTraitsMappedView,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityTraitsMapping,
|
|
minimumMappedPages: u32,
|
|
accessMode: RdcMappingAccessMode,
|
|
mappedView: ?*?*ISimilarityTraitsMappedView,
|
|
) 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 ISimilarityTraitsMapping_CloseMapping(self: *const T) callconv(.Inline) void {
|
|
return @as(*const ISimilarityTraitsMapping.VTable, @ptrCast(self.vtable)).CloseMapping(@as(*const ISimilarityTraitsMapping, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarityTraitsMapping_SetFileSize(self: *const T, fileSize: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityTraitsMapping.VTable, @ptrCast(self.vtable)).SetFileSize(@as(*const ISimilarityTraitsMapping, @ptrCast(self)), fileSize);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarityTraitsMapping_GetFileSize(self: *const T, fileSize: ?*u64) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityTraitsMapping.VTable, @ptrCast(self.vtable)).GetFileSize(@as(*const ISimilarityTraitsMapping, @ptrCast(self)), fileSize);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarityTraitsMapping_OpenMapping(self: *const T, accessMode: RdcMappingAccessMode, begin: u64, end: u64, actualEnd: ?*u64) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityTraitsMapping.VTable, @ptrCast(self.vtable)).OpenMapping(@as(*const ISimilarityTraitsMapping, @ptrCast(self)), accessMode, begin, end, actualEnd);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarityTraitsMapping_ResizeMapping(self: *const T, accessMode: RdcMappingAccessMode, begin: u64, end: u64, actualEnd: ?*u64) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityTraitsMapping.VTable, @ptrCast(self.vtable)).ResizeMapping(@as(*const ISimilarityTraitsMapping, @ptrCast(self)), accessMode, begin, end, actualEnd);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarityTraitsMapping_GetPageSize(self: *const T, pageSize: ?*u32) callconv(.Inline) void {
|
|
return @as(*const ISimilarityTraitsMapping.VTable, @ptrCast(self.vtable)).GetPageSize(@as(*const ISimilarityTraitsMapping, @ptrCast(self)), pageSize);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarityTraitsMapping_CreateView(self: *const T, minimumMappedPages: u32, accessMode: RdcMappingAccessMode, mappedView: ?*?*ISimilarityTraitsMappedView) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityTraitsMapping.VTable, @ptrCast(self.vtable)).CreateView(@as(*const ISimilarityTraitsMapping, @ptrCast(self)), minimumMappedPages, accessMode, mappedView);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows6.0.6000'
|
|
const IID_ISimilarityTraitsTable_Value = Guid.initString("96236a7e-9dbc-11da-9e3f-0011114ae311");
|
|
pub const IID_ISimilarityTraitsTable = &IID_ISimilarityTraitsTable_Value;
|
|
pub const ISimilarityTraitsTable = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
CreateTable: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityTraitsTable,
|
|
path: ?PWSTR,
|
|
truncate: BOOL,
|
|
securityDescriptor: ?*u8,
|
|
isNew: ?*RdcCreatedTables,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityTraitsTable,
|
|
path: ?PWSTR,
|
|
truncate: BOOL,
|
|
securityDescriptor: ?*u8,
|
|
isNew: ?*RdcCreatedTables,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CreateTableIndirect: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityTraitsTable,
|
|
mapping: ?*ISimilarityTraitsMapping,
|
|
truncate: BOOL,
|
|
isNew: ?*RdcCreatedTables,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityTraitsTable,
|
|
mapping: ?*ISimilarityTraitsMapping,
|
|
truncate: BOOL,
|
|
isNew: ?*RdcCreatedTables,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CloseTable: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityTraitsTable,
|
|
isValid: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityTraitsTable,
|
|
isValid: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Append: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityTraitsTable,
|
|
data: ?*SimilarityData,
|
|
fileIndex: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityTraitsTable,
|
|
data: ?*SimilarityData,
|
|
fileIndex: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
FindSimilarFileIndex: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityTraitsTable,
|
|
similarityData: ?*SimilarityData,
|
|
numberOfMatchesRequired: u16,
|
|
findSimilarFileIndexResults: ?*FindSimilarFileIndexResults,
|
|
resultsSize: u32,
|
|
resultsUsed: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityTraitsTable,
|
|
similarityData: ?*SimilarityData,
|
|
numberOfMatchesRequired: u16,
|
|
findSimilarFileIndexResults: ?*FindSimilarFileIndexResults,
|
|
resultsSize: u32,
|
|
resultsUsed: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
BeginDump: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityTraitsTable,
|
|
similarityTableDumpState: ?*?*ISimilarityTableDumpState,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityTraitsTable,
|
|
similarityTableDumpState: ?*?*ISimilarityTableDumpState,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetLastIndex: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityTraitsTable,
|
|
fileIndex: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityTraitsTable,
|
|
fileIndex: ?*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 ISimilarityTraitsTable_CreateTable(self: *const T, path: ?PWSTR, truncate: BOOL, securityDescriptor: ?*u8, isNew: ?*RdcCreatedTables) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityTraitsTable.VTable, @ptrCast(self.vtable)).CreateTable(@as(*const ISimilarityTraitsTable, @ptrCast(self)), path, truncate, securityDescriptor, isNew);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarityTraitsTable_CreateTableIndirect(self: *const T, mapping: ?*ISimilarityTraitsMapping, truncate: BOOL, isNew: ?*RdcCreatedTables) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityTraitsTable.VTable, @ptrCast(self.vtable)).CreateTableIndirect(@as(*const ISimilarityTraitsTable, @ptrCast(self)), mapping, truncate, isNew);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarityTraitsTable_CloseTable(self: *const T, isValid: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityTraitsTable.VTable, @ptrCast(self.vtable)).CloseTable(@as(*const ISimilarityTraitsTable, @ptrCast(self)), isValid);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarityTraitsTable_Append(self: *const T, data: ?*SimilarityData, fileIndex: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityTraitsTable.VTable, @ptrCast(self.vtable)).Append(@as(*const ISimilarityTraitsTable, @ptrCast(self)), data, fileIndex);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarityTraitsTable_FindSimilarFileIndex(self: *const T, similarityData: ?*SimilarityData, numberOfMatchesRequired: u16, findSimilarFileIndexResults: ?*FindSimilarFileIndexResults, resultsSize: u32, resultsUsed: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityTraitsTable.VTable, @ptrCast(self.vtable)).FindSimilarFileIndex(@as(*const ISimilarityTraitsTable, @ptrCast(self)), similarityData, numberOfMatchesRequired, findSimilarFileIndexResults, resultsSize, resultsUsed);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarityTraitsTable_BeginDump(self: *const T, similarityTableDumpState: ?*?*ISimilarityTableDumpState) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityTraitsTable.VTable, @ptrCast(self.vtable)).BeginDump(@as(*const ISimilarityTraitsTable, @ptrCast(self)), similarityTableDumpState);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarityTraitsTable_GetLastIndex(self: *const T, fileIndex: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityTraitsTable.VTable, @ptrCast(self.vtable)).GetLastIndex(@as(*const ISimilarityTraitsTable, @ptrCast(self)), fileIndex);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows6.0.6000'
|
|
const IID_ISimilarityFileIdTable_Value = Guid.initString("96236a7f-9dbc-11da-9e3f-0011114ae311");
|
|
pub const IID_ISimilarityFileIdTable = &IID_ISimilarityFileIdTable_Value;
|
|
pub const ISimilarityFileIdTable = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
CreateTable: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityFileIdTable,
|
|
path: ?PWSTR,
|
|
truncate: BOOL,
|
|
securityDescriptor: ?*u8,
|
|
recordSize: u32,
|
|
isNew: ?*RdcCreatedTables,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityFileIdTable,
|
|
path: ?PWSTR,
|
|
truncate: BOOL,
|
|
securityDescriptor: ?*u8,
|
|
recordSize: u32,
|
|
isNew: ?*RdcCreatedTables,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CreateTableIndirect: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityFileIdTable,
|
|
fileIdFile: ?*IRdcFileWriter,
|
|
truncate: BOOL,
|
|
recordSize: u32,
|
|
isNew: ?*RdcCreatedTables,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityFileIdTable,
|
|
fileIdFile: ?*IRdcFileWriter,
|
|
truncate: BOOL,
|
|
recordSize: u32,
|
|
isNew: ?*RdcCreatedTables,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CloseTable: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityFileIdTable,
|
|
isValid: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityFileIdTable,
|
|
isValid: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Append: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityFileIdTable,
|
|
similarityFileId: ?*SimilarityFileId,
|
|
similarityFileIndex: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityFileIdTable,
|
|
similarityFileId: ?*SimilarityFileId,
|
|
similarityFileIndex: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Lookup: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityFileIdTable,
|
|
similarityFileIndex: u32,
|
|
similarityFileId: ?*SimilarityFileId,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityFileIdTable,
|
|
similarityFileIndex: u32,
|
|
similarityFileId: ?*SimilarityFileId,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Invalidate: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityFileIdTable,
|
|
similarityFileIndex: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityFileIdTable,
|
|
similarityFileIndex: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetRecordCount: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarityFileIdTable,
|
|
recordCount: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarityFileIdTable,
|
|
recordCount: ?*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 ISimilarityFileIdTable_CreateTable(self: *const T, path: ?PWSTR, truncate: BOOL, securityDescriptor: ?*u8, recordSize: u32, isNew: ?*RdcCreatedTables) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityFileIdTable.VTable, @ptrCast(self.vtable)).CreateTable(@as(*const ISimilarityFileIdTable, @ptrCast(self)), path, truncate, securityDescriptor, recordSize, isNew);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarityFileIdTable_CreateTableIndirect(self: *const T, fileIdFile: ?*IRdcFileWriter, truncate: BOOL, recordSize: u32, isNew: ?*RdcCreatedTables) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityFileIdTable.VTable, @ptrCast(self.vtable)).CreateTableIndirect(@as(*const ISimilarityFileIdTable, @ptrCast(self)), fileIdFile, truncate, recordSize, isNew);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarityFileIdTable_CloseTable(self: *const T, isValid: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityFileIdTable.VTable, @ptrCast(self.vtable)).CloseTable(@as(*const ISimilarityFileIdTable, @ptrCast(self)), isValid);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarityFileIdTable_Append(self: *const T, similarityFileId: ?*SimilarityFileId, similarityFileIndex: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityFileIdTable.VTable, @ptrCast(self.vtable)).Append(@as(*const ISimilarityFileIdTable, @ptrCast(self)), similarityFileId, similarityFileIndex);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarityFileIdTable_Lookup(self: *const T, similarityFileIndex: u32, similarityFileId: ?*SimilarityFileId) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityFileIdTable.VTable, @ptrCast(self.vtable)).Lookup(@as(*const ISimilarityFileIdTable, @ptrCast(self)), similarityFileIndex, similarityFileId);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarityFileIdTable_Invalidate(self: *const T, similarityFileIndex: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityFileIdTable.VTable, @ptrCast(self.vtable)).Invalidate(@as(*const ISimilarityFileIdTable, @ptrCast(self)), similarityFileIndex);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarityFileIdTable_GetRecordCount(self: *const T, recordCount: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarityFileIdTable.VTable, @ptrCast(self.vtable)).GetRecordCount(@as(*const ISimilarityFileIdTable, @ptrCast(self)), recordCount);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows6.0.6000'
|
|
const IID_IRdcSimilarityGenerator_Value = Guid.initString("96236a80-9dbc-11da-9e3f-0011114ae311");
|
|
pub const IID_IRdcSimilarityGenerator = &IID_IRdcSimilarityGenerator_Value;
|
|
pub const IRdcSimilarityGenerator = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
EnableSimilarity: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcSimilarityGenerator,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcSimilarityGenerator,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Results: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IRdcSimilarityGenerator,
|
|
similarityData: ?*SimilarityData,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IRdcSimilarityGenerator,
|
|
similarityData: ?*SimilarityData,
|
|
) 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 IRdcSimilarityGenerator_EnableSimilarity(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcSimilarityGenerator.VTable, @ptrCast(self.vtable)).EnableSimilarity(@as(*const IRdcSimilarityGenerator, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IRdcSimilarityGenerator_Results(self: *const T, similarityData: ?*SimilarityData) callconv(.Inline) HRESULT {
|
|
return @as(*const IRdcSimilarityGenerator.VTable, @ptrCast(self.vtable)).Results(@as(*const IRdcSimilarityGenerator, @ptrCast(self)), similarityData);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows6.0.6000'
|
|
const IID_IFindSimilarResults_Value = Guid.initString("96236a81-9dbc-11da-9e3f-0011114ae311");
|
|
pub const IID_IFindSimilarResults = &IID_IFindSimilarResults_Value;
|
|
pub const IFindSimilarResults = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetSize: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IFindSimilarResults,
|
|
size: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IFindSimilarResults,
|
|
size: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetNextFileId: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IFindSimilarResults,
|
|
numTraitsMatched: ?*u32,
|
|
similarityFileId: ?*SimilarityFileId,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IFindSimilarResults,
|
|
numTraitsMatched: ?*u32,
|
|
similarityFileId: ?*SimilarityFileId,
|
|
) 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 IFindSimilarResults_GetSize(self: *const T, size: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IFindSimilarResults.VTable, @ptrCast(self.vtable)).GetSize(@as(*const IFindSimilarResults, @ptrCast(self)), size);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IFindSimilarResults_GetNextFileId(self: *const T, numTraitsMatched: ?*u32, similarityFileId: ?*SimilarityFileId) callconv(.Inline) HRESULT {
|
|
return @as(*const IFindSimilarResults.VTable, @ptrCast(self.vtable)).GetNextFileId(@as(*const IFindSimilarResults, @ptrCast(self)), numTraitsMatched, similarityFileId);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows6.0.6000'
|
|
const IID_ISimilarity_Value = Guid.initString("96236a83-9dbc-11da-9e3f-0011114ae311");
|
|
pub const IID_ISimilarity = &IID_ISimilarity_Value;
|
|
pub const ISimilarity = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
CreateTable: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarity,
|
|
path: ?PWSTR,
|
|
truncate: BOOL,
|
|
securityDescriptor: ?*u8,
|
|
recordSize: u32,
|
|
isNew: ?*RdcCreatedTables,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarity,
|
|
path: ?PWSTR,
|
|
truncate: BOOL,
|
|
securityDescriptor: ?*u8,
|
|
recordSize: u32,
|
|
isNew: ?*RdcCreatedTables,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CreateTableIndirect: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarity,
|
|
mapping: ?*ISimilarityTraitsMapping,
|
|
fileIdFile: ?*IRdcFileWriter,
|
|
truncate: BOOL,
|
|
recordSize: u32,
|
|
isNew: ?*RdcCreatedTables,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarity,
|
|
mapping: ?*ISimilarityTraitsMapping,
|
|
fileIdFile: ?*IRdcFileWriter,
|
|
truncate: BOOL,
|
|
recordSize: u32,
|
|
isNew: ?*RdcCreatedTables,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CloseTable: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarity,
|
|
isValid: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarity,
|
|
isValid: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Append: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarity,
|
|
similarityFileId: ?*SimilarityFileId,
|
|
similarityData: ?*SimilarityData,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarity,
|
|
similarityFileId: ?*SimilarityFileId,
|
|
similarityData: ?*SimilarityData,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
FindSimilarFileId: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarity,
|
|
similarityData: ?*SimilarityData,
|
|
numberOfMatchesRequired: u16,
|
|
resultsSize: u32,
|
|
findSimilarResults: ?*?*IFindSimilarResults,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarity,
|
|
similarityData: ?*SimilarityData,
|
|
numberOfMatchesRequired: u16,
|
|
resultsSize: u32,
|
|
findSimilarResults: ?*?*IFindSimilarResults,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CopyAndSwap: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarity,
|
|
newSimilarityTables: ?*ISimilarity,
|
|
reportProgress: ?*ISimilarityReportProgress,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarity,
|
|
newSimilarityTables: ?*ISimilarity,
|
|
reportProgress: ?*ISimilarityReportProgress,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetRecordCount: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISimilarity,
|
|
recordCount: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISimilarity,
|
|
recordCount: ?*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 ISimilarity_CreateTable(self: *const T, path: ?PWSTR, truncate: BOOL, securityDescriptor: ?*u8, recordSize: u32, isNew: ?*RdcCreatedTables) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarity.VTable, @ptrCast(self.vtable)).CreateTable(@as(*const ISimilarity, @ptrCast(self)), path, truncate, securityDescriptor, recordSize, isNew);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarity_CreateTableIndirect(self: *const T, mapping: ?*ISimilarityTraitsMapping, fileIdFile: ?*IRdcFileWriter, truncate: BOOL, recordSize: u32, isNew: ?*RdcCreatedTables) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarity.VTable, @ptrCast(self.vtable)).CreateTableIndirect(@as(*const ISimilarity, @ptrCast(self)), mapping, fileIdFile, truncate, recordSize, isNew);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarity_CloseTable(self: *const T, isValid: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarity.VTable, @ptrCast(self.vtable)).CloseTable(@as(*const ISimilarity, @ptrCast(self)), isValid);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarity_Append(self: *const T, similarityFileId: ?*SimilarityFileId, similarityData: ?*SimilarityData) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarity.VTable, @ptrCast(self.vtable)).Append(@as(*const ISimilarity, @ptrCast(self)), similarityFileId, similarityData);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarity_FindSimilarFileId(self: *const T, similarityData: ?*SimilarityData, numberOfMatchesRequired: u16, resultsSize: u32, findSimilarResults: ?*?*IFindSimilarResults) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarity.VTable, @ptrCast(self.vtable)).FindSimilarFileId(@as(*const ISimilarity, @ptrCast(self)), similarityData, numberOfMatchesRequired, resultsSize, findSimilarResults);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarity_CopyAndSwap(self: *const T, newSimilarityTables: ?*ISimilarity, reportProgress: ?*ISimilarityReportProgress) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarity.VTable, @ptrCast(self.vtable)).CopyAndSwap(@as(*const ISimilarity, @ptrCast(self)), newSimilarityTables, reportProgress);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISimilarity_GetRecordCount(self: *const T, recordCount: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const ISimilarity.VTable, @ptrCast(self.vtable)).GetRecordCount(@as(*const ISimilarity, @ptrCast(self)), recordCount);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
// Section: Functions (0)
|
|
//--------------------------------------------------------------------------------
|
|
|
|
//--------------------------------------------------------------------------------
|
|
// Section: Unicode Aliases (0)
|
|
//--------------------------------------------------------------------------------
|
|
const thismodule = @This();
|
|
pub usingnamespace switch (@import("../zig.zig").unicode_mode) {
|
|
.ansi => struct {
|
|
},
|
|
.wide => struct {
|
|
},
|
|
.unspecified => if (@import("builtin").is_test) struct {
|
|
} else struct {
|
|
},
|
|
};
|
|
//--------------------------------------------------------------------------------
|
|
// Section: Imports (5)
|
|
//--------------------------------------------------------------------------------
|
|
const Guid = @import("../zig.zig").Guid;
|
|
const BOOL = @import("../foundation.zig").BOOL;
|
|
const HRESULT = @import("../foundation.zig").HRESULT;
|
|
const IUnknown = @import("../system/com.zig").IUnknown;
|
|
const PWSTR = @import("../foundation.zig").PWSTR;
|
|
|
|
test {
|
|
@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);
|
|
}
|
|
}
|