vendor/windows/src/Windows/Win32/Storage/DataDeduplication/mod.rs

   1 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
   2 #[repr(transparent)]
   3 pub struct IDedupBackupSupport(::windows::core::IUnknown);
   4 impl IDedupBackupSupport {
   5     pub unsafe fn RestoreFiles<P0>(&self, numberoffiles: u32, filefullpaths: *const ::windows::core::BSTR, store: P0, flags: u32, fileresults: *mut ::windows::core::HRESULT) -> ::windows::core::Result<()>
   6     where
   7         P0: ::windows::core::IntoParam<IDedupReadFileCallback>,
   8     {
   9         (::windows::core::Interface::vtable(self).RestoreFiles)(::windows::core::Interface::as_raw(self), numberoffiles, ::core::mem::transmute(filefullpaths), store.into_param().abi(), flags, fileresults).ok()
  10     }
  11 }
  12 ::windows::imp::interface_hierarchy!(IDedupBackupSupport, ::windows::core::IUnknown);
  13 impl ::core::cmp::PartialEq for IDedupBackupSupport {
  14     fn eq(&self, other: &Self) -> bool {
  15         self.0 == other.0
  16     }
  17 }
  18 impl ::core::cmp::Eq for IDedupBackupSupport {}
  19 impl ::core::fmt::Debug for IDedupBackupSupport {
  20     fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
  21         f.debug_tuple("IDedupBackupSupport").field(&self.0).finish()
  22     }
  23 }
  24 unsafe impl ::windows::core::Interface for IDedupBackupSupport {
  25     type Vtable = IDedupBackupSupport_Vtbl;
  26 }
  27 impl ::core::clone::Clone for IDedupBackupSupport {
  28     fn clone(&self) -> Self {
  29         Self(self.0.clone())
  30     }
  31 }
  32 unsafe impl ::windows::core::ComInterface for IDedupBackupSupport {
  33     const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc719d963_2b2d_415e_acf7_7eb7ca596ff4);
  34 }
  35 #[repr(C)]
  36 #[doc(hidden)]
  37 pub struct IDedupBackupSupport_Vtbl {
  38     pub base__: ::windows::core::IUnknown_Vtbl,
  39     pub RestoreFiles: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, numberoffiles: u32, filefullpaths: *const ::std::mem::MaybeUninit<::windows::core::BSTR>, store: *mut ::core::ffi::c_void, flags: u32, fileresults: *mut ::windows::core::HRESULT) -> ::windows::core::HRESULT,
  40 }
  41 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
  42 #[repr(transparent)]
  43 pub struct IDedupChunkLibrary(::windows::core::IUnknown);
  44 impl IDedupChunkLibrary {
  45     pub unsafe fn InitializeForPushBuffers(&self) -> ::windows::core::Result<()> {
  46         (::windows::core::Interface::vtable(self).InitializeForPushBuffers)(::windows::core::Interface::as_raw(self)).ok()
  47     }
  48     pub unsafe fn Uninitialize(&self) -> ::windows::core::Result<()> {
  49         (::windows::core::Interface::vtable(self).Uninitialize)(::windows::core::Interface::as_raw(self)).ok()
  50     }
  51     #[doc = "*Required features: `\"Win32_Foundation\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`*"]
  52     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
  53     pub unsafe fn SetParameter(&self, dwparamtype: u32, vparamvalue: super::super::System::Com::VARIANT) -> ::windows::core::Result<()> {
  54         (::windows::core::Interface::vtable(self).SetParameter)(::windows::core::Interface::as_raw(self), dwparamtype, ::core::mem::transmute(vparamvalue)).ok()
  55     }
  56     pub unsafe fn StartChunking(&self, iiditeratorinterfaceid: ::windows::core::GUID) -> ::windows::core::Result<::windows::core::IUnknown> {
  57         let mut result__ = ::windows::core::zeroed::<::windows::core::IUnknown>();
  58         (::windows::core::Interface::vtable(self).StartChunking)(::windows::core::Interface::as_raw(self), ::core::mem::transmute(iiditeratorinterfaceid), &mut result__).from_abi(result__)
  59     }
  60 }
  61 ::windows::imp::interface_hierarchy!(IDedupChunkLibrary, ::windows::core::IUnknown);
  62 impl ::core::cmp::PartialEq for IDedupChunkLibrary {
  63     fn eq(&self, other: &Self) -> bool {
  64         self.0 == other.0
  65     }
  66 }
  67 impl ::core::cmp::Eq for IDedupChunkLibrary {}
  68 impl ::core::fmt::Debug for IDedupChunkLibrary {
  69     fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
  70         f.debug_tuple("IDedupChunkLibrary").field(&self.0).finish()
  71     }
  72 }
  73 unsafe impl ::windows::core::Interface for IDedupChunkLibrary {
  74     type Vtable = IDedupChunkLibrary_Vtbl;
  75 }
  76 impl ::core::clone::Clone for IDedupChunkLibrary {
  77     fn clone(&self) -> Self {
  78         Self(self.0.clone())
  79     }
  80 }
  81 unsafe impl ::windows::core::ComInterface for IDedupChunkLibrary {
  82     const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbb5144d7_2720_4dcc_8777_78597416ec23);
  83 }
  84 #[repr(C)]
  85 #[doc(hidden)]
  86 pub struct IDedupChunkLibrary_Vtbl {
  87     pub base__: ::windows::core::IUnknown_Vtbl,
  88     pub InitializeForPushBuffers: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
  89     pub Uninitialize: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
  90     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
  91     pub SetParameter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwparamtype: u32, vparamvalue: super::super::System::Com::VARIANT) -> ::windows::core::HRESULT,
  92     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))]
  93     SetParameter: usize,
  94     pub StartChunking: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iiditeratorinterfaceid: ::windows::core::GUID, ppchunksenum: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
  95 }
  96 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
  97 #[repr(transparent)]
  98 pub struct IDedupDataPort(::windows::core::IUnknown);
  99 impl IDedupDataPort {
 100     pub unsafe fn GetStatus(&self, pstatus: *mut DedupDataPortVolumeStatus, pdataheadroommb: *mut u32) -> ::windows::core::Result<()> {
 101         (::windows::core::Interface::vtable(self).GetStatus)(::windows::core::Interface::as_raw(self), pstatus, pdataheadroommb).ok()
 102     }
 103     pub unsafe fn LookupChunks(&self, phashes: &[DedupHash]) -> ::windows::core::Result<::windows::core::GUID> {
 104         let mut result__ = ::windows::core::zeroed::<::windows::core::GUID>();
 105         (::windows::core::Interface::vtable(self).LookupChunks)(::windows::core::Interface::as_raw(self), phashes.len() as _, ::core::mem::transmute(phashes.as_ptr()), &mut result__).from_abi(result__)
 106     }
 107     pub unsafe fn InsertChunks(&self, pchunkmetadata: &[DedupChunk], pchunkdata: &[u8]) -> ::windows::core::Result<::windows::core::GUID> {
 108         let mut result__ = ::windows::core::zeroed::<::windows::core::GUID>();
 109         (::windows::core::Interface::vtable(self).InsertChunks)(::windows::core::Interface::as_raw(self), pchunkmetadata.len() as _, ::core::mem::transmute(pchunkmetadata.as_ptr()), pchunkdata.len() as _, ::core::mem::transmute(pchunkdata.as_ptr()), &mut result__).from_abi(result__)
 110     }
 111     #[doc = "*Required features: `\"Win32_System_Com\"`*"]
 112     #[cfg(feature = "Win32_System_Com")]
 113     pub unsafe fn InsertChunksWithStream<P0>(&self, pchunkmetadata: &[DedupChunk], databytecount: u32, pchunkdatastream: P0) -> ::windows::core::Result<::windows::core::GUID>
 114     where
 115         P0: ::windows::core::IntoParam<super::super::System::Com::IStream>,
 116     {
 117         let mut result__ = ::windows::core::zeroed::<::windows::core::GUID>();
 118         (::windows::core::Interface::vtable(self).InsertChunksWithStream)(::windows::core::Interface::as_raw(self), pchunkmetadata.len() as _, ::core::mem::transmute(pchunkmetadata.as_ptr()), databytecount, pchunkdatastream.into_param().abi(), &mut result__).from_abi(result__)
 119     }
 120     pub unsafe fn CommitStreams(&self, pstreams: &[DedupStream], pentries: &[DedupStreamEntry]) -> ::windows::core::Result<::windows::core::GUID> {
 121         let mut result__ = ::windows::core::zeroed::<::windows::core::GUID>();
 122         (::windows::core::Interface::vtable(self).CommitStreams)(::windows::core::Interface::as_raw(self), pstreams.len() as _, ::core::mem::transmute(pstreams.as_ptr()), pentries.len() as _, ::core::mem::transmute(pentries.as_ptr()), &mut result__).from_abi(result__)
 123     }
 124     #[doc = "*Required features: `\"Win32_System_Com\"`*"]
 125     #[cfg(feature = "Win32_System_Com")]
 126     pub unsafe fn CommitStreamsWithStream<P0>(&self, pstreams: &[DedupStream], entrycount: u32, pentriesstream: P0) -> ::windows::core::Result<::windows::core::GUID>
 127     where
 128         P0: ::windows::core::IntoParam<super::super::System::Com::IStream>,
 129     {
 130         let mut result__ = ::windows::core::zeroed::<::windows::core::GUID>();
 131         (::windows::core::Interface::vtable(self).CommitStreamsWithStream)(::windows::core::Interface::as_raw(self), pstreams.len() as _, ::core::mem::transmute(pstreams.as_ptr()), entrycount, pentriesstream.into_param().abi(), &mut result__).from_abi(result__)
 132     }
 133     pub unsafe fn GetStreams(&self, pstreampaths: &[::windows::core::BSTR]) -> ::windows::core::Result<::windows::core::GUID> {
 134         let mut result__ = ::windows::core::zeroed::<::windows::core::GUID>();
 135         (::windows::core::Interface::vtable(self).GetStreams)(::windows::core::Interface::as_raw(self), pstreampaths.len() as _, ::core::mem::transmute(pstreampaths.as_ptr()), &mut result__).from_abi(result__)
 136     }
 137     pub unsafe fn GetStreamsResults(&self, requestid: ::windows::core::GUID, maxwaitms: u32, streamentryindex: u32, pstreamcount: *mut u32, ppstreams: *mut *mut DedupStream, pentrycount: *mut u32, ppentries: *mut *mut DedupStreamEntry, pstatus: *mut DedupDataPortRequestStatus, ppitemresults: *mut *mut ::windows::core::HRESULT) -> ::windows::core::Result<()> {
 138         (::windows::core::Interface::vtable(self).GetStreamsResults)(::windows::core::Interface::as_raw(self), ::core::mem::transmute(requestid), maxwaitms, streamentryindex, pstreamcount, ppstreams, pentrycount, ppentries, pstatus, ppitemresults).ok()
 139     }
 140     pub unsafe fn GetChunks(&self, phashes: &[DedupHash]) -> ::windows::core::Result<::windows::core::GUID> {
 141         let mut result__ = ::windows::core::zeroed::<::windows::core::GUID>();
 142         (::windows::core::Interface::vtable(self).GetChunks)(::windows::core::Interface::as_raw(self), phashes.len() as _, ::core::mem::transmute(phashes.as_ptr()), &mut result__).from_abi(result__)
 143     }
 144     pub unsafe fn GetChunksResults(&self, requestid: ::windows::core::GUID, maxwaitms: u32, chunkindex: u32, pchunkcount: *mut u32, ppchunkmetadata: *mut *mut DedupChunk, pdatabytecount: *mut u32, ppchunkdata: *mut *mut u8, pstatus: *mut DedupDataPortRequestStatus, ppitemresults: *mut *mut ::windows::core::HRESULT) -> ::windows::core::Result<()> {
 145         (::windows::core::Interface::vtable(self).GetChunksResults)(::windows::core::Interface::as_raw(self), ::core::mem::transmute(requestid), maxwaitms, chunkindex, pchunkcount, ppchunkmetadata, pdatabytecount, ppchunkdata, pstatus, ppitemresults).ok()
 146     }
 147     pub unsafe fn GetRequestStatus(&self, requestid: ::windows::core::GUID) -> ::windows::core::Result<DedupDataPortRequestStatus> {
 148         let mut result__ = ::windows::core::zeroed::<DedupDataPortRequestStatus>();
 149         (::windows::core::Interface::vtable(self).GetRequestStatus)(::windows::core::Interface::as_raw(self), ::core::mem::transmute(requestid), &mut result__).from_abi(result__)
 150     }
 151     pub unsafe fn GetRequestResults(&self, requestid: ::windows::core::GUID, maxwaitms: u32, pbatchresult: *mut ::windows::core::HRESULT, pbatchcount: *mut u32, pstatus: *mut DedupDataPortRequestStatus, ppitemresults: *mut *mut ::windows::core::HRESULT) -> ::windows::core::Result<()> {
 152         (::windows::core::Interface::vtable(self).GetRequestResults)(::windows::core::Interface::as_raw(self), ::core::mem::transmute(requestid), maxwaitms, pbatchresult, pbatchcount, pstatus, ppitemresults).ok()
 153     }
 154 }
 155 ::windows::imp::interface_hierarchy!(IDedupDataPort, ::windows::core::IUnknown);
 156 impl ::core::cmp::PartialEq for IDedupDataPort {
 157     fn eq(&self, other: &Self) -> bool {
 158         self.0 == other.0
 159     }
 160 }
 161 impl ::core::cmp::Eq for IDedupDataPort {}
 162 impl ::core::fmt::Debug for IDedupDataPort {
 163     fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
 164         f.debug_tuple("IDedupDataPort").field(&self.0).finish()
 165     }
 166 }
 167 unsafe impl ::windows::core::Interface for IDedupDataPort {
 168     type Vtable = IDedupDataPort_Vtbl;
 169 }
 170 impl ::core::clone::Clone for IDedupDataPort {
 171     fn clone(&self) -> Self {
 172         Self(self.0.clone())
 173     }
 174 }
 175 unsafe impl ::windows::core::ComInterface for IDedupDataPort {
 176     const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7963d734_40a9_4ea3_bbf6_5a89d26f7ae8);
 177 }
 178 #[repr(C)]
 179 #[doc(hidden)]
 180 pub struct IDedupDataPort_Vtbl {
 181     pub base__: ::windows::core::IUnknown_Vtbl,
 182     pub GetStatus: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstatus: *mut DedupDataPortVolumeStatus, pdataheadroommb: *mut u32) -> ::windows::core::HRESULT,
 183     pub LookupChunks: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, count: u32, phashes: *const DedupHash, prequestid: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
 184     pub InsertChunks: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, chunkcount: u32, pchunkmetadata: *const DedupChunk, databytecount: u32, pchunkdata: *const u8, prequestid: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
 185     #[cfg(feature = "Win32_System_Com")]
 186     pub InsertChunksWithStream: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, chunkcount: u32, pchunkmetadata: *const DedupChunk, databytecount: u32, pchunkdatastream: *mut ::core::ffi::c_void, prequestid: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
 187     #[cfg(not(feature = "Win32_System_Com"))]
 188     InsertChunksWithStream: usize,
 189     pub CommitStreams: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, streamcount: u32, pstreams: *const DedupStream, entrycount: u32, pentries: *const DedupStreamEntry, prequestid: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
 190     #[cfg(feature = "Win32_System_Com")]
 191     pub CommitStreamsWithStream: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, streamcount: u32, pstreams: *const DedupStream, entrycount: u32, pentriesstream: *mut ::core::ffi::c_void, prequestid: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
 192     #[cfg(not(feature = "Win32_System_Com"))]
 193     CommitStreamsWithStream: usize,
 194     pub GetStreams: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, streamcount: u32, pstreampaths: *const ::std::mem::MaybeUninit<::windows::core::BSTR>, prequestid: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
 195     pub GetStreamsResults: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, requestid: ::windows::core::GUID, maxwaitms: u32, streamentryindex: u32, pstreamcount: *mut u32, ppstreams: *mut *mut DedupStream, pentrycount: *mut u32, ppentries: *mut *mut DedupStreamEntry, pstatus: *mut DedupDataPortRequestStatus, ppitemresults: *mut *mut ::windows::core::HRESULT) -> ::windows::core::HRESULT,
 196     pub GetChunks: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, count: u32, phashes: *const DedupHash, prequestid: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
 197     pub GetChunksResults: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, requestid: ::windows::core::GUID, maxwaitms: u32, chunkindex: u32, pchunkcount: *mut u32, ppchunkmetadata: *mut *mut DedupChunk, pdatabytecount: *mut u32, ppchunkdata: *mut *mut u8, pstatus: *mut DedupDataPortRequestStatus, ppitemresults: *mut *mut ::windows::core::HRESULT) -> ::windows::core::HRESULT,
 198     pub GetRequestStatus: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, requestid: ::windows::core::GUID, pstatus: *mut DedupDataPortRequestStatus) -> ::windows::core::HRESULT,
 199     pub GetRequestResults: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, requestid: ::windows::core::GUID, maxwaitms: u32, pbatchresult: *mut ::windows::core::HRESULT, pbatchcount: *mut u32, pstatus: *mut DedupDataPortRequestStatus, ppitemresults: *mut *mut ::windows::core::HRESULT) -> ::windows::core::HRESULT,
 200 }
 201 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 202 #[repr(transparent)]
 203 pub struct IDedupDataPortManager(::windows::core::IUnknown);
 204 impl IDedupDataPortManager {
 205     pub unsafe fn GetConfiguration(&self, pminchunksize: *mut u32, pmaxchunksize: *mut u32, pchunkingalgorithm: *mut DedupChunkingAlgorithm, phashingalgorithm: *mut DedupHashingAlgorithm, pcompressionalgorithm: *mut DedupCompressionAlgorithm) -> ::windows::core::Result<()> {
 206         (::windows::core::Interface::vtable(self).GetConfiguration)(::windows::core::Interface::as_raw(self), pminchunksize, pmaxchunksize, pchunkingalgorithm, phashingalgorithm, pcompressionalgorithm).ok()
 207     }
 208     pub unsafe fn GetVolumeStatus<P0>(&self, options: u32, path: P0) -> ::windows::core::Result<DedupDataPortVolumeStatus>
 209     where
 210         P0: ::windows::core::IntoParam<::windows::core::BSTR>,
 211     {
 212         let mut result__ = ::windows::core::zeroed::<DedupDataPortVolumeStatus>();
 213         (::windows::core::Interface::vtable(self).GetVolumeStatus)(::windows::core::Interface::as_raw(self), options, path.into_param().abi(), &mut result__).from_abi(result__)
 214     }
 215     pub unsafe fn GetVolumeDataPort<P0>(&self, options: u32, path: P0) -> ::windows::core::Result<IDedupDataPort>
 216     where
 217         P0: ::windows::core::IntoParam<::windows::core::BSTR>,
 218     {
 219         let mut result__ = ::windows::core::zeroed::<IDedupDataPort>();
 220         (::windows::core::Interface::vtable(self).GetVolumeDataPort)(::windows::core::Interface::as_raw(self), options, path.into_param().abi(), &mut result__).from_abi(result__)
 221     }
 222 }
 223 ::windows::imp::interface_hierarchy!(IDedupDataPortManager, ::windows::core::IUnknown);
 224 impl ::core::cmp::PartialEq for IDedupDataPortManager {
 225     fn eq(&self, other: &Self) -> bool {
 226         self.0 == other.0
 227     }
 228 }
 229 impl ::core::cmp::Eq for IDedupDataPortManager {}
 230 impl ::core::fmt::Debug for IDedupDataPortManager {
 231     fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
 232         f.debug_tuple("IDedupDataPortManager").field(&self.0).finish()
 233     }
 234 }
 235 unsafe impl ::windows::core::Interface for IDedupDataPortManager {
 236     type Vtable = IDedupDataPortManager_Vtbl;
 237 }
 238 impl ::core::clone::Clone for IDedupDataPortManager {
 239     fn clone(&self) -> Self {
 240         Self(self.0.clone())
 241     }
 242 }
 243 unsafe impl ::windows::core::ComInterface for IDedupDataPortManager {
 244     const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x44677452_b90a_445e_8192_cdcfe81511fb);
 245 }
 246 #[repr(C)]
 247 #[doc(hidden)]
 248 pub struct IDedupDataPortManager_Vtbl {
 249     pub base__: ::windows::core::IUnknown_Vtbl,
 250     pub GetConfiguration: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pminchunksize: *mut u32, pmaxchunksize: *mut u32, pchunkingalgorithm: *mut DedupChunkingAlgorithm, phashingalgorithm: *mut DedupHashingAlgorithm, pcompressionalgorithm: *mut DedupCompressionAlgorithm) -> ::windows::core::HRESULT,
 251     pub GetVolumeStatus: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, options: u32, path: ::std::mem::MaybeUninit<::windows::core::BSTR>, pstatus: *mut DedupDataPortVolumeStatus) -> ::windows::core::HRESULT,
 252     pub GetVolumeDataPort: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, options: u32, path: ::std::mem::MaybeUninit<::windows::core::BSTR>, ppdataport: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
 253 }
 254 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 255 #[repr(transparent)]
 256 pub struct IDedupIterateChunksHash32(::windows::core::IUnknown);
 257 impl IDedupIterateChunksHash32 {
 258     pub unsafe fn PushBuffer(&self, pbuffer: &[u8]) -> ::windows::core::Result<()> {
 259         (::windows::core::Interface::vtable(self).PushBuffer)(::windows::core::Interface::as_raw(self), ::core::mem::transmute(pbuffer.as_ptr()), pbuffer.len() as _).ok()
 260     }
 261     pub unsafe fn Next(&self, parrchunks: &mut [DEDUP_CHUNK_INFO_HASH32], pulfetched: *mut u32) -> ::windows::core::Result<()> {
 262         (::windows::core::Interface::vtable(self).Next)(::windows::core::Interface::as_raw(self), parrchunks.len() as _, ::core::mem::transmute(parrchunks.as_ptr()), pulfetched).ok()
 263     }
 264     pub unsafe fn Drain(&self) -> ::windows::core::Result<()> {
 265         (::windows::core::Interface::vtable(self).Drain)(::windows::core::Interface::as_raw(self)).ok()
 266     }
 267     pub unsafe fn Reset(&self) -> ::windows::core::Result<()> {
 268         (::windows::core::Interface::vtable(self).Reset)(::windows::core::Interface::as_raw(self)).ok()
 269     }
 270 }
 271 ::windows::imp::interface_hierarchy!(IDedupIterateChunksHash32, ::windows::core::IUnknown);
 272 impl ::core::cmp::PartialEq for IDedupIterateChunksHash32 {
 273     fn eq(&self, other: &Self) -> bool {
 274         self.0 == other.0
 275     }
 276 }
 277 impl ::core::cmp::Eq for IDedupIterateChunksHash32 {}
 278 impl ::core::fmt::Debug for IDedupIterateChunksHash32 {
 279     fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
 280         f.debug_tuple("IDedupIterateChunksHash32").field(&self.0).finish()
 281     }
 282 }
 283 unsafe impl ::windows::core::Interface for IDedupIterateChunksHash32 {
 284     type Vtable = IDedupIterateChunksHash32_Vtbl;
 285 }
 286 impl ::core::clone::Clone for IDedupIterateChunksHash32 {
 287     fn clone(&self) -> Self {
 288         Self(self.0.clone())
 289     }
 290 }
 291 unsafe impl ::windows::core::ComInterface for IDedupIterateChunksHash32 {
 292     const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x90b584d3_72aa_400f_9767_cad866a5a2d8);
 293 }
 294 #[repr(C)]
 295 #[doc(hidden)]
 296 pub struct IDedupIterateChunksHash32_Vtbl {
 297     pub base__: ::windows::core::IUnknown_Vtbl,
 298     pub PushBuffer: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbuffer: *const u8, ulbufferlength: u32) -> ::windows::core::HRESULT,
 299     pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ulmaxchunks: u32, parrchunks: *mut DEDUP_CHUNK_INFO_HASH32, pulfetched: *mut u32) -> ::windows::core::HRESULT,
 300     pub Drain: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
 301     pub Reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
 302 }
 303 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 304 #[repr(transparent)]
 305 pub struct IDedupReadFileCallback(::windows::core::IUnknown);
 306 impl IDedupReadFileCallback {
 307     pub unsafe fn ReadBackupFile<P0>(&self, filefullpath: P0, fileoffset: i64, filebuffer: &mut [u8], returnedsize: *mut u32, flags: u32) -> ::windows::core::Result<()>
 308     where
 309         P0: ::windows::core::IntoParam<::windows::core::BSTR>,
 310     {
 311         (::windows::core::Interface::vtable(self).ReadBackupFile)(::windows::core::Interface::as_raw(self), filefullpath.into_param().abi(), fileoffset, filebuffer.len() as _, ::core::mem::transmute(filebuffer.as_ptr()), returnedsize, flags).ok()
 312     }
 313     pub unsafe fn OrderContainersRestore(&self, containerpaths: &[::windows::core::BSTR], readplanentries: *mut u32, readplan: *mut *mut DEDUP_CONTAINER_EXTENT) -> ::windows::core::Result<()> {
 314         (::windows::core::Interface::vtable(self).OrderContainersRestore)(::windows::core::Interface::as_raw(self), containerpaths.len() as _, ::core::mem::transmute(containerpaths.as_ptr()), readplanentries, readplan).ok()
 315     }
 316     pub unsafe fn PreviewContainerRead<P0>(&self, filefullpath: P0, readoffsets: &[DDP_FILE_EXTENT]) -> ::windows::core::Result<()>
 317     where
 318         P0: ::windows::core::IntoParam<::windows::core::BSTR>,
 319     {
 320         (::windows::core::Interface::vtable(self).PreviewContainerRead)(::windows::core::Interface::as_raw(self), filefullpath.into_param().abi(), readoffsets.len() as _, ::core::mem::transmute(readoffsets.as_ptr())).ok()
 321     }
 322 }
 323 ::windows::imp::interface_hierarchy!(IDedupReadFileCallback, ::windows::core::IUnknown);
 324 impl ::core::cmp::PartialEq for IDedupReadFileCallback {
 325     fn eq(&self, other: &Self) -> bool {
 326         self.0 == other.0
 327     }
 328 }
 329 impl ::core::cmp::Eq for IDedupReadFileCallback {}
 330 impl ::core::fmt::Debug for IDedupReadFileCallback {
 331     fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
 332         f.debug_tuple("IDedupReadFileCallback").field(&self.0).finish()
 333     }
 334 }
 335 unsafe impl ::windows::core::Interface for IDedupReadFileCallback {
 336     type Vtable = IDedupReadFileCallback_Vtbl;
 337 }
 338 impl ::core::clone::Clone for IDedupReadFileCallback {
 339     fn clone(&self) -> Self {
 340         Self(self.0.clone())
 341     }
 342 }
 343 unsafe impl ::windows::core::ComInterface for IDedupReadFileCallback {
 344     const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7bacc67a_2f1d_42d0_897e_6ff62dd533bb);
 345 }
 346 #[repr(C)]
 347 #[doc(hidden)]
 348 pub struct IDedupReadFileCallback_Vtbl {
 349     pub base__: ::windows::core::IUnknown_Vtbl,
 350     pub ReadBackupFile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filefullpath: ::std::mem::MaybeUninit<::windows::core::BSTR>, fileoffset: i64, sizetoread: u32, filebuffer: *mut u8, returnedsize: *mut u32, flags: u32) -> ::windows::core::HRESULT,
 351     pub OrderContainersRestore: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, numberofcontainers: u32, containerpaths: *const ::std::mem::MaybeUninit<::windows::core::BSTR>, readplanentries: *mut u32, readplan: *mut *mut DEDUP_CONTAINER_EXTENT) -> ::windows::core::HRESULT,
 352     pub PreviewContainerRead: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filefullpath: ::std::mem::MaybeUninit<::windows::core::BSTR>, numberofreads: u32, readoffsets: *const DDP_FILE_EXTENT) -> ::windows::core::HRESULT,
 353 }
 354 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 355 pub const DEDUP_CHUNKLIB_MAX_CHUNKS_ENUM: u32 = 1024u32;
 356 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 357 pub const DedupBackupSupport: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x73d6b2ad_2984_4715_b2e3_924c149744dd);
 358 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 359 pub const DedupDataPort: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8f107207_1829_48b2_a64b_e61f8e0d9acb);
 360 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 361 #[repr(transparent)]
 362 #[derive(::core::cmp::PartialEq, ::core::cmp::Eq)]
 363 pub struct DEDUP_BACKUP_SUPPORT_PARAM_TYPE(pub i32);
 364 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 365 pub const DEDUP_RECONSTRUCT_UNOPTIMIZED: DEDUP_BACKUP_SUPPORT_PARAM_TYPE = DEDUP_BACKUP_SUPPORT_PARAM_TYPE(1i32);
 366 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 367 pub const DEDUP_RECONSTRUCT_OPTIMIZED: DEDUP_BACKUP_SUPPORT_PARAM_TYPE = DEDUP_BACKUP_SUPPORT_PARAM_TYPE(2i32);
 368 impl ::core::marker::Copy for DEDUP_BACKUP_SUPPORT_PARAM_TYPE {}
 369 impl ::core::clone::Clone for DEDUP_BACKUP_SUPPORT_PARAM_TYPE {
 370     fn clone(&self) -> Self {
 371         *self
 372     }
 373 }
 374 impl ::core::default::Default for DEDUP_BACKUP_SUPPORT_PARAM_TYPE {
 375     fn default() -> Self {
 376         Self(0)
 377     }
 378 }
 379 impl ::windows::core::TypeKind for DEDUP_BACKUP_SUPPORT_PARAM_TYPE {
 380     type TypeKind = ::windows::core::CopyType;
 381 }
 382 impl ::core::fmt::Debug for DEDUP_BACKUP_SUPPORT_PARAM_TYPE {
 383     fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
 384         f.debug_tuple("DEDUP_BACKUP_SUPPORT_PARAM_TYPE").field(&self.0).finish()
 385     }
 386 }
 387 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 388 #[repr(transparent)]
 389 #[derive(::core::cmp::PartialEq, ::core::cmp::Eq)]
 390 pub struct DEDUP_SET_PARAM_TYPE(pub i32);
 391 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 392 pub const DEDUP_PT_MinChunkSizeBytes: DEDUP_SET_PARAM_TYPE = DEDUP_SET_PARAM_TYPE(1i32);
 393 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 394 pub const DEDUP_PT_MaxChunkSizeBytes: DEDUP_SET_PARAM_TYPE = DEDUP_SET_PARAM_TYPE(2i32);
 395 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 396 pub const DEDUP_PT_AvgChunkSizeBytes: DEDUP_SET_PARAM_TYPE = DEDUP_SET_PARAM_TYPE(3i32);
 397 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 398 pub const DEDUP_PT_InvariantChunking: DEDUP_SET_PARAM_TYPE = DEDUP_SET_PARAM_TYPE(4i32);
 399 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 400 pub const DEDUP_PT_DisableStrongHashComputation: DEDUP_SET_PARAM_TYPE = DEDUP_SET_PARAM_TYPE(5i32);
 401 impl ::core::marker::Copy for DEDUP_SET_PARAM_TYPE {}
 402 impl ::core::clone::Clone for DEDUP_SET_PARAM_TYPE {
 403     fn clone(&self) -> Self {
 404         *self
 405     }
 406 }
 407 impl ::core::default::Default for DEDUP_SET_PARAM_TYPE {
 408     fn default() -> Self {
 409         Self(0)
 410     }
 411 }
 412 impl ::windows::core::TypeKind for DEDUP_SET_PARAM_TYPE {
 413     type TypeKind = ::windows::core::CopyType;
 414 }
 415 impl ::core::fmt::Debug for DEDUP_SET_PARAM_TYPE {
 416     fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
 417         f.debug_tuple("DEDUP_SET_PARAM_TYPE").field(&self.0).finish()
 418     }
 419 }
 420 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 421 #[repr(transparent)]
 422 #[derive(::core::cmp::PartialEq, ::core::cmp::Eq)]
 423 pub struct DedupChunkFlags(pub i32);
 424 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 425 pub const DedupChunkFlags_None: DedupChunkFlags = DedupChunkFlags(0i32);
 426 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 427 pub const DedupChunkFlags_Compressed: DedupChunkFlags = DedupChunkFlags(1i32);
 428 impl ::core::marker::Copy for DedupChunkFlags {}
 429 impl ::core::clone::Clone for DedupChunkFlags {
 430     fn clone(&self) -> Self {
 431         *self
 432     }
 433 }
 434 impl ::core::default::Default for DedupChunkFlags {
 435     fn default() -> Self {
 436         Self(0)
 437     }
 438 }
 439 impl ::windows::core::TypeKind for DedupChunkFlags {
 440     type TypeKind = ::windows::core::CopyType;
 441 }
 442 impl ::core::fmt::Debug for DedupChunkFlags {
 443     fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
 444         f.debug_tuple("DedupChunkFlags").field(&self.0).finish()
 445     }
 446 }
 447 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 448 #[repr(transparent)]
 449 #[derive(::core::cmp::PartialEq, ::core::cmp::Eq)]
 450 pub struct DedupChunkingAlgorithm(pub i32);
 451 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 452 pub const DedupChunkingAlgorithm_Unknonwn: DedupChunkingAlgorithm = DedupChunkingAlgorithm(0i32);
 453 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 454 pub const DedupChunkingAlgorithm_V1: DedupChunkingAlgorithm = DedupChunkingAlgorithm(1i32);
 455 impl ::core::marker::Copy for DedupChunkingAlgorithm {}
 456 impl ::core::clone::Clone for DedupChunkingAlgorithm {
 457     fn clone(&self) -> Self {
 458         *self
 459     }
 460 }
 461 impl ::core::default::Default for DedupChunkingAlgorithm {
 462     fn default() -> Self {
 463         Self(0)
 464     }
 465 }
 466 impl ::windows::core::TypeKind for DedupChunkingAlgorithm {
 467     type TypeKind = ::windows::core::CopyType;
 468 }
 469 impl ::core::fmt::Debug for DedupChunkingAlgorithm {
 470     fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
 471         f.debug_tuple("DedupChunkingAlgorithm").field(&self.0).finish()
 472     }
 473 }
 474 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 475 #[repr(transparent)]
 476 #[derive(::core::cmp::PartialEq, ::core::cmp::Eq)]
 477 pub struct DedupCompressionAlgorithm(pub i32);
 478 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 479 pub const DedupCompressionAlgorithm_Unknonwn: DedupCompressionAlgorithm = DedupCompressionAlgorithm(0i32);
 480 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 481 pub const DedupCompressionAlgorithm_Xpress: DedupCompressionAlgorithm = DedupCompressionAlgorithm(1i32);
 482 impl ::core::marker::Copy for DedupCompressionAlgorithm {}
 483 impl ::core::clone::Clone for DedupCompressionAlgorithm {
 484     fn clone(&self) -> Self {
 485         *self
 486     }
 487 }
 488 impl ::core::default::Default for DedupCompressionAlgorithm {
 489     fn default() -> Self {
 490         Self(0)
 491     }
 492 }
 493 impl ::windows::core::TypeKind for DedupCompressionAlgorithm {
 494     type TypeKind = ::windows::core::CopyType;
 495 }
 496 impl ::core::fmt::Debug for DedupCompressionAlgorithm {
 497     fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
 498         f.debug_tuple("DedupCompressionAlgorithm").field(&self.0).finish()
 499     }
 500 }
 501 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 502 #[repr(transparent)]
 503 #[derive(::core::cmp::PartialEq, ::core::cmp::Eq)]
 504 pub struct DedupDataPortManagerOption(pub i32);
 505 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 506 pub const DedupDataPortManagerOption_None: DedupDataPortManagerOption = DedupDataPortManagerOption(0i32);
 507 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 508 pub const DedupDataPortManagerOption_AutoStart: DedupDataPortManagerOption = DedupDataPortManagerOption(1i32);
 509 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 510 pub const DedupDataPortManagerOption_SkipReconciliation: DedupDataPortManagerOption = DedupDataPortManagerOption(2i32);
 511 impl ::core::marker::Copy for DedupDataPortManagerOption {}
 512 impl ::core::clone::Clone for DedupDataPortManagerOption {
 513     fn clone(&self) -> Self {
 514         *self
 515     }
 516 }
 517 impl ::core::default::Default for DedupDataPortManagerOption {
 518     fn default() -> Self {
 519         Self(0)
 520     }
 521 }
 522 impl ::windows::core::TypeKind for DedupDataPortManagerOption {
 523     type TypeKind = ::windows::core::CopyType;
 524 }
 525 impl ::core::fmt::Debug for DedupDataPortManagerOption {
 526     fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
 527         f.debug_tuple("DedupDataPortManagerOption").field(&self.0).finish()
 528     }
 529 }
 530 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 531 #[repr(transparent)]
 532 #[derive(::core::cmp::PartialEq, ::core::cmp::Eq)]
 533 pub struct DedupDataPortRequestStatus(pub i32);
 534 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 535 pub const DedupDataPortRequestStatus_Unknown: DedupDataPortRequestStatus = DedupDataPortRequestStatus(0i32);
 536 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 537 pub const DedupDataPortRequestStatus_Queued: DedupDataPortRequestStatus = DedupDataPortRequestStatus(1i32);
 538 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 539 pub const DedupDataPortRequestStatus_Processing: DedupDataPortRequestStatus = DedupDataPortRequestStatus(2i32);
 540 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 541 pub const DedupDataPortRequestStatus_Partial: DedupDataPortRequestStatus = DedupDataPortRequestStatus(3i32);
 542 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 543 pub const DedupDataPortRequestStatus_Complete: DedupDataPortRequestStatus = DedupDataPortRequestStatus(4i32);
 544 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 545 pub const DedupDataPortRequestStatus_Failed: DedupDataPortRequestStatus = DedupDataPortRequestStatus(5i32);
 546 impl ::core::marker::Copy for DedupDataPortRequestStatus {}
 547 impl ::core::clone::Clone for DedupDataPortRequestStatus {
 548     fn clone(&self) -> Self {
 549         *self
 550     }
 551 }
 552 impl ::core::default::Default for DedupDataPortRequestStatus {
 553     fn default() -> Self {
 554         Self(0)
 555     }
 556 }
 557 impl ::windows::core::TypeKind for DedupDataPortRequestStatus {
 558     type TypeKind = ::windows::core::CopyType;
 559 }
 560 impl ::core::fmt::Debug for DedupDataPortRequestStatus {
 561     fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
 562         f.debug_tuple("DedupDataPortRequestStatus").field(&self.0).finish()
 563     }
 564 }
 565 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 566 #[repr(transparent)]
 567 #[derive(::core::cmp::PartialEq, ::core::cmp::Eq)]
 568 pub struct DedupDataPortVolumeStatus(pub i32);
 569 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 570 pub const DedupDataPortVolumeStatus_Unknown: DedupDataPortVolumeStatus = DedupDataPortVolumeStatus(0i32);
 571 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 572 pub const DedupDataPortVolumeStatus_NotEnabled: DedupDataPortVolumeStatus = DedupDataPortVolumeStatus(1i32);
 573 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 574 pub const DedupDataPortVolumeStatus_NotAvailable: DedupDataPortVolumeStatus = DedupDataPortVolumeStatus(2i32);
 575 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 576 pub const DedupDataPortVolumeStatus_Initializing: DedupDataPortVolumeStatus = DedupDataPortVolumeStatus(3i32);
 577 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 578 pub const DedupDataPortVolumeStatus_Ready: DedupDataPortVolumeStatus = DedupDataPortVolumeStatus(4i32);
 579 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 580 pub const DedupDataPortVolumeStatus_Maintenance: DedupDataPortVolumeStatus = DedupDataPortVolumeStatus(5i32);
 581 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 582 pub const DedupDataPortVolumeStatus_Shutdown: DedupDataPortVolumeStatus = DedupDataPortVolumeStatus(6i32);
 583 impl ::core::marker::Copy for DedupDataPortVolumeStatus {}
 584 impl ::core::clone::Clone for DedupDataPortVolumeStatus {
 585     fn clone(&self) -> Self {
 586         *self
 587     }
 588 }
 589 impl ::core::default::Default for DedupDataPortVolumeStatus {
 590     fn default() -> Self {
 591         Self(0)
 592     }
 593 }
 594 impl ::windows::core::TypeKind for DedupDataPortVolumeStatus {
 595     type TypeKind = ::windows::core::CopyType;
 596 }
 597 impl ::core::fmt::Debug for DedupDataPortVolumeStatus {
 598     fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
 599         f.debug_tuple("DedupDataPortVolumeStatus").field(&self.0).finish()
 600     }
 601 }
 602 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 603 #[repr(transparent)]
 604 #[derive(::core::cmp::PartialEq, ::core::cmp::Eq)]
 605 pub struct DedupHashingAlgorithm(pub i32);
 606 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 607 pub const DedupHashingAlgorithm_Unknonwn: DedupHashingAlgorithm = DedupHashingAlgorithm(0i32);
 608 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 609 pub const DedupHashingAlgorithm_V1: DedupHashingAlgorithm = DedupHashingAlgorithm(1i32);
 610 impl ::core::marker::Copy for DedupHashingAlgorithm {}
 611 impl ::core::clone::Clone for DedupHashingAlgorithm {
 612     fn clone(&self) -> Self {
 613         *self
 614     }
 615 }
 616 impl ::core::default::Default for DedupHashingAlgorithm {
 617     fn default() -> Self {
 618         Self(0)
 619     }
 620 }
 621 impl ::windows::core::TypeKind for DedupHashingAlgorithm {
 622     type TypeKind = ::windows::core::CopyType;
 623 }
 624 impl ::core::fmt::Debug for DedupHashingAlgorithm {
 625     fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
 626         f.debug_tuple("DedupHashingAlgorithm").field(&self.0).finish()
 627     }
 628 }
 629 #[repr(C)]
 630 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 631 pub struct DDP_FILE_EXTENT {
 632     pub Length: i64,
 633     pub Offset: i64,
 634 }
 635 impl ::core::marker::Copy for DDP_FILE_EXTENT {}
 636 impl ::core::clone::Clone for DDP_FILE_EXTENT {
 637     fn clone(&self) -> Self {
 638         *self
 639     }
 640 }
 641 impl ::core::fmt::Debug for DDP_FILE_EXTENT {
 642     fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
 643         f.debug_struct("DDP_FILE_EXTENT").field("Length", &self.Length).field("Offset", &self.Offset).finish()
 644     }
 645 }
 646 impl ::windows::core::TypeKind for DDP_FILE_EXTENT {
 647     type TypeKind = ::windows::core::CopyType;
 648 }
 649 impl ::core::cmp::PartialEq for DDP_FILE_EXTENT {
 650     fn eq(&self, other: &Self) -> bool {
 651         self.Length == other.Length && self.Offset == other.Offset
 652     }
 653 }
 654 impl ::core::cmp::Eq for DDP_FILE_EXTENT {}
 655 impl ::core::default::Default for DDP_FILE_EXTENT {
 656     fn default() -> Self {
 657         unsafe { ::core::mem::zeroed() }
 658     }
 659 }
 660 #[repr(C)]
 661 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 662 pub struct DEDUP_CHUNK_INFO_HASH32 {
 663     pub ChunkFlags: u32,
 664     pub ChunkOffsetInStream: u64,
 665     pub ChunkSize: u64,
 666     pub HashVal: [u8; 32],
 667 }
 668 impl ::core::marker::Copy for DEDUP_CHUNK_INFO_HASH32 {}
 669 impl ::core::clone::Clone for DEDUP_CHUNK_INFO_HASH32 {
 670     fn clone(&self) -> Self {
 671         *self
 672     }
 673 }
 674 impl ::core::fmt::Debug for DEDUP_CHUNK_INFO_HASH32 {
 675     fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
 676         f.debug_struct("DEDUP_CHUNK_INFO_HASH32").field("ChunkFlags", &self.ChunkFlags).field("ChunkOffsetInStream", &self.ChunkOffsetInStream).field("ChunkSize", &self.ChunkSize).field("HashVal", &self.HashVal).finish()
 677     }
 678 }
 679 impl ::windows::core::TypeKind for DEDUP_CHUNK_INFO_HASH32 {
 680     type TypeKind = ::windows::core::CopyType;
 681 }
 682 impl ::core::cmp::PartialEq for DEDUP_CHUNK_INFO_HASH32 {
 683     fn eq(&self, other: &Self) -> bool {
 684         self.ChunkFlags == other.ChunkFlags && self.ChunkOffsetInStream == other.ChunkOffsetInStream && self.ChunkSize == other.ChunkSize && self.HashVal == other.HashVal
 685     }
 686 }
 687 impl ::core::cmp::Eq for DEDUP_CHUNK_INFO_HASH32 {}
 688 impl ::core::default::Default for DEDUP_CHUNK_INFO_HASH32 {
 689     fn default() -> Self {
 690         unsafe { ::core::mem::zeroed() }
 691     }
 692 }
 693 #[repr(C)]
 694 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 695 pub struct DEDUP_CONTAINER_EXTENT {
 696     pub ContainerIndex: u32,
 697     pub StartOffset: i64,
 698     pub Length: i64,
 699 }
 700 impl ::core::marker::Copy for DEDUP_CONTAINER_EXTENT {}
 701 impl ::core::clone::Clone for DEDUP_CONTAINER_EXTENT {
 702     fn clone(&self) -> Self {
 703         *self
 704     }
 705 }
 706 impl ::core::fmt::Debug for DEDUP_CONTAINER_EXTENT {
 707     fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
 708         f.debug_struct("DEDUP_CONTAINER_EXTENT").field("ContainerIndex", &self.ContainerIndex).field("StartOffset", &self.StartOffset).field("Length", &self.Length).finish()
 709     }
 710 }
 711 impl ::windows::core::TypeKind for DEDUP_CONTAINER_EXTENT {
 712     type TypeKind = ::windows::core::CopyType;
 713 }
 714 impl ::core::cmp::PartialEq for DEDUP_CONTAINER_EXTENT {
 715     fn eq(&self, other: &Self) -> bool {
 716         self.ContainerIndex == other.ContainerIndex && self.StartOffset == other.StartOffset && self.Length == other.Length
 717     }
 718 }
 719 impl ::core::cmp::Eq for DEDUP_CONTAINER_EXTENT {}
 720 impl ::core::default::Default for DEDUP_CONTAINER_EXTENT {
 721     fn default() -> Self {
 722         unsafe { ::core::mem::zeroed() }
 723     }
 724 }
 725 #[repr(C)]
 726 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 727 pub struct DedupChunk {
 728     pub Hash: DedupHash,
 729     pub Flags: DedupChunkFlags,
 730     pub LogicalSize: u32,
 731     pub DataSize: u32,
 732 }
 733 impl ::core::marker::Copy for DedupChunk {}
 734 impl ::core::clone::Clone for DedupChunk {
 735     fn clone(&self) -> Self {
 736         *self
 737     }
 738 }
 739 impl ::core::fmt::Debug for DedupChunk {
 740     fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
 741         f.debug_struct("DedupChunk").field("Hash", &self.Hash).field("Flags", &self.Flags).field("LogicalSize", &self.LogicalSize).field("DataSize", &self.DataSize).finish()
 742     }
 743 }
 744 impl ::windows::core::TypeKind for DedupChunk {
 745     type TypeKind = ::windows::core::CopyType;
 746 }
 747 impl ::core::cmp::PartialEq for DedupChunk {
 748     fn eq(&self, other: &Self) -> bool {
 749         self.Hash == other.Hash && self.Flags == other.Flags && self.LogicalSize == other.LogicalSize && self.DataSize == other.DataSize
 750     }
 751 }
 752 impl ::core::cmp::Eq for DedupChunk {}
 753 impl ::core::default::Default for DedupChunk {
 754     fn default() -> Self {
 755         unsafe { ::core::mem::zeroed() }
 756     }
 757 }
 758 #[repr(C)]
 759 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 760 pub struct DedupHash {
 761     pub Hash: [u8; 32],
 762 }
 763 impl ::core::marker::Copy for DedupHash {}
 764 impl ::core::clone::Clone for DedupHash {
 765     fn clone(&self) -> Self {
 766         *self
 767     }
 768 }
 769 impl ::core::fmt::Debug for DedupHash {
 770     fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
 771         f.debug_struct("DedupHash").field("Hash", &self.Hash).finish()
 772     }
 773 }
 774 impl ::windows::core::TypeKind for DedupHash {
 775     type TypeKind = ::windows::core::CopyType;
 776 }
 777 impl ::core::cmp::PartialEq for DedupHash {
 778     fn eq(&self, other: &Self) -> bool {
 779         self.Hash == other.Hash
 780     }
 781 }
 782 impl ::core::cmp::Eq for DedupHash {}
 783 impl ::core::default::Default for DedupHash {
 784     fn default() -> Self {
 785         unsafe { ::core::mem::zeroed() }
 786     }
 787 }
 788 #[repr(C)]
 789 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 790 pub struct DedupStream {
 791     pub Path: ::std::mem::ManuallyDrop<::windows::core::BSTR>,
 792     pub Offset: u64,
 793     pub Length: u64,
 794     pub ChunkCount: u32,
 795 }
 796 impl ::core::clone::Clone for DedupStream {
 797     fn clone(&self) -> Self {
 798         unsafe { ::core::mem::transmute_copy(self) }
 799     }
 800 }
 801 impl ::core::fmt::Debug for DedupStream {
 802     fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
 803         f.debug_struct("DedupStream").field("Path", &self.Path).field("Offset", &self.Offset).field("Length", &self.Length).field("ChunkCount", &self.ChunkCount).finish()
 804     }
 805 }
 806 impl ::windows::core::TypeKind for DedupStream {
 807     type TypeKind = ::windows::core::CopyType;
 808 }
 809 impl ::core::cmp::PartialEq for DedupStream {
 810     fn eq(&self, other: &Self) -> bool {
 811         self.Path == other.Path && self.Offset == other.Offset && self.Length == other.Length && self.ChunkCount == other.ChunkCount
 812     }
 813 }
 814 impl ::core::cmp::Eq for DedupStream {}
 815 impl ::core::default::Default for DedupStream {
 816     fn default() -> Self {
 817         unsafe { ::core::mem::zeroed() }
 818     }
 819 }
 820 #[repr(C)]
 821 #[doc = "*Required features: `\"Win32_Storage_DataDeduplication\"`*"]
 822 pub struct DedupStreamEntry {
 823     pub Hash: DedupHash,
 824     pub LogicalSize: u32,
 825     pub Offset: u64,
 826 }
 827 impl ::core::marker::Copy for DedupStreamEntry {}
 828 impl ::core::clone::Clone for DedupStreamEntry {
 829     fn clone(&self) -> Self {
 830         *self
 831     }
 832 }
 833 impl ::core::fmt::Debug for DedupStreamEntry {
 834     fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
 835         f.debug_struct("DedupStreamEntry").field("Hash", &self.Hash).field("LogicalSize", &self.LogicalSize).field("Offset", &self.Offset).finish()
 836     }
 837 }
 838 impl ::windows::core::TypeKind for DedupStreamEntry {
 839     type TypeKind = ::windows::core::CopyType;
 840 }
 841 impl ::core::cmp::PartialEq for DedupStreamEntry {
 842     fn eq(&self, other: &Self) -> bool {
 843         self.Hash == other.Hash && self.LogicalSize == other.LogicalSize && self.Offset == other.Offset
 844     }
 845 }
 846 impl ::core::cmp::Eq for DedupStreamEntry {}
 847 impl ::core::default::Default for DedupStreamEntry {
 848     fn default() -> Self {
 849         unsafe { ::core::mem::zeroed() }
 850     }
 851 }
 852 #[cfg(feature = "implement")]
 853 ::core::include!("impl.rs");