pub type size_t = ::std::os::raw::c_ulonglong;
pub type wchar_t = ::std::os::raw::c_ushort;
pub type BYTE = ::std::os::raw::c_uchar;
pub type DWORD = ::std::os::raw::c_ulong;
pub type INT32 = ::std::os::raw::c_int;
pub type INT64 = ::std::os::raw::c_longlong;
pub type UINT8 = ::std::os::raw::c_uchar;
pub type UINT32 = ::std::os::raw::c_uint;
pub type UINT64 = ::std::os::raw::c_ulonglong;
pub type LONG = ::std::os::raw::c_long;
pub type WCHAR = wchar_t;
pub type PCWSTR = *const WCHAR;
pub type HRESULT = LONG;
pub type LONGLONG = ::std::os::raw::c_longlong;
#[repr(C)]
#[derive(Copy, Clone)]
pub union _LARGE_INTEGER {
pub __bindgen_anon_1: _LARGE_INTEGER__bindgen_ty_1,
pub u: _LARGE_INTEGER__bindgen_ty_2,
pub QuadPart: LONGLONG,
_bindgen_union_align: u64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _LARGE_INTEGER__bindgen_ty_1 {
pub LowPart: DWORD,
pub HighPart: LONG,
}
#[test]
fn bindgen_test_layout__LARGE_INTEGER__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<_LARGE_INTEGER__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(_LARGE_INTEGER__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<_LARGE_INTEGER__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(_LARGE_INTEGER__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_LARGE_INTEGER__bindgen_ty_1>())).LowPart as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_LARGE_INTEGER__bindgen_ty_1),
"::",
stringify!(LowPart)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_LARGE_INTEGER__bindgen_ty_1>())).HighPart as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(_LARGE_INTEGER__bindgen_ty_1),
"::",
stringify!(HighPart)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _LARGE_INTEGER__bindgen_ty_2 {
pub LowPart: DWORD,
pub HighPart: LONG,
}
#[test]
fn bindgen_test_layout__LARGE_INTEGER__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<_LARGE_INTEGER__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(_LARGE_INTEGER__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<_LARGE_INTEGER__bindgen_ty_2>(),
4usize,
concat!("Alignment of ", stringify!(_LARGE_INTEGER__bindgen_ty_2))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_LARGE_INTEGER__bindgen_ty_2>())).LowPart as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_LARGE_INTEGER__bindgen_ty_2),
"::",
stringify!(LowPart)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_LARGE_INTEGER__bindgen_ty_2>())).HighPart as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(_LARGE_INTEGER__bindgen_ty_2),
"::",
stringify!(HighPart)
)
);
}
#[test]
fn bindgen_test_layout__LARGE_INTEGER() {
assert_eq!(
::std::mem::size_of::<_LARGE_INTEGER>(),
8usize,
concat!("Size of: ", stringify!(_LARGE_INTEGER))
);
assert_eq!(
::std::mem::align_of::<_LARGE_INTEGER>(),
8usize,
concat!("Alignment of ", stringify!(_LARGE_INTEGER))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_LARGE_INTEGER>())).u as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_LARGE_INTEGER),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_LARGE_INTEGER>())).QuadPart as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_LARGE_INTEGER),
"::",
stringify!(QuadPart)
)
);
}
pub type LARGE_INTEGER = _LARGE_INTEGER;
pub type BOOLEAN = BYTE;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GUID {
pub Data1: ::std::os::raw::c_ulong,
pub Data2: ::std::os::raw::c_ushort,
pub Data3: ::std::os::raw::c_ushort,
pub Data4: [::std::os::raw::c_uchar; 8usize],
}
#[test]
fn bindgen_test_layout__GUID() {
assert_eq!(
::std::mem::size_of::<_GUID>(),
16usize,
concat!("Size of: ", stringify!(_GUID))
);
assert_eq!(
::std::mem::align_of::<_GUID>(),
4usize,
concat!("Alignment of ", stringify!(_GUID))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_GUID>())).Data1 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_GUID),
"::",
stringify!(Data1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_GUID>())).Data2 as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_GUID),
"::",
stringify!(Data2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_GUID>())).Data3 as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(_GUID),
"::",
stringify!(Data3)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_GUID>())).Data4 as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_GUID),
"::",
stringify!(Data4)
)
);
}
pub type GUID = _GUID;
pub const PRJ_NOTIFY_TYPES_PRJ_NOTIFY_NONE: PRJ_NOTIFY_TYPES = 0;
pub const PRJ_NOTIFY_TYPES_PRJ_NOTIFY_SUPPRESS_NOTIFICATIONS: PRJ_NOTIFY_TYPES = 1;
pub const PRJ_NOTIFY_TYPES_PRJ_NOTIFY_FILE_OPENED: PRJ_NOTIFY_TYPES = 2;
pub const PRJ_NOTIFY_TYPES_PRJ_NOTIFY_NEW_FILE_CREATED: PRJ_NOTIFY_TYPES = 4;
pub const PRJ_NOTIFY_TYPES_PRJ_NOTIFY_FILE_OVERWRITTEN: PRJ_NOTIFY_TYPES = 8;
pub const PRJ_NOTIFY_TYPES_PRJ_NOTIFY_PRE_DELETE: PRJ_NOTIFY_TYPES = 16;
pub const PRJ_NOTIFY_TYPES_PRJ_NOTIFY_PRE_RENAME: PRJ_NOTIFY_TYPES = 32;
pub const PRJ_NOTIFY_TYPES_PRJ_NOTIFY_PRE_SET_HARDLINK: PRJ_NOTIFY_TYPES = 64;
pub const PRJ_NOTIFY_TYPES_PRJ_NOTIFY_FILE_RENAMED: PRJ_NOTIFY_TYPES = 128;
pub const PRJ_NOTIFY_TYPES_PRJ_NOTIFY_HARDLINK_CREATED: PRJ_NOTIFY_TYPES = 256;
pub const PRJ_NOTIFY_TYPES_PRJ_NOTIFY_FILE_HANDLE_CLOSED_NO_MODIFICATION: PRJ_NOTIFY_TYPES = 512;
pub const PRJ_NOTIFY_TYPES_PRJ_NOTIFY_FILE_HANDLE_CLOSED_FILE_MODIFIED: PRJ_NOTIFY_TYPES = 1024;
pub const PRJ_NOTIFY_TYPES_PRJ_NOTIFY_FILE_HANDLE_CLOSED_FILE_DELETED: PRJ_NOTIFY_TYPES = 2048;
pub const PRJ_NOTIFY_TYPES_PRJ_NOTIFY_FILE_PRE_CONVERT_TO_FULL: PRJ_NOTIFY_TYPES = 4096;
pub const PRJ_NOTIFY_TYPES_PRJ_NOTIFY_USE_EXISTING_MASK: PRJ_NOTIFY_TYPES = 4294967295;
pub type PRJ_NOTIFY_TYPES = u32;
pub const PRJ_NOTIFICATION_PRJ_NOTIFICATION_FILE_OPENED: PRJ_NOTIFICATION = 2;
pub const PRJ_NOTIFICATION_PRJ_NOTIFICATION_NEW_FILE_CREATED: PRJ_NOTIFICATION = 4;
pub const PRJ_NOTIFICATION_PRJ_NOTIFICATION_FILE_OVERWRITTEN: PRJ_NOTIFICATION = 8;
pub const PRJ_NOTIFICATION_PRJ_NOTIFICATION_PRE_DELETE: PRJ_NOTIFICATION = 16;
pub const PRJ_NOTIFICATION_PRJ_NOTIFICATION_PRE_RENAME: PRJ_NOTIFICATION = 32;
pub const PRJ_NOTIFICATION_PRJ_NOTIFICATION_PRE_SET_HARDLINK: PRJ_NOTIFICATION = 64;
pub const PRJ_NOTIFICATION_PRJ_NOTIFICATION_FILE_RENAMED: PRJ_NOTIFICATION = 128;
pub const PRJ_NOTIFICATION_PRJ_NOTIFICATION_HARDLINK_CREATED: PRJ_NOTIFICATION = 256;
pub const PRJ_NOTIFICATION_PRJ_NOTIFICATION_FILE_HANDLE_CLOSED_NO_MODIFICATION: PRJ_NOTIFICATION =
512;
pub const PRJ_NOTIFICATION_PRJ_NOTIFICATION_FILE_HANDLE_CLOSED_FILE_MODIFIED: PRJ_NOTIFICATION =
1024;
pub const PRJ_NOTIFICATION_PRJ_NOTIFICATION_FILE_HANDLE_CLOSED_FILE_DELETED: PRJ_NOTIFICATION =
2048;
pub const PRJ_NOTIFICATION_PRJ_NOTIFICATION_FILE_PRE_CONVERT_TO_FULL: PRJ_NOTIFICATION = 4096;
pub type PRJ_NOTIFICATION = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PRJ_NAMESPACE_VIRTUALIZATION_CONTEXT__ {
pub unused: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_PRJ_NAMESPACE_VIRTUALIZATION_CONTEXT__() {
assert_eq!(
::std::mem::size_of::<PRJ_NAMESPACE_VIRTUALIZATION_CONTEXT__>(),
4usize,
concat!(
"Size of: ",
stringify!(PRJ_NAMESPACE_VIRTUALIZATION_CONTEXT__)
)
);
assert_eq!(
::std::mem::align_of::<PRJ_NAMESPACE_VIRTUALIZATION_CONTEXT__>(),
4usize,
concat!(
"Alignment of ",
stringify!(PRJ_NAMESPACE_VIRTUALIZATION_CONTEXT__)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_NAMESPACE_VIRTUALIZATION_CONTEXT__>())).unused as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(PRJ_NAMESPACE_VIRTUALIZATION_CONTEXT__),
"::",
stringify!(unused)
)
);
}
pub type PRJ_NAMESPACE_VIRTUALIZATION_CONTEXT = *mut PRJ_NAMESPACE_VIRTUALIZATION_CONTEXT__;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PRJ_DIR_ENTRY_BUFFER_HANDLE__ {
pub unused: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_PRJ_DIR_ENTRY_BUFFER_HANDLE__() {
assert_eq!(
::std::mem::size_of::<PRJ_DIR_ENTRY_BUFFER_HANDLE__>(),
4usize,
concat!("Size of: ", stringify!(PRJ_DIR_ENTRY_BUFFER_HANDLE__))
);
assert_eq!(
::std::mem::align_of::<PRJ_DIR_ENTRY_BUFFER_HANDLE__>(),
4usize,
concat!("Alignment of ", stringify!(PRJ_DIR_ENTRY_BUFFER_HANDLE__))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_DIR_ENTRY_BUFFER_HANDLE__>())).unused as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(PRJ_DIR_ENTRY_BUFFER_HANDLE__),
"::",
stringify!(unused)
)
);
}
pub type PRJ_DIR_ENTRY_BUFFER_HANDLE = *mut PRJ_DIR_ENTRY_BUFFER_HANDLE__;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PRJ_NOTIFICATION_MAPPING {
pub NotificationBitMask: PRJ_NOTIFY_TYPES,
pub NotificationRoot: PCWSTR,
}
#[test]
fn bindgen_test_layout_PRJ_NOTIFICATION_MAPPING() {
assert_eq!(
::std::mem::size_of::<PRJ_NOTIFICATION_MAPPING>(),
16usize,
concat!("Size of: ", stringify!(PRJ_NOTIFICATION_MAPPING))
);
assert_eq!(
::std::mem::align_of::<PRJ_NOTIFICATION_MAPPING>(),
8usize,
concat!("Alignment of ", stringify!(PRJ_NOTIFICATION_MAPPING))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_NOTIFICATION_MAPPING>())).NotificationBitMask as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(PRJ_NOTIFICATION_MAPPING),
"::",
stringify!(NotificationBitMask)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_NOTIFICATION_MAPPING>())).NotificationRoot as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(PRJ_NOTIFICATION_MAPPING),
"::",
stringify!(NotificationRoot)
)
);
}
pub const PRJ_STARTVIRTUALIZING_FLAGS_PRJ_FLAG_NONE: PRJ_STARTVIRTUALIZING_FLAGS = 0;
pub const PRJ_STARTVIRTUALIZING_FLAGS_PRJ_FLAG_USE_NEGATIVE_PATH_CACHE:
PRJ_STARTVIRTUALIZING_FLAGS = 1;
pub type PRJ_STARTVIRTUALIZING_FLAGS = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PRJ_STARTVIRTUALIZING_OPTIONS {
pub Flags: PRJ_STARTVIRTUALIZING_FLAGS,
pub PoolThreadCount: UINT32,
pub ConcurrentThreadCount: UINT32,
pub NotificationMappings: *mut PRJ_NOTIFICATION_MAPPING,
pub NotificationMappingsCount: UINT32,
}
#[test]
fn bindgen_test_layout_PRJ_STARTVIRTUALIZING_OPTIONS() {
assert_eq!(
::std::mem::size_of::<PRJ_STARTVIRTUALIZING_OPTIONS>(),
32usize,
concat!("Size of: ", stringify!(PRJ_STARTVIRTUALIZING_OPTIONS))
);
assert_eq!(
::std::mem::align_of::<PRJ_STARTVIRTUALIZING_OPTIONS>(),
8usize,
concat!("Alignment of ", stringify!(PRJ_STARTVIRTUALIZING_OPTIONS))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_STARTVIRTUALIZING_OPTIONS>())).Flags as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(PRJ_STARTVIRTUALIZING_OPTIONS),
"::",
stringify!(Flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_STARTVIRTUALIZING_OPTIONS>())).PoolThreadCount as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(PRJ_STARTVIRTUALIZING_OPTIONS),
"::",
stringify!(PoolThreadCount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_STARTVIRTUALIZING_OPTIONS>())).ConcurrentThreadCount
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(PRJ_STARTVIRTUALIZING_OPTIONS),
"::",
stringify!(ConcurrentThreadCount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_STARTVIRTUALIZING_OPTIONS>())).NotificationMappings
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(PRJ_STARTVIRTUALIZING_OPTIONS),
"::",
stringify!(NotificationMappings)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_STARTVIRTUALIZING_OPTIONS>())).NotificationMappingsCount
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(PRJ_STARTVIRTUALIZING_OPTIONS),
"::",
stringify!(NotificationMappingsCount)
)
);
}
extern "C" {
pub fn PrjStartVirtualizing(
virtualizationRootPath: PCWSTR,
callbacks: *const PRJ_CALLBACKS,
instanceContext: *const ::std::os::raw::c_void,
options: *const PRJ_STARTVIRTUALIZING_OPTIONS,
namespaceVirtualizationContext: *mut PRJ_NAMESPACE_VIRTUALIZATION_CONTEXT,
) -> HRESULT;
}
extern "C" {
pub fn PrjStopVirtualizing(
namespaceVirtualizationContext: PRJ_NAMESPACE_VIRTUALIZATION_CONTEXT,
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct PRJ_PLACEHOLDER_VERSION_INFO {
pub ProviderID: [UINT8; 128usize],
pub ContentID: [UINT8; 128usize],
}
#[test]
fn bindgen_test_layout_PRJ_PLACEHOLDER_VERSION_INFO() {
assert_eq!(
::std::mem::size_of::<PRJ_PLACEHOLDER_VERSION_INFO>(),
256usize,
concat!("Size of: ", stringify!(PRJ_PLACEHOLDER_VERSION_INFO))
);
assert_eq!(
::std::mem::align_of::<PRJ_PLACEHOLDER_VERSION_INFO>(),
1usize,
concat!("Alignment of ", stringify!(PRJ_PLACEHOLDER_VERSION_INFO))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_PLACEHOLDER_VERSION_INFO>())).ProviderID as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(PRJ_PLACEHOLDER_VERSION_INFO),
"::",
stringify!(ProviderID)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_PLACEHOLDER_VERSION_INFO>())).ContentID as *const _ as usize
},
128usize,
concat!(
"Offset of field: ",
stringify!(PRJ_PLACEHOLDER_VERSION_INFO),
"::",
stringify!(ContentID)
)
);
}
extern "C" {
pub fn PrjMarkDirectoryAsPlaceholder(
rootPathName: PCWSTR,
targetPathName: PCWSTR,
versionInfo: *const PRJ_PLACEHOLDER_VERSION_INFO,
virtualizationInstanceID: *const GUID,
) -> HRESULT;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct PRJ_FILE_BASIC_INFO {
pub IsDirectory: BOOLEAN,
pub FileSize: INT64,
pub CreationTime: LARGE_INTEGER,
pub LastAccessTime: LARGE_INTEGER,
pub LastWriteTime: LARGE_INTEGER,
pub ChangeTime: LARGE_INTEGER,
pub FileAttributes: UINT32,
}
#[test]
fn bindgen_test_layout_PRJ_FILE_BASIC_INFO() {
assert_eq!(
::std::mem::size_of::<PRJ_FILE_BASIC_INFO>(),
56usize,
concat!("Size of: ", stringify!(PRJ_FILE_BASIC_INFO))
);
assert_eq!(
::std::mem::align_of::<PRJ_FILE_BASIC_INFO>(),
8usize,
concat!("Alignment of ", stringify!(PRJ_FILE_BASIC_INFO))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<PRJ_FILE_BASIC_INFO>())).IsDirectory as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(PRJ_FILE_BASIC_INFO),
"::",
stringify!(IsDirectory)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<PRJ_FILE_BASIC_INFO>())).FileSize as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(PRJ_FILE_BASIC_INFO),
"::",
stringify!(FileSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_FILE_BASIC_INFO>())).CreationTime as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(PRJ_FILE_BASIC_INFO),
"::",
stringify!(CreationTime)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_FILE_BASIC_INFO>())).LastAccessTime as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(PRJ_FILE_BASIC_INFO),
"::",
stringify!(LastAccessTime)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_FILE_BASIC_INFO>())).LastWriteTime as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(PRJ_FILE_BASIC_INFO),
"::",
stringify!(LastWriteTime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<PRJ_FILE_BASIC_INFO>())).ChangeTime as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(PRJ_FILE_BASIC_INFO),
"::",
stringify!(ChangeTime)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_FILE_BASIC_INFO>())).FileAttributes as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(PRJ_FILE_BASIC_INFO),
"::",
stringify!(FileAttributes)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct PRJ_PLACEHOLDER_INFO {
pub FileBasicInfo: PRJ_FILE_BASIC_INFO,
pub EaInformation: PRJ_PLACEHOLDER_INFO__bindgen_ty_1,
pub SecurityInformation: PRJ_PLACEHOLDER_INFO__bindgen_ty_2,
pub StreamsInformation: PRJ_PLACEHOLDER_INFO__bindgen_ty_3,
pub VersionInfo: PRJ_PLACEHOLDER_VERSION_INFO,
pub VariableData: [UINT8; 1usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PRJ_PLACEHOLDER_INFO__bindgen_ty_1 {
pub EaBufferSize: UINT32,
pub OffsetToFirstEa: UINT32,
}
#[test]
fn bindgen_test_layout_PRJ_PLACEHOLDER_INFO__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<PRJ_PLACEHOLDER_INFO__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(PRJ_PLACEHOLDER_INFO__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<PRJ_PLACEHOLDER_INFO__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(PRJ_PLACEHOLDER_INFO__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_PLACEHOLDER_INFO__bindgen_ty_1>())).EaBufferSize as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(PRJ_PLACEHOLDER_INFO__bindgen_ty_1),
"::",
stringify!(EaBufferSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_PLACEHOLDER_INFO__bindgen_ty_1>())).OffsetToFirstEa
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(PRJ_PLACEHOLDER_INFO__bindgen_ty_1),
"::",
stringify!(OffsetToFirstEa)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PRJ_PLACEHOLDER_INFO__bindgen_ty_2 {
pub SecurityBufferSize: UINT32,
pub OffsetToSecurityDescriptor: UINT32,
}
#[test]
fn bindgen_test_layout_PRJ_PLACEHOLDER_INFO__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<PRJ_PLACEHOLDER_INFO__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(PRJ_PLACEHOLDER_INFO__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<PRJ_PLACEHOLDER_INFO__bindgen_ty_2>(),
4usize,
concat!(
"Alignment of ",
stringify!(PRJ_PLACEHOLDER_INFO__bindgen_ty_2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_PLACEHOLDER_INFO__bindgen_ty_2>())).SecurityBufferSize
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(PRJ_PLACEHOLDER_INFO__bindgen_ty_2),
"::",
stringify!(SecurityBufferSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_PLACEHOLDER_INFO__bindgen_ty_2>()))
.OffsetToSecurityDescriptor as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(PRJ_PLACEHOLDER_INFO__bindgen_ty_2),
"::",
stringify!(OffsetToSecurityDescriptor)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PRJ_PLACEHOLDER_INFO__bindgen_ty_3 {
pub StreamsInfoBufferSize: UINT32,
pub OffsetToFirstStreamInfo: UINT32,
}
#[test]
fn bindgen_test_layout_PRJ_PLACEHOLDER_INFO__bindgen_ty_3() {
assert_eq!(
::std::mem::size_of::<PRJ_PLACEHOLDER_INFO__bindgen_ty_3>(),
8usize,
concat!("Size of: ", stringify!(PRJ_PLACEHOLDER_INFO__bindgen_ty_3))
);
assert_eq!(
::std::mem::align_of::<PRJ_PLACEHOLDER_INFO__bindgen_ty_3>(),
4usize,
concat!(
"Alignment of ",
stringify!(PRJ_PLACEHOLDER_INFO__bindgen_ty_3)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_PLACEHOLDER_INFO__bindgen_ty_3>())).StreamsInfoBufferSize
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(PRJ_PLACEHOLDER_INFO__bindgen_ty_3),
"::",
stringify!(StreamsInfoBufferSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_PLACEHOLDER_INFO__bindgen_ty_3>())).OffsetToFirstStreamInfo
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(PRJ_PLACEHOLDER_INFO__bindgen_ty_3),
"::",
stringify!(OffsetToFirstStreamInfo)
)
);
}
#[test]
fn bindgen_test_layout_PRJ_PLACEHOLDER_INFO() {
assert_eq!(
::std::mem::size_of::<PRJ_PLACEHOLDER_INFO>(),
344usize,
concat!("Size of: ", stringify!(PRJ_PLACEHOLDER_INFO))
);
assert_eq!(
::std::mem::align_of::<PRJ_PLACEHOLDER_INFO>(),
8usize,
concat!("Alignment of ", stringify!(PRJ_PLACEHOLDER_INFO))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_PLACEHOLDER_INFO>())).FileBasicInfo as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(PRJ_PLACEHOLDER_INFO),
"::",
stringify!(FileBasicInfo)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_PLACEHOLDER_INFO>())).EaInformation as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(PRJ_PLACEHOLDER_INFO),
"::",
stringify!(EaInformation)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_PLACEHOLDER_INFO>())).SecurityInformation as *const _
as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(PRJ_PLACEHOLDER_INFO),
"::",
stringify!(SecurityInformation)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_PLACEHOLDER_INFO>())).StreamsInformation as *const _ as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(PRJ_PLACEHOLDER_INFO),
"::",
stringify!(StreamsInformation)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_PLACEHOLDER_INFO>())).VersionInfo as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(PRJ_PLACEHOLDER_INFO),
"::",
stringify!(VersionInfo)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_PLACEHOLDER_INFO>())).VariableData as *const _ as usize
},
336usize,
concat!(
"Offset of field: ",
stringify!(PRJ_PLACEHOLDER_INFO),
"::",
stringify!(VariableData)
)
);
}
extern "C" {
pub fn PrjWritePlaceholderInfo(
namespaceVirtualizationContext: PRJ_NAMESPACE_VIRTUALIZATION_CONTEXT,
destinationFileName: PCWSTR,
placeholderInfo: *const PRJ_PLACEHOLDER_INFO,
placeholderInfoSize: UINT32,
) -> HRESULT;
}
extern "C" {
pub fn PrjWriteFileData(
namespaceVirtualizationContext: PRJ_NAMESPACE_VIRTUALIZATION_CONTEXT,
dataStreamId: *const GUID,
buffer: *mut ::std::os::raw::c_void,
byteOffset: UINT64,
length: UINT32,
) -> HRESULT;
}
extern "C" {
pub fn PrjAllocateAlignedBuffer(
namespaceVirtualizationContext: PRJ_NAMESPACE_VIRTUALIZATION_CONTEXT,
size: size_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn PrjFreeAlignedBuffer(buffer: *mut ::std::os::raw::c_void);
}
pub const PRJ_CALLBACK_DATA_FLAGS_PRJ_CB_DATA_FLAG_ENUM_RESTART_SCAN: PRJ_CALLBACK_DATA_FLAGS = 1;
pub const PRJ_CALLBACK_DATA_FLAGS_PRJ_CB_DATA_FLAG_ENUM_RETURN_SINGLE_ENTRY:
PRJ_CALLBACK_DATA_FLAGS = 2;
pub type PRJ_CALLBACK_DATA_FLAGS = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PRJ_CALLBACK_DATA {
pub Size: UINT32,
pub Flags: PRJ_CALLBACK_DATA_FLAGS,
pub NamespaceVirtualizationContext: PRJ_NAMESPACE_VIRTUALIZATION_CONTEXT,
pub CommandId: INT32,
pub FileId: GUID,
pub DataStreamId: GUID,
pub FilePathName: PCWSTR,
pub VersionInfo: *mut PRJ_PLACEHOLDER_VERSION_INFO,
pub TriggeringProcessId: UINT32,
pub TriggeringProcessImageFileName: PCWSTR,
pub InstanceContext: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_PRJ_CALLBACK_DATA() {
assert_eq!(
::std::mem::size_of::<PRJ_CALLBACK_DATA>(),
96usize,
concat!("Size of: ", stringify!(PRJ_CALLBACK_DATA))
);
assert_eq!(
::std::mem::align_of::<PRJ_CALLBACK_DATA>(),
8usize,
concat!("Alignment of ", stringify!(PRJ_CALLBACK_DATA))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<PRJ_CALLBACK_DATA>())).Size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(PRJ_CALLBACK_DATA),
"::",
stringify!(Size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<PRJ_CALLBACK_DATA>())).Flags as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(PRJ_CALLBACK_DATA),
"::",
stringify!(Flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_CALLBACK_DATA>())).NamespaceVirtualizationContext as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(PRJ_CALLBACK_DATA),
"::",
stringify!(NamespaceVirtualizationContext)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<PRJ_CALLBACK_DATA>())).CommandId as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(PRJ_CALLBACK_DATA),
"::",
stringify!(CommandId)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<PRJ_CALLBACK_DATA>())).FileId as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(PRJ_CALLBACK_DATA),
"::",
stringify!(FileId)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<PRJ_CALLBACK_DATA>())).DataStreamId as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(PRJ_CALLBACK_DATA),
"::",
stringify!(DataStreamId)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<PRJ_CALLBACK_DATA>())).FilePathName as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(PRJ_CALLBACK_DATA),
"::",
stringify!(FilePathName)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<PRJ_CALLBACK_DATA>())).VersionInfo as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(PRJ_CALLBACK_DATA),
"::",
stringify!(VersionInfo)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_CALLBACK_DATA>())).TriggeringProcessId as *const _ as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(PRJ_CALLBACK_DATA),
"::",
stringify!(TriggeringProcessId)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_CALLBACK_DATA>())).TriggeringProcessImageFileName as *const _
as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(PRJ_CALLBACK_DATA),
"::",
stringify!(TriggeringProcessImageFileName)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_CALLBACK_DATA>())).InstanceContext as *const _ as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(PRJ_CALLBACK_DATA),
"::",
stringify!(InstanceContext)
)
);
}
pub type PRJ_START_DIRECTORY_ENUMERATION_CB = ::std::option::Option<
unsafe extern "C" fn(
callbackData: *const PRJ_CALLBACK_DATA,
enumerationId: *const GUID,
) -> HRESULT,
>;
pub type PRJ_GET_DIRECTORY_ENUMERATION_CB = ::std::option::Option<
unsafe extern "C" fn(
callbackData: *const PRJ_CALLBACK_DATA,
enumerationId: *const GUID,
searchExpression: PCWSTR,
dirEntryBufferHandle: PRJ_DIR_ENTRY_BUFFER_HANDLE,
) -> HRESULT,
>;
pub type PRJ_END_DIRECTORY_ENUMERATION_CB = ::std::option::Option<
unsafe extern "C" fn(
callbackData: *const PRJ_CALLBACK_DATA,
enumerationId: *const GUID,
) -> HRESULT,
>;
pub type PRJ_GET_PLACEHOLDER_INFO_CB =
::std::option::Option<unsafe extern "C" fn(callbackData: *const PRJ_CALLBACK_DATA) -> HRESULT>;
pub type PRJ_GET_FILE_DATA_CB = ::std::option::Option<
unsafe extern "C" fn(
callbackData: *const PRJ_CALLBACK_DATA,
byteOffset: UINT64,
length: UINT32,
) -> HRESULT,
>;
pub type PRJ_QUERY_FILE_NAME_CB =
::std::option::Option<unsafe extern "C" fn(callbackData: *const PRJ_CALLBACK_DATA) -> HRESULT>;
#[repr(C)]
#[derive(Copy, Clone)]
pub union PRJ_NOTIFICATION_PARAMETERS {
pub PostCreate: PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_1,
pub FileRenamed: PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_2,
pub FileDeletedOnHandleClose: PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_3,
_bindgen_union_align: u32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_1 {
pub NotificationMask: PRJ_NOTIFY_TYPES,
}
#[test]
fn bindgen_test_layout_PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_1>(),
4usize,
concat!(
"Size of: ",
stringify!(PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_1>())).NotificationMask
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_1),
"::",
stringify!(NotificationMask)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_2 {
pub NotificationMask: PRJ_NOTIFY_TYPES,
}
#[test]
fn bindgen_test_layout_PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_2>(),
4usize,
concat!(
"Size of: ",
stringify!(PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_2)
)
);
assert_eq!(
::std::mem::align_of::<PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_2>(),
4usize,
concat!(
"Alignment of ",
stringify!(PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_2>())).NotificationMask
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_2),
"::",
stringify!(NotificationMask)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_3 {
pub IsFileModified: BOOLEAN,
}
#[test]
fn bindgen_test_layout_PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_3() {
assert_eq!(
::std::mem::size_of::<PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_3>(),
1usize,
concat!(
"Size of: ",
stringify!(PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_3)
)
);
assert_eq!(
::std::mem::align_of::<PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_3>(),
1usize,
concat!(
"Alignment of ",
stringify!(PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_3)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_3>())).IsFileModified
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(PRJ_NOTIFICATION_PARAMETERS__bindgen_ty_3),
"::",
stringify!(IsFileModified)
)
);
}
#[test]
fn bindgen_test_layout_PRJ_NOTIFICATION_PARAMETERS() {
assert_eq!(
::std::mem::size_of::<PRJ_NOTIFICATION_PARAMETERS>(),
4usize,
concat!("Size of: ", stringify!(PRJ_NOTIFICATION_PARAMETERS))
);
assert_eq!(
::std::mem::align_of::<PRJ_NOTIFICATION_PARAMETERS>(),
4usize,
concat!("Alignment of ", stringify!(PRJ_NOTIFICATION_PARAMETERS))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_NOTIFICATION_PARAMETERS>())).PostCreate as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(PRJ_NOTIFICATION_PARAMETERS),
"::",
stringify!(PostCreate)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_NOTIFICATION_PARAMETERS>())).FileRenamed as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(PRJ_NOTIFICATION_PARAMETERS),
"::",
stringify!(FileRenamed)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_NOTIFICATION_PARAMETERS>())).FileDeletedOnHandleClose
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(PRJ_NOTIFICATION_PARAMETERS),
"::",
stringify!(FileDeletedOnHandleClose)
)
);
}
pub type PRJ_NOTIFICATION_CB = ::std::option::Option<
unsafe extern "C" fn(
callbackData: *const PRJ_CALLBACK_DATA,
isDirectory: BOOLEAN,
notification: PRJ_NOTIFICATION,
destinationFileName: PCWSTR,
operationParameters: *mut PRJ_NOTIFICATION_PARAMETERS,
) -> HRESULT,
>;
pub type PRJ_CANCEL_COMMAND_CB =
::std::option::Option<unsafe extern "C" fn(callbackData: *const PRJ_CALLBACK_DATA)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PRJ_CALLBACKS {
pub StartDirectoryEnumerationCallback: PRJ_START_DIRECTORY_ENUMERATION_CB,
pub EndDirectoryEnumerationCallback: PRJ_END_DIRECTORY_ENUMERATION_CB,
pub GetDirectoryEnumerationCallback: PRJ_GET_DIRECTORY_ENUMERATION_CB,
pub GetPlaceholderInfoCallback: PRJ_GET_PLACEHOLDER_INFO_CB,
pub GetFileDataCallback: PRJ_GET_FILE_DATA_CB,
pub QueryFileNameCallback: PRJ_QUERY_FILE_NAME_CB,
pub NotificationCallback: PRJ_NOTIFICATION_CB,
pub CancelCommandCallback: PRJ_CANCEL_COMMAND_CB,
}
#[test]
fn bindgen_test_layout_PRJ_CALLBACKS() {
assert_eq!(
::std::mem::size_of::<PRJ_CALLBACKS>(),
64usize,
concat!("Size of: ", stringify!(PRJ_CALLBACKS))
);
assert_eq!(
::std::mem::align_of::<PRJ_CALLBACKS>(),
8usize,
concat!("Alignment of ", stringify!(PRJ_CALLBACKS))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_CALLBACKS>())).StartDirectoryEnumerationCallback as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(PRJ_CALLBACKS),
"::",
stringify!(StartDirectoryEnumerationCallback)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_CALLBACKS>())).EndDirectoryEnumerationCallback as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(PRJ_CALLBACKS),
"::",
stringify!(EndDirectoryEnumerationCallback)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_CALLBACKS>())).GetDirectoryEnumerationCallback as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(PRJ_CALLBACKS),
"::",
stringify!(GetDirectoryEnumerationCallback)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_CALLBACKS>())).GetPlaceholderInfoCallback as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(PRJ_CALLBACKS),
"::",
stringify!(GetPlaceholderInfoCallback)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_CALLBACKS>())).GetFileDataCallback as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(PRJ_CALLBACKS),
"::",
stringify!(GetFileDataCallback)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_CALLBACKS>())).QueryFileNameCallback as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(PRJ_CALLBACKS),
"::",
stringify!(QueryFileNameCallback)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_CALLBACKS>())).NotificationCallback as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(PRJ_CALLBACKS),
"::",
stringify!(NotificationCallback)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<PRJ_CALLBACKS>())).CancelCommandCallback as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(PRJ_CALLBACKS),
"::",
stringify!(CancelCommandCallback)
)
);
}
extern "C" {
pub fn PrjFillDirEntryBuffer(
fileName: PCWSTR,
fileBasicInfo: *mut PRJ_FILE_BASIC_INFO,
dirEntryBufferHandle: PRJ_DIR_ENTRY_BUFFER_HANDLE,
) -> HRESULT;
}
extern "C" {
pub fn PrjFileNameMatch(fileNameToCheck: PCWSTR, pattern: PCWSTR) -> BOOLEAN;
}
pub const IO_ERROR_OK: IO_ERROR = 0;
pub const IO_ERROR_FILE_NOT_FOUND: IO_ERROR = 2;
pub const IO_ERROR_IO_PENDING: IO_ERROR = 997;
pub const IO_ERROR_INSUFFICIENT_BUFFER: IO_ERROR = 122;
pub type IO_ERROR = u32;