From 93c2a7afa5bb97a51a23baaa7e9457fdef935222 Mon Sep 17 00:00:00 2001 From: Ronbb Date: Sat, 12 Jul 2025 13:34:15 +0800 Subject: [PATCH 1/3] Spilit opc_da_binding and add more bindings --- Cargo.lock | 33 +- Cargo.toml | 19 +- opc_ae_bindings/.gitignore | 1 + opc_ae_bindings/.metadata/.gitignore | 2 + opc_ae_bindings/.metadata/generate.proj | 17 + opc_ae_bindings/.metadata/main.cpp | 3 + opc_ae_bindings/.metadata/opc_ae.idl | 506 +++ opc_ae_bindings/.windows/winmd/OPCAE.winmd | Bin 0 -> 9216 bytes opc_ae_bindings/Cargo.toml | 22 + opc_ae_bindings/README.md | 18 + opc_ae_bindings/build.rs | 19 + opc_ae_bindings/src/bindings.rs | 2321 ++++++++++ opc_ae_bindings/src/lib.rs | 3 + opc_comn_bindings/.gitignore | 1 + opc_comn_bindings/.metadata/.gitignore | 2 + opc_comn_bindings/.metadata/generate.proj | 17 + opc_comn_bindings/.metadata/main.cpp | 3 + .../.metadata/opccomn.idl | 0 .../.windows/winmd/OPCCOMN.winmd | Bin 0 -> 3584 bytes opc_comn_bindings/Cargo.toml | 22 + opc_comn_bindings/README.md | 18 + opc_comn_bindings/build.rs | 19 + opc_comn_bindings/src/bindings.rs | 781 ++++ opc_comn_bindings/src/lib.rs | 3 + opc_da/Cargo.toml | 5 +- opc_da/src/client/traits/client.rs | 2 +- opc_da/src/client/traits/common.rs | 2 +- opc_da/src/client/v2/mod.rs | 6 +- opc_da/src/client/v3/mod.rs | 6 +- opc_da/src/server/com/server.rs | 4 +- opc_da_bindings/.metadata/generate.proj | 4 +- opc_da_bindings/.metadata/main.cpp | 1 - opc_da_bindings/.windows/winmd/OPCDA.winmd | Bin 20992 -> 19456 bytes opc_da_bindings/Cargo.toml | 18 +- opc_da_bindings/src/bindings.rs | 771 ---- opc_hda_bindings/.gitignore | 1 + opc_hda_bindings/.metadata/.gitignore | 2 + opc_hda_bindings/.metadata/generate.proj | 17 + opc_hda_bindings/.metadata/main.cpp | 3 + opc_hda_bindings/.metadata/opchda.idl | 881 ++++ opc_hda_bindings/.windows/winmd/OPCHDA.winmd | Bin 0 -> 15360 bytes opc_hda_bindings/Cargo.toml | 22 + opc_hda_bindings/README.md | 18 + opc_hda_bindings/build.rs | 19 + opc_hda_bindings/src/bindings.rs | 3997 +++++++++++++++++ opc_hda_bindings/src/lib.rs | 3 + 46 files changed, 8811 insertions(+), 801 deletions(-) create mode 100644 opc_ae_bindings/.gitignore create mode 100644 opc_ae_bindings/.metadata/.gitignore create mode 100644 opc_ae_bindings/.metadata/generate.proj create mode 100644 opc_ae_bindings/.metadata/main.cpp create mode 100644 opc_ae_bindings/.metadata/opc_ae.idl create mode 100644 opc_ae_bindings/.windows/winmd/OPCAE.winmd create mode 100644 opc_ae_bindings/Cargo.toml create mode 100644 opc_ae_bindings/README.md create mode 100644 opc_ae_bindings/build.rs create mode 100644 opc_ae_bindings/src/bindings.rs create mode 100644 opc_ae_bindings/src/lib.rs create mode 100644 opc_comn_bindings/.gitignore create mode 100644 opc_comn_bindings/.metadata/.gitignore create mode 100644 opc_comn_bindings/.metadata/generate.proj create mode 100644 opc_comn_bindings/.metadata/main.cpp rename opc_da_bindings/.metadata/OPCComn.idl => opc_comn_bindings/.metadata/opccomn.idl (100%) create mode 100644 opc_comn_bindings/.windows/winmd/OPCCOMN.winmd create mode 100644 opc_comn_bindings/Cargo.toml create mode 100644 opc_comn_bindings/README.md create mode 100644 opc_comn_bindings/build.rs create mode 100644 opc_comn_bindings/src/bindings.rs create mode 100644 opc_comn_bindings/src/lib.rs create mode 100644 opc_hda_bindings/.gitignore create mode 100644 opc_hda_bindings/.metadata/.gitignore create mode 100644 opc_hda_bindings/.metadata/generate.proj create mode 100644 opc_hda_bindings/.metadata/main.cpp create mode 100644 opc_hda_bindings/.metadata/opchda.idl create mode 100644 opc_hda_bindings/.windows/winmd/OPCHDA.winmd create mode 100644 opc_hda_bindings/Cargo.toml create mode 100644 opc_hda_bindings/README.md create mode 100644 opc_hda_bindings/build.rs create mode 100644 opc_hda_bindings/src/bindings.rs create mode 100644 opc_hda_bindings/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index 7d9874e..314d1f4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -276,11 +276,32 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" [[package]] -name = "opc_da" +name = "opc_ae_bindings" +version = "0.3.0" +dependencies = [ + "windows", + "windows-bindgen", + "windows-core", + "windows-targets 0.53.2", +] + +[[package]] +name = "opc_comn_bindings" version = "0.3.0" +dependencies = [ + "windows", + "windows-bindgen", + "windows-core", + "windows-targets 0.53.2", +] + +[[package]] +name = "opc_da" +version = "0.3.1" dependencies = [ "actix", "globset", + "opc_comn_bindings", "opc_da_bindings", "tokio", "windows", @@ -289,6 +310,16 @@ dependencies = [ [[package]] name = "opc_da_bindings" +version = "0.3.1" +dependencies = [ + "windows", + "windows-bindgen", + "windows-core", + "windows-targets 0.53.2", +] + +[[package]] +name = "opc_hda_bindings" version = "0.3.0" dependencies = [ "windows", diff --git a/Cargo.toml b/Cargo.toml index c49dbb7..6aba39a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,23 @@ [workspace] resolver = "2" -members = ["opc_da_bindings", "opc_da"] +members = [ + "opc_ae_bindings", + "opc_comn_bindings", + "opc_da", + "opc_da_bindings", + "opc_hda_bindings", +] + +[workspace.dependencies] +windows = { version = "0.61.3", features = [ + "Win32_Foundation", + "Win32_System_Com", + "Win32_System_Ole", + "Win32_System_Variant", +] } +windows-bindgen = "0.62.1" +windows-core = "0.61.2" +windows-targets = "0.53.2" [profile.dev.build-override] debug = true diff --git a/opc_ae_bindings/.gitignore b/opc_ae_bindings/.gitignore new file mode 100644 index 0000000..ea8c4bf --- /dev/null +++ b/opc_ae_bindings/.gitignore @@ -0,0 +1 @@ +/target diff --git a/opc_ae_bindings/.metadata/.gitignore b/opc_ae_bindings/.metadata/.gitignore new file mode 100644 index 0000000..1746e32 --- /dev/null +++ b/opc_ae_bindings/.metadata/.gitignore @@ -0,0 +1,2 @@ +bin +obj diff --git a/opc_ae_bindings/.metadata/generate.proj b/opc_ae_bindings/.metadata/generate.proj new file mode 100644 index 0000000..e9f7917 --- /dev/null +++ b/opc_ae_bindings/.metadata/generate.proj @@ -0,0 +1,17 @@ + + + + ../.windows/winmd/OPCAE.winmd + 0.0.0.1 + $(CompiledHeadersDir) + + + + + + @(Headers) + OPCAE + true + + + \ No newline at end of file diff --git a/opc_ae_bindings/.metadata/main.cpp b/opc_ae_bindings/.metadata/main.cpp new file mode 100644 index 0000000..b3c8e1f --- /dev/null +++ b/opc_ae_bindings/.metadata/main.cpp @@ -0,0 +1,3 @@ +#include + +#include "opc_ae.h" diff --git a/opc_ae_bindings/.metadata/opc_ae.idl b/opc_ae_bindings/.metadata/opc_ae.idl new file mode 100644 index 0000000..d9a48ea --- /dev/null +++ b/opc_ae_bindings/.metadata/opc_ae.idl @@ -0,0 +1,506 @@ +//============================================================================== +// TITLE: opc_ae.idl +// +// CONTENTS: +// +// Interface declarations for the OPC Alarms & Event specifications. +// +// (c) Copyright 1997-2003 The OPC Foundation +// ALL RIGHTS RESERVED. +// +// DISCLAIMER: +// This code is provided by the OPC Foundation solely to assist in +// understanding and use of the appropriate OPC Specification(s) and may be +// used as set forth in the License Grant section of the OPC Specification. +// This code is provided as-is and without warranty or support of any sort +// and is subject to the Warranty and Liability Disclaimers which appear +// in the printed OPC Specification. +// +// MODIFICATION LOG: +// +// Date By Notes +// ---------- --- ----- +// 2002/10/02 JL Updated for Version 1.1. +// 2003/01/06 RSA Fixed formatting to comply with coding guidelines. +// 2004/09/01 RSA Renamed modules in TYPELIB section to avoid name conflicts. +// + +import "oaidl.idl"; +import "ocidl.idl"; + +//============================================================================== +// Category ID declaration (defined as an interface to ensure they show up in the typelib). + +[uuid(58E13251-AC87-11d1-84D5-00608CB8A7E9)] interface OPCEventServerCATID : IUnknown {} + +cpp_quote("#define CATID_OPCAEServer10 IID_OPCEventServerCATID") + +//============================================================================== +// Structures, Typedefs and Enumerations. + +typedef DWORD OPCHANDLE; + +typedef enum +{ + OPCAE_BROWSE_UP = 1, + OPCAE_BROWSE_DOWN, + OPCAE_BROWSE_TO +} +OPCAEBROWSEDIRECTION; + +typedef enum +{ + OPC_AREA = 1, + OPC_SOURCE +} +OPCAEBROWSETYPE; + +typedef enum +{ + OPCAE_STATUS_RUNNING = 1, + OPCAE_STATUS_FAILED, + OPCAE_STATUS_NOCONFIG, + OPCAE_STATUS_SUSPENDED, + OPCAE_STATUS_TEST, + OPCAE_STATUS_COMM_FAULT +} +OPCEVENTSERVERSTATE; + +typedef struct +{ + WORD wChangeMask; + WORD wNewState; + [string] LPWSTR szSource; + FILETIME ftTime; + [string] LPWSTR szMessage; + DWORD dwEventType; + DWORD dwEventCategory; + DWORD dwSeverity; + [string] LPWSTR szConditionName; + [string] LPWSTR szSubconditionName; + WORD wQuality; + WORD wReserved; + BOOL bAckRequired; + FILETIME ftActiveTime; + DWORD dwCookie; + DWORD dwNumEventAttrs; + [size_is(dwNumEventAttrs)] VARIANT* pEventAttributes; + [string] LPWSTR szActorID; +} +ONEVENTSTRUCT; + +typedef struct +{ + FILETIME ftStartTime; + FILETIME ftCurrentTime; + FILETIME ftLastUpdateTime; + OPCEVENTSERVERSTATE dwServerState; + WORD wMajorVersion; + WORD wMinorVersion; + WORD wBuildNumber; + WORD wReserved; + [string] LPWSTR szVendorInfo; +} +OPCEVENTSERVERSTATUS; + +typedef struct +{ + WORD wState; + WORD wReserved1; + LPWSTR szActiveSubCondition; + LPWSTR szASCDefinition; + DWORD dwASCSeverity; + LPWSTR szASCDescription; + WORD wQuality; + WORD wReserved2; + FILETIME ftLastAckTime; + FILETIME ftSubCondLastActive; + FILETIME ftCondLastActive; + FILETIME ftCondLastInactive; + LPWSTR szAcknowledgerID; + LPWSTR szComment; + DWORD dwNumSCs; + [size_is (dwNumSCs)] LPWSTR * pszSCNames; + [size_is (dwNumSCs)] LPWSTR * pszSCDefinitions; + [size_is (dwNumSCs)] DWORD * pdwSCSeverities; + [size_is (dwNumSCs)] LPWSTR * pszSCDescriptions; + DWORD dwNumEventAttrs; + [size_is(dwNumEventAttrs)] VARIANT* pEventAttributes; + [size_is(dwNumEventAttrs)] HRESULT* pErrors; +} +OPCCONDITIONSTATE; + +//============================================================================== +// IOPCEventServer + +[ + uuid(65168851-5783-11D1-84A0-00608CB8A7E9), + pointer_default(unique) +] +interface IOPCEventServer : IUnknown +{ + HRESULT GetStatus( + [out] OPCEVENTSERVERSTATUS **ppEventServerStatus + ); + + HRESULT CreateEventSubscription( + [in] BOOL bActive, + [in] DWORD dwBufferTime, + [in] DWORD dwMaxSize, + [in] OPCHANDLE hClientSubscription, + [in] REFIID riid, + [out, iid_is(riid)] LPUNKNOWN* ppUnk, + [out] DWORD* pdwRevisedBufferTime, + [out] DWORD* pdwRevisedMaxSize + ); + + HRESULT QueryAvailableFilters( + [out] DWORD* pdwFilterMask + ); + + HRESULT QueryEventCategories( + [in] DWORD dwEventType, + [out] DWORD* pdwCount, + [out, size_is(,*pdwCount)] DWORD** ppdwEventCategories, + [out, size_is(,*pdwCount)] LPWSTR** ppszEventCategoryDescs + ); + + HRESULT QueryConditionNames( + [in] DWORD dwEventCategory, + [out] DWORD* pdwCount, + [out, size_is(,*pdwCount)] LPWSTR** ppszConditionNames + ); + + HRESULT QuerySubConditionNames( + [in] LPWSTR szConditionName, + [out] DWORD* pdwCount, + [out, size_is(,*pdwCount)] LPWSTR** ppszSubConditionNames + ); + + HRESULT QuerySourceConditions( + [in] LPWSTR szSource, + [out] DWORD* pdwCount, + [out, size_is(,*pdwCount)] LPWSTR** ppszConditionNames + ); + + HRESULT QueryEventAttributes( + [in] DWORD dwEventCategory, + [out] DWORD* pdwCount, + [out, size_is(,*pdwCount)] DWORD** ppdwAttrIDs, + [out, size_is(,*pdwCount)] LPWSTR** ppszAttrDescs, + [out, size_is(,*pdwCount)] VARTYPE** ppvtAttrTypes + ); + + HRESULT TranslateToItemIDs( + [in] LPWSTR szSource, + [in] DWORD dwEventCategory, + [in] LPWSTR szConditionName, + [in] LPWSTR szSubconditionName, + [in] DWORD dwCount, + [in, size_is(dwCount)] DWORD* pdwAssocAttrIDs, + [out, size_is(,dwCount)] LPWSTR** ppszAttrItemIDs, + [out, size_is(,dwCount)] LPWSTR** ppszNodeNames, + [out, size_is(,dwCount)] CLSID** ppCLSIDs + ); + + HRESULT GetConditionState ( + [in] LPWSTR szSource, + [in] LPWSTR szConditionName, + [in] DWORD dwNumEventAttrs, + [in, size_is(dwNumEventAttrs)] DWORD* pdwAttributeIDs, + [out] OPCCONDITIONSTATE** ppConditionState + ); + + HRESULT EnableConditionByArea( + [in] DWORD dwNumAreas, + [in, size_is(dwNumAreas)] LPWSTR* pszAreas + ); + + + HRESULT EnableConditionBySource( + [in] DWORD dwNumSources, + [in, size_is(dwNumSources)] LPWSTR* pszSources + ); + + HRESULT DisableConditionByArea( + [in] DWORD dwNumAreas, + [in, size_is(dwNumAreas)] LPWSTR* pszAreas + ); + + HRESULT DisableConditionBySource( + [in] DWORD dwNumSources, + [in, size_is(dwNumSources)] LPWSTR* pszSources + ); + + HRESULT AckCondition( + [in] DWORD dwCount, + [in, string] LPWSTR szAcknowledgerID, + [in, string] LPWSTR szComment, + [in, size_is(dwCount)] LPWSTR* pszSource, + [in, size_is(dwCount)] LPWSTR* pszConditionName, + [in, size_is(dwCount)] FILETIME* pftActiveTime, + [in, size_is(dwCount)] DWORD* pdwCookie, + [out, size_is(,dwCount)] HRESULT** ppErrors + ); + + HRESULT CreateAreaBrowser( + [in] REFIID riid, + [out, iid_is(riid)] LPUNKNOWN* ppUnk + ); +}; + +//============================================================================== +// IOPCEventSubscriptionMgt + +[ + uuid(65168855-5783-11D1-84A0-00608CB8A7E9), + pointer_default(unique) +] +interface IOPCEventSubscriptionMgt : IUnknown +{ + HRESULT SetFilter( + [in] DWORD dwEventType, + [in] DWORD dwNumCategories, + [in, size_is(dwNumCategories)] DWORD* pdwEventCategories, + [in] DWORD dwLowSeverity, + [in] DWORD dwHighSeverity, + [in] DWORD dwNumAreas, + [in, size_is(dwNumAreas)] LPWSTR* pszAreaList, + [in] DWORD dwNumSources, + [in, size_is(dwNumSources)] LPWSTR* pszSourceList + ); + + HRESULT GetFilter( + [out] DWORD* pdwEventType, + [out] DWORD* pdwNumCategories, + [out, size_is(,*pdwNumCategories)] DWORD** ppdwEventCategories, + [out] DWORD* pdwLowSeverity, + [out] DWORD* pdwHighSeverity, + [out] DWORD* pdwNumAreas, + [out, size_is(,*pdwNumAreas)] LPWSTR** ppszAreaList, + [out] DWORD* pdwNumSources, + [out, size_is(,*pdwNumSources)] LPWSTR** ppszSourceList + ); + + HRESULT SelectReturnedAttributes( + [in] DWORD dwEventCategory, + [in] DWORD dwCount, + [in, size_is(dwCount)] DWORD* dwAttributeIDs + ); + + HRESULT GetReturnedAttributes( + [in] DWORD dwEventCategory, + [out] DWORD* pdwCount, + [out, size_is(,*pdwCount)] DWORD** ppdwAttributeIDs + ); + + + HRESULT Refresh( + [in] DWORD dwConnection + ); + + HRESULT CancelRefresh( + [in] DWORD dwConnection + ); + + HRESULT GetState( + [out] BOOL* pbActive, + [out] DWORD* pdwBufferTime, + [out] DWORD* pdwMaxSize, + [out] OPCHANDLE* phClientSubscription + ); + + HRESULT SetState( + [unique, in] BOOL* pbActive, + [unique, in] DWORD* pdwBufferTime, + [unique, in] DWORD* pdwMaxSize, + [in] OPCHANDLE hClientSubscription, + [out] DWORD* pdwRevisedBufferTime, + [out] DWORD* pdwRevisedMaxSize + ); +}; + +//============================================================================== +// IOPCEventAreaBrowser + +[ + uuid(65168857-5783-11D1-84A0-00608CB8A7E9), + pointer_default(unique) +] +interface IOPCEventAreaBrowser : IUnknown +{ + HRESULT ChangeBrowsePosition( + [in] OPCAEBROWSEDIRECTION dwBrowseDirection, + [in, string] LPCWSTR szString + ); + + HRESULT BrowseOPCAreas( + [in] OPCAEBROWSETYPE dwBrowseFilterType, + [in, string] LPCWSTR szFilterCriteria, + [out] LPENUMSTRING* ppIEnumString + ); + + HRESULT GetQualifiedAreaName( + [in] LPCWSTR szAreaName, + [out, string] LPWSTR* pszQualifiedAreaName + ); + + HRESULT GetQualifiedSourceName( + [in] LPCWSTR szSourceName, + [out, string] LPWSTR* pszQualifiedSourceName + ); +}; + +//============================================================================== +// IOPCEventSink + +[ + uuid(6516885F-5783-11D1-84A0-00608CB8A7E9), + pointer_default(unique) +] +interface IOPCEventSink : IUnknown +{ + HRESULT OnEvent( + [in] OPCHANDLE hClientSubscription, + [in] BOOL bRefresh, + [in] BOOL bLastRefresh, + [in] DWORD dwCount, + [in, size_is(dwCount)] ONEVENTSTRUCT* pEvents + ); +}; + +//============================================================================== +// IOPCEventServer2 + +[ + uuid(71BBE88E-9564-4bcd-BCFC-71C558D94F2D), + pointer_default(unique) +] +interface IOPCEventServer2 : IOPCEventServer +{ + HRESULT EnableConditionByArea2( + [in] DWORD dwNumAreas, + [in, string, size_is(dwNumAreas)] LPWSTR* pszAreas, + [out, size_is(,dwNumAreas)] HRESULT** ppErrors + ); + + HRESULT EnableConditionBySource2( + [in] DWORD dwNumSources, + [in, string, size_is(dwNumSources)] LPWSTR* pszSources, + [out, size_is(,dwNumSources)] HRESULT** ppErrors + ); + + HRESULT DisableConditionByArea2( + [in] DWORD dwNumAreas, + [in, string, size_is(dwNumAreas)] LPWSTR* pszAreas, + [out, size_is(,dwNumAreas)] HRESULT** ppErrors + ); + + HRESULT DisableConditionBySource2( + [in] DWORD dwNumSources, + [in, string, size_is(dwNumSources)] LPWSTR* pszSources, + [out, size_is(,dwNumSources)] HRESULT** ppErrors + ); + + HRESULT GetEnableStateByArea( + [in] DWORD dwNumAreas, + [in, string, size_is(dwNumAreas)] LPWSTR* pszAreas, + [out, size_is(,dwNumAreas)] BOOL** pbEnabled, + [out, size_is(,dwNumAreas)] BOOL** pbEffectivelyEnabled, + [out, size_is(,dwNumAreas)] HRESULT** ppErrors + ); + + HRESULT GetEnableStateBySource( + [in] DWORD dwNumSources, + [in, string, size_is(dwNumSources)] LPWSTR* pszSources, + [out, size_is(,dwNumSources)] BOOL** pbEnabled, + [out, size_is(,dwNumSources)] BOOL** pbEffectivelyEnabled, + [out, size_is(,dwNumSources)] HRESULT** ppErrors + ); +}; + +//============================================================================== +// IOPCEventSubscriptionMgt2 + +[ + uuid(94C955DC-3684-4ccb-AFAB-F898CE19AAC3), + pointer_default(unique) +] +interface IOPCEventSubscriptionMgt2 : IOPCEventSubscriptionMgt +{ + HRESULT SetKeepAlive( + [in] DWORD dwKeepAliveTime, + [out] DWORD* pdwRevisedKeepAliveTime + ); + + HRESULT GetKeepAlive( + [out] DWORD* pdwKeepAliveTime + ); +}; + +//============================================================================== +// Type Library + +[ + uuid(65168844-5783-11D1-84A0-00608CB8A7E9), + version(1.10), + helpstring("OPC Alarms & Events 1.10 Type Library") +] +library OPC_AE +{ + importlib("stdole32.tlb"); + importlib("stdole2.tlb"); + + //========================================================================== + // Category IDs + + interface OPCEventServerCATID; + + //========================================================================== + // Constants + + module OPCAE_Constants + { + // category description string. + const LPCWSTR OPC_CATEGORY_DESCRIPTION_AE10 = L"OPC Alarm & Event Server Version 1.0"; + + // state bit masks. + const DWORD OPC_CONDITION_ENABLED = 0x0001; + const DWORD OPC_CONDITION_ACTIVE = 0x0002; + const DWORD OPC_CONDITION_ACKED = 0x0004; + + // bit masks for change mask. + const DWORD OPC_CHANGE_ACTIVE_STATE = 0x0001; + const DWORD OPC_CHANGE_ACK_STATE = 0x0002; + const DWORD OPC_CHANGE_ENABLE_STATE = 0x0004; + const DWORD OPC_CHANGE_QUALITY = 0x0008; + const DWORD OPC_CHANGE_SEVERITY = 0x0010; + const DWORD OPC_CHANGE_SUBCONDITION = 0x0020; + const DWORD OPC_CHANGE_MESSAGE = 0x0040; + const DWORD OPC_CHANGE_ATTRIBUTE = 0x0080; + + // event type. + const DWORD OPC_SIMPLE_EVENT = 0x0001; + const DWORD OPC_TRACKING_EVENT = 0x0002; + const DWORD OPC_CONDITION_EVENT = 0x0004; + const DWORD OPC_ALL_EVENTS = 0x0007; + + // bit masks for QueryAvailableFilters(). + const DWORD OPC_FILTER_BY_EVENT = 0x0001; + const DWORD OPC_FILTER_BY_CATEGORY = 0x0002; + const DWORD OPC_FILTER_BY_SEVERITY = 0x0004; + const DWORD OPC_FILTER_BY_AREA = 0x0008; + const DWORD OPC_FILTER_BY_SOURCE = 0x0010; + } + + //========================================================================== + // Synchronous Interfaces + + interface IOPCEventServer; + interface IOPCEventSubscriptionMgt; + interface IOPCEventAreaBrowser; + interface IOPCEventSink; + interface OPCEventServerCATID; + interface IOPCEventServer2; + interface IOPCEventSubscriptionMgt2; +}; diff --git a/opc_ae_bindings/.windows/winmd/OPCAE.winmd b/opc_ae_bindings/.windows/winmd/OPCAE.winmd new file mode 100644 index 0000000000000000000000000000000000000000..b68ac83ef034a4f5162d78078e66f0a838259d53 GIT binary patch literal 9216 zcmeHNeQaCTbwBU%^GTFx+HPhiQB6m7kZiFc*|FzjUL%U6W!97^iIf!ALm5hZvR_P* z^dl)+Y7yA8mVE_Xy0~4iw8gR+sQUqAZCo^KvMxXr2V3WUVeQb(UADnkngwVEw7`OT zh4(w>Jw85JQs7~K3AB@YahTT>jStMqWC}?`^{JDlOBa)kMYpJ zZxL;jf9+3Ou9SXltzpl5<6g z9_=;tQf0>WVE|3Mw!3h+!+_bp-gQj(pdSKvX^eNeBS~!j5~*W7w#|O4&dfG ziQ?vE^BOT8*O1Rzub=)-Dgy(xfKb=<@ ze^um{Jbx7Gpr829gLwf=2le`R)CIBgalz9-KkW{({r}L|+T$U%-wd6XLiw_|z_EJ{ z9^I!Nd$#L{YGpCYI=g*0U&Jp^qxR&Ht2qV2G?-xKYZq45mt1JQu3 zu`jGer0sRPZJTJNpw-qb+MAf2d%j<^cWrGaomDo`wa#Pe7~1Y8zklA_OOt2jJ^jF( z;4HAkzoaC<7u1Bq+~qk8W~<5=68Y~Hmcw4gXTkVsF?bC4Xn^se@58|F`lo?k5;+o> zh5UAi@vbh${eJFqNbq`yM{V~pZt@wx^D_2jANP#OsIPaU=Q*+b{Q$4x-vzG=4u}tzLTuCD z!5(huG=Vn+y`4?S8$-;vJ%2Ft5yVQNyFHUIVz?#`?9OOEyyv^yN_Tb*xVUs%^=-@P5zWuLQt+1DGmU%B6D zd)oVmvd_`xeUB&y9PM*x`!z@V7~1Ruk^R&bm6+4^742!|gO2uZ+6&6Cqg~bBRi+&6 z4?4G~1xLHs*{$l1_Tk_?s^Mrypq+HIkwC9H=V()bgR1Fh4{Ouvf}@@2IH`Wr(O&a4 z)iaLvGic`=?dzdWs!urDB7IkV($OwKd&<#14(+_7U4izDqdo3@L;aMa<$Z6cf9hzj z1T@b@M|&ag9DTvoR8+uGobi0|N%qZvg7fw@zk*uW5may%PiP9xv3q?g`Dr$&;)H(Q zui`A*ASWW9&I&zY%WNSMP{Caesj%>m9V#sRaYx(!+u&QR<<2(0A2wTj!o^?2ye;0{ z-)-kNWR@p^K03Q%EU)G55U*uFR^+8aKp(vh#!qSV570qikhXWKcshk$eqQwPSRUoU z?&Y!D#C|tFpm6a@Pj_&ibFNWe7Ur*9%&qice^eS!d9F(`*Jm-ikM?19KRpc$&`XFz zkPf&q#TikNk+we($=x^LgNLpHz0}*qb~Xe3;%$Jw4f{c2KQ;QHZH+UyQL^?oSYs<| zySq4^n}B|5O02$x+y&`NkTtsM@`NL-N>n{`yKC+49Bp;+KX&=tlG%qV;=?j3!9!70 znwN6&%3wwNimYx~G7_~blRe~W^gGqadAW{Ol^%4>@^g$*=@lPaEeC-(C zBXt<@w;8T~l?GwcLq}y^&X_I?p*8jIVY=o z%w8SG{5Qe)kWU|V;O@j7!retFocF_c)1ZzHItBbR;ba4z6%3*d_TdiEL%@ynFmS6d zcM7vp1JeJ1^gpQlKKKFQ6T%-BJ}q`eVJD82Zo}N0;b)K1NuN=6 zDtADRLmpOVfM?Znz`s=g4ER&^Rba%kQ|+OzQbKUql0D2U3nsiQ7X_Cr+1Eq2DNBME z1eXPi{vLW*xdtpKi2&mTL2poG!DYc~f?kdJoq|P;eO}VoTW<%?xCFecECb(A5}o1? z@Ur3!F|!2xDtWuaw=j=g7Tmc}>CQXX80nR;OlC5+mdyfecZBeRu;Iis&Nw$+ltGL!Rqxt?V&%{|m68q>8I)2Ol! z!^i7;Zqfg}x7hE2TkN;*7W?g|gTs|#qojX;ICHV_WK4uZsdO$mo*z8wP_bk_n~UWp zvia;pb~HJXNG7CbJTsC=Ss9KWS;ZwsVuNXmZ5ucgOWB+&hA0~Rby{1D&73S(nkBt> zTsLi^USSFT#gZ~*HZw6Ex5T!eE;4>NHZqjV4=1zP*ie$tCz(qPTLbJi%P(2c3O*Lk zr6#SF-ozhSqjN4do*JCU**#r>U?Y~pt)Pu$5U4|`p_T0T#K=f$WQYbcnY1j;b}u_I z=)~0?F*u%?$|m!P%+$zACYM>MPmI#&R5mv*_G0ODJ~^2j$z|H8J0~AkEWB>NFj3LvG@^q>Y^M6U0gdIGU>`WbIGh_z1^#IQpggD=UhPj9WqLF-He+C z&?wN9Q7%@RwO)Mg-P3!h(kK@TytjLY^?CtffvVHioJE#qXZ4x7F|U^vTI4hedR#x% zFigGJKG(=Jj3Ny+04rx`8s)j76}MhXF6;GLy?|*=47h25)_Jsgi8jCb@Ut7LwMAR1 zEe`9oTH&}()nYSVshl))o@K02C>gVcUgT4Bq%eo(+Tv;w+qKp19%R{GHOxh~=5O_J z&TS#k+L)ec9pysJ*3*SreWHqx>p6q{DdGs9H)?wEh^|*-B?P_2-$cyTW0DhTw(KA$ zt8>Wd9-_}rJrX^2u@#Pk(Iu)CPCTc~uN=PVpDQBFeRGno? zfpVa4Vv0@ciQ=?dLRPO^LUTlK+HI(vSRLQ^O*iT~ji4y!^_XcE7ENqwUb;MRt`kV zF4XG!+)ew;B6|@Y?4HIPHHQn2Rm@4*KcXi!*e!6+v zqVolSBWjP-+Sam zhRkzn5EO#DPhgX2q;orQ^7P29c#h`+b{Fz=kZsmNL_iVV&)=b#E2Cg|EH$CkuGM zm+ROVI0fdg!6;Lf*{nxl0|e)biz#i?EX8_+iMp~H7N{wY$NB=6fK6@Ze}QcsHjbZg zbUxvwG^8nAX{-GA)c5`U&oAAWKJuA=%D$LA|M)Tm|MnxBZ(P~^!?6wcEl&#seD<|P zp|L&x^2l$0@jH>F@6n@AzWCX<@I9YD=T??i zhXc1qHEz}--2kf-o5sCw9rIoavz7LM=sF$o9a&W6>DKj>Xe%#RCg(}{-wtu2zk`Qb zLEt3(&Taa+DJ0=fT1nW%ej`i>6;JRUllW*I{{nOe8^L@MQ2vmxS{RfVg6eRBsrfh! zS{G*_9N8uPwT)4~qlpQ)JF&`LiA1C;(k-cpybmkgl+<{QvTTf*S~aFik`>v7dI(3h zuCoXaVQhZYSjjpE1&Qq6Vr5;FT_E`G$FPt6=%rJ|Ph2_j@_(Ir?U5g3cH>7!D`6TM zuTK2+`KA5eNI(CDcc1y@w$H!HrM%&AhDIq)QHoKC3S`n8^k}0|g zZBn!v8B{@gl=`Wc`pC=QJ$m`~Qg4)DfZ+^-{k1a0|GVp{*3T+%;qxp<*Y>6Ld$iS> zk5|k@sWedqz C<`(<_ literal 0 HcmV?d00001 diff --git a/opc_ae_bindings/Cargo.toml b/opc_ae_bindings/Cargo.toml new file mode 100644 index 0000000..fa473f9 --- /dev/null +++ b/opc_ae_bindings/Cargo.toml @@ -0,0 +1,22 @@ +[package] +name = "opc_ae_bindings" +version = "0.3.0" +edition = "2024" +description = "OPC Historical Data Access bindings" +readme = "README.md" +repository = "https://github.com/Ronbb/rust_opc" +license = "MIT" +keywords = ["ae", "bindings", "opc", "opcae"] +exclude = [".metadata/*", ".windows/*", "build.rs"] + +[package.metadata.docs.rs] +default-target = "x86_64-pc-windows-msvc" +targets = [] + +[dependencies] +windows = { workspace = true } +windows-core = { workspace = true } +windows-targets = { workspace = true } + +[build-dependencies] +windows-bindgen = { workspace = true } diff --git a/opc_ae_bindings/README.md b/opc_ae_bindings/README.md new file mode 100644 index 0000000..f90a317 --- /dev/null +++ b/opc_ae_bindings/README.md @@ -0,0 +1,18 @@ +# OPC AE Bindings + +Please see docs on [docs.rs](https://docs.rs/opc_ae_bindings/). + +## Example + +```rust +// TODO +``` + +## Rebuild metadata + +Open **Developer Powershell for VS2022**. + +```batch +cd .metadata +dotnet build +``` diff --git a/opc_ae_bindings/build.rs b/opc_ae_bindings/build.rs new file mode 100644 index 0000000..19d638c --- /dev/null +++ b/opc_ae_bindings/build.rs @@ -0,0 +1,19 @@ +fn main() { + println!("cargo:rerun-if-changed=build.rs"); + println!("cargo:rerun-if-changed=.windows/winmd/OPCAE.winmd"); + + windows_bindgen::bindgen([ + "--in", + ".windows/winmd/OPCAE.winmd", + "default", + "--out", + "src/bindings.rs", + "--reference", + "windows,skip-root,Windows", + "--filter", + "OPCAE", + "--flat", + "--implement", + ]) + .unwrap(); +} diff --git a/opc_ae_bindings/src/bindings.rs b/opc_ae_bindings/src/bindings.rs new file mode 100644 index 0000000..af9123e --- /dev/null +++ b/opc_ae_bindings/src/bindings.rs @@ -0,0 +1,2321 @@ +// Bindings generated by `windows-bindgen` 0.62.1 + +#![allow( + non_snake_case, + non_upper_case_globals, + non_camel_case_types, + dead_code, + clippy::all +)] + +windows_core::imp::define_interface!( + IOPCEventAreaBrowser, + IOPCEventAreaBrowser_Vtbl, + 0x65168857_5783_11d1_84a0_00608cb8a7e9 +); +windows_core::imp::interface_hierarchy!(IOPCEventAreaBrowser, windows_core::IUnknown); +impl IOPCEventAreaBrowser { + pub unsafe fn ChangeBrowsePosition( + &self, + dwbrowsedirection: __MIDL___MIDL_itf_opc_ae_0000_0001_0001, + szstring: P1, + ) -> windows_core::Result<()> + where + P1: windows_core::Param, + { + unsafe { + (windows_core::Interface::vtable(self).ChangeBrowsePosition)( + windows_core::Interface::as_raw(self), + dwbrowsedirection, + szstring.param().abi(), + ) + .ok() + } + } + pub unsafe fn BrowseOPCAreas( + &self, + dwbrowsefiltertype: __MIDL___MIDL_itf_opc_ae_0000_0001_0002, + szfiltercriteria: P1, + ) -> windows_core::Result + where + P1: windows_core::Param, + { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).BrowseOPCAreas)( + windows_core::Interface::as_raw(self), + dwbrowsefiltertype, + szfiltercriteria.param().abi(), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub unsafe fn GetQualifiedAreaName( + &self, + szareaname: P0, + ) -> windows_core::Result + where + P0: windows_core::Param, + { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).GetQualifiedAreaName)( + windows_core::Interface::as_raw(self), + szareaname.param().abi(), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn GetQualifiedSourceName( + &self, + szsourcename: P0, + ) -> windows_core::Result + where + P0: windows_core::Param, + { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).GetQualifiedSourceName)( + windows_core::Interface::as_raw(self), + szsourcename.param().abi(), + &mut result__, + ) + .map(|| result__) + } + } +} +#[repr(C)] +#[doc(hidden)] +pub struct IOPCEventAreaBrowser_Vtbl { + pub base__: windows_core::IUnknown_Vtbl, + pub ChangeBrowsePosition: unsafe extern "system" fn( + *mut core::ffi::c_void, + __MIDL___MIDL_itf_opc_ae_0000_0001_0001, + windows_core::PCWSTR, + ) -> windows_core::HRESULT, + pub BrowseOPCAreas: unsafe extern "system" fn( + *mut core::ffi::c_void, + __MIDL___MIDL_itf_opc_ae_0000_0001_0002, + windows_core::PCWSTR, + *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT, + pub GetQualifiedAreaName: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows_core::PCWSTR, + *mut windows_core::PWSTR, + ) -> windows_core::HRESULT, + pub GetQualifiedSourceName: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows_core::PCWSTR, + *mut windows_core::PWSTR, + ) -> windows_core::HRESULT, +} +pub trait IOPCEventAreaBrowser_Impl: windows_core::IUnknownImpl { + fn ChangeBrowsePosition( + &self, + dwbrowsedirection: __MIDL___MIDL_itf_opc_ae_0000_0001_0001, + szstring: &windows_core::PCWSTR, + ) -> windows_core::Result<()>; + fn BrowseOPCAreas( + &self, + dwbrowsefiltertype: __MIDL___MIDL_itf_opc_ae_0000_0001_0002, + szfiltercriteria: &windows_core::PCWSTR, + ) -> windows_core::Result; + fn GetQualifiedAreaName( + &self, + szareaname: &windows_core::PCWSTR, + ) -> windows_core::Result; + fn GetQualifiedSourceName( + &self, + szsourcename: &windows_core::PCWSTR, + ) -> windows_core::Result; +} +impl IOPCEventAreaBrowser_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn ChangeBrowsePosition< + Identity: IOPCEventAreaBrowser_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwbrowsedirection: __MIDL___MIDL_itf_opc_ae_0000_0001_0001, + szstring: windows_core::PCWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventAreaBrowser_Impl::ChangeBrowsePosition( + this, + core::mem::transmute_copy(&dwbrowsedirection), + core::mem::transmute(&szstring), + ) + .into() + } + } + unsafe extern "system" fn BrowseOPCAreas< + Identity: IOPCEventAreaBrowser_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwbrowsefiltertype: __MIDL___MIDL_itf_opc_ae_0000_0001_0002, + szfiltercriteria: windows_core::PCWSTR, + ppienumstring: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCEventAreaBrowser_Impl::BrowseOPCAreas( + this, + core::mem::transmute_copy(&dwbrowsefiltertype), + core::mem::transmute(&szfiltercriteria), + ) { + Ok(ok__) => { + ppienumstring.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn GetQualifiedAreaName< + Identity: IOPCEventAreaBrowser_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + szareaname: windows_core::PCWSTR, + pszqualifiedareaname: *mut windows_core::PWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCEventAreaBrowser_Impl::GetQualifiedAreaName( + this, + core::mem::transmute(&szareaname), + ) { + Ok(ok__) => { + pszqualifiedareaname.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn GetQualifiedSourceName< + Identity: IOPCEventAreaBrowser_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + szsourcename: windows_core::PCWSTR, + pszqualifiedsourcename: *mut windows_core::PWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCEventAreaBrowser_Impl::GetQualifiedSourceName( + this, + core::mem::transmute(&szsourcename), + ) { + Ok(ok__) => { + pszqualifiedsourcename.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + Self { + base__: windows_core::IUnknown_Vtbl::new::(), + ChangeBrowsePosition: ChangeBrowsePosition::, + BrowseOPCAreas: BrowseOPCAreas::, + GetQualifiedAreaName: GetQualifiedAreaName::, + GetQualifiedSourceName: GetQualifiedSourceName::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +impl windows_core::RuntimeName for IOPCEventAreaBrowser {} +windows_core::imp::define_interface!( + IOPCEventServer, + IOPCEventServer_Vtbl, + 0x65168851_5783_11d1_84a0_00608cb8a7e9 +); +windows_core::imp::interface_hierarchy!(IOPCEventServer, windows_core::IUnknown); +impl IOPCEventServer { + pub unsafe fn GetStatus( + &self, + ) -> windows_core::Result<*mut __MIDL___MIDL_itf_opc_ae_0000_0001_0005> { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).GetStatus)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn CreateEventSubscription( + &self, + bactive: bool, + dwbuffertime: u32, + dwmaxsize: u32, + hclientsubscription: u32, + riid: *const windows_core::GUID, + ppunk: *mut Option, + pdwrevisedbuffertime: *mut u32, + pdwrevisedmaxsize: *mut u32, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).CreateEventSubscription)( + windows_core::Interface::as_raw(self), + bactive.into(), + dwbuffertime, + dwmaxsize, + hclientsubscription, + riid, + core::mem::transmute(ppunk), + pdwrevisedbuffertime as _, + pdwrevisedmaxsize as _, + ) + .ok() + } + } + pub unsafe fn QueryAvailableFilters(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).QueryAvailableFilters)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn QueryEventCategories( + &self, + dweventtype: u32, + pdwcount: *mut u32, + ppdweventcategories: *mut *mut u32, + ppszeventcategorydescs: *mut *mut windows_core::PWSTR, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).QueryEventCategories)( + windows_core::Interface::as_raw(self), + dweventtype, + pdwcount as _, + ppdweventcategories as _, + ppszeventcategorydescs as _, + ) + .ok() + } + } + pub unsafe fn QueryConditionNames( + &self, + dweventcategory: u32, + pdwcount: *mut u32, + ppszconditionnames: *mut *mut windows_core::PWSTR, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).QueryConditionNames)( + windows_core::Interface::as_raw(self), + dweventcategory, + pdwcount as _, + ppszconditionnames as _, + ) + .ok() + } + } + pub unsafe fn QuerySubConditionNames( + &self, + szconditionname: P0, + pdwcount: *mut u32, + ppszsubconditionnames: *mut *mut windows_core::PWSTR, + ) -> windows_core::Result<()> + where + P0: windows_core::Param, + { + unsafe { + (windows_core::Interface::vtable(self).QuerySubConditionNames)( + windows_core::Interface::as_raw(self), + szconditionname.param().abi(), + pdwcount as _, + ppszsubconditionnames as _, + ) + .ok() + } + } + pub unsafe fn QuerySourceConditions( + &self, + szsource: P0, + pdwcount: *mut u32, + ppszconditionnames: *mut *mut windows_core::PWSTR, + ) -> windows_core::Result<()> + where + P0: windows_core::Param, + { + unsafe { + (windows_core::Interface::vtable(self).QuerySourceConditions)( + windows_core::Interface::as_raw(self), + szsource.param().abi(), + pdwcount as _, + ppszconditionnames as _, + ) + .ok() + } + } + pub unsafe fn QueryEventAttributes( + &self, + dweventcategory: u32, + pdwcount: *mut u32, + ppdwattrids: *mut *mut u32, + ppszattrdescs: *mut *mut windows_core::PWSTR, + ppvtattrtypes: *mut *mut u16, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).QueryEventAttributes)( + windows_core::Interface::as_raw(self), + dweventcategory, + pdwcount as _, + ppdwattrids as _, + ppszattrdescs as _, + ppvtattrtypes as _, + ) + .ok() + } + } + pub unsafe fn TranslateToItemIDs( + &self, + szsource: P0, + dweventcategory: u32, + szconditionname: P2, + szsubconditionname: P3, + dwcount: u32, + pdwassocattrids: *const u32, + ppszattritemids: *mut *mut windows_core::PWSTR, + ppsznodenames: *mut *mut windows_core::PWSTR, + ppclsids: *mut *mut windows_core::GUID, + ) -> windows_core::Result<()> + where + P0: windows_core::Param, + P2: windows_core::Param, + P3: windows_core::Param, + { + unsafe { + (windows_core::Interface::vtable(self).TranslateToItemIDs)( + windows_core::Interface::as_raw(self), + szsource.param().abi(), + dweventcategory, + szconditionname.param().abi(), + szsubconditionname.param().abi(), + dwcount, + pdwassocattrids, + ppszattritemids as _, + ppsznodenames as _, + ppclsids as _, + ) + .ok() + } + } + pub unsafe fn GetConditionState( + &self, + szsource: P0, + szconditionname: P1, + pdwattributeids: &[u32], + ) -> windows_core::Result<*mut __MIDL___MIDL_itf_opc_ae_0000_0001_0006> + where + P0: windows_core::Param, + P1: windows_core::Param, + { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).GetConditionState)( + windows_core::Interface::as_raw(self), + szsource.param().abi(), + szconditionname.param().abi(), + pdwattributeids.len().try_into().unwrap(), + core::mem::transmute(pdwattributeids.as_ptr()), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn EnableConditionByArea( + &self, + pszareas: &[windows_core::PCWSTR], + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).EnableConditionByArea)( + windows_core::Interface::as_raw(self), + pszareas.len().try_into().unwrap(), + core::mem::transmute(pszareas.as_ptr()), + ) + .ok() + } + } + pub unsafe fn EnableConditionBySource( + &self, + pszsources: &[windows_core::PCWSTR], + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).EnableConditionBySource)( + windows_core::Interface::as_raw(self), + pszsources.len().try_into().unwrap(), + core::mem::transmute(pszsources.as_ptr()), + ) + .ok() + } + } + pub unsafe fn DisableConditionByArea( + &self, + pszareas: &[windows_core::PCWSTR], + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).DisableConditionByArea)( + windows_core::Interface::as_raw(self), + pszareas.len().try_into().unwrap(), + core::mem::transmute(pszareas.as_ptr()), + ) + .ok() + } + } + pub unsafe fn DisableConditionBySource( + &self, + pszsources: &[windows_core::PCWSTR], + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).DisableConditionBySource)( + windows_core::Interface::as_raw(self), + pszsources.len().try_into().unwrap(), + core::mem::transmute(pszsources.as_ptr()), + ) + .ok() + } + } + pub unsafe fn AckCondition( + &self, + dwcount: u32, + szacknowledgerid: P1, + szcomment: P2, + pszsource: *const windows_core::PCWSTR, + pszconditionname: *const windows_core::PCWSTR, + pftactivetime: *const windows::Win32::Foundation::FILETIME, + pdwcookie: *const u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> + where + P1: windows_core::Param, + P2: windows_core::Param, + { + unsafe { + (windows_core::Interface::vtable(self).AckCondition)( + windows_core::Interface::as_raw(self), + dwcount, + szacknowledgerid.param().abi(), + szcomment.param().abi(), + pszsource, + pszconditionname, + pftactivetime, + pdwcookie, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn CreateAreaBrowser( + &self, + riid: *const windows_core::GUID, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).CreateAreaBrowser)( + windows_core::Interface::as_raw(self), + riid, + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } +} +#[repr(C)] +#[doc(hidden)] +pub struct IOPCEventServer_Vtbl { + pub base__: windows_core::IUnknown_Vtbl, + pub GetStatus: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut *mut __MIDL___MIDL_itf_opc_ae_0000_0001_0005, + ) -> windows_core::HRESULT, + pub CreateEventSubscription: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows_core::BOOL, + u32, + u32, + u32, + *const windows_core::GUID, + *mut *mut core::ffi::c_void, + *mut u32, + *mut u32, + ) -> windows_core::HRESULT, + pub QueryAvailableFilters: + unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, + pub QueryEventCategories: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *mut u32, + *mut *mut u32, + *mut *mut windows_core::PWSTR, + ) -> windows_core::HRESULT, + pub QueryConditionNames: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *mut u32, + *mut *mut windows_core::PWSTR, + ) -> windows_core::HRESULT, + pub QuerySubConditionNames: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows_core::PCWSTR, + *mut u32, + *mut *mut windows_core::PWSTR, + ) -> windows_core::HRESULT, + pub QuerySourceConditions: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows_core::PCWSTR, + *mut u32, + *mut *mut windows_core::PWSTR, + ) -> windows_core::HRESULT, + pub QueryEventAttributes: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *mut u32, + *mut *mut u32, + *mut *mut windows_core::PWSTR, + *mut *mut u16, + ) -> windows_core::HRESULT, + pub TranslateToItemIDs: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows_core::PCWSTR, + u32, + windows_core::PCWSTR, + windows_core::PCWSTR, + u32, + *const u32, + *mut *mut windows_core::PWSTR, + *mut *mut windows_core::PWSTR, + *mut *mut windows_core::GUID, + ) -> windows_core::HRESULT, + pub GetConditionState: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows_core::PCWSTR, + windows_core::PCWSTR, + u32, + *const u32, + *mut *mut __MIDL___MIDL_itf_opc_ae_0000_0001_0006, + ) -> windows_core::HRESULT, + pub EnableConditionByArea: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const windows_core::PCWSTR, + ) -> windows_core::HRESULT, + pub EnableConditionBySource: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const windows_core::PCWSTR, + ) -> windows_core::HRESULT, + pub DisableConditionByArea: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const windows_core::PCWSTR, + ) -> windows_core::HRESULT, + pub DisableConditionBySource: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const windows_core::PCWSTR, + ) -> windows_core::HRESULT, + pub AckCondition: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + windows_core::PCWSTR, + windows_core::PCWSTR, + *const windows_core::PCWSTR, + *const windows_core::PCWSTR, + *const windows::Win32::Foundation::FILETIME, + *const u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub CreateAreaBrowser: unsafe extern "system" fn( + *mut core::ffi::c_void, + *const windows_core::GUID, + *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT, +} +pub trait IOPCEventServer_Impl: windows_core::IUnknownImpl { + fn GetStatus(&self) -> windows_core::Result<*mut __MIDL___MIDL_itf_opc_ae_0000_0001_0005>; + fn CreateEventSubscription( + &self, + bactive: windows_core::BOOL, + dwbuffertime: u32, + dwmaxsize: u32, + hclientsubscription: u32, + riid: *const windows_core::GUID, + ppunk: windows_core::OutRef<'_, windows_core::IUnknown>, + pdwrevisedbuffertime: *mut u32, + pdwrevisedmaxsize: *mut u32, + ) -> windows_core::Result<()>; + fn QueryAvailableFilters(&self) -> windows_core::Result; + fn QueryEventCategories( + &self, + dweventtype: u32, + pdwcount: *mut u32, + ppdweventcategories: *mut *mut u32, + ppszeventcategorydescs: *mut *mut windows_core::PWSTR, + ) -> windows_core::Result<()>; + fn QueryConditionNames( + &self, + dweventcategory: u32, + pdwcount: *mut u32, + ppszconditionnames: *mut *mut windows_core::PWSTR, + ) -> windows_core::Result<()>; + fn QuerySubConditionNames( + &self, + szconditionname: &windows_core::PCWSTR, + pdwcount: *mut u32, + ppszsubconditionnames: *mut *mut windows_core::PWSTR, + ) -> windows_core::Result<()>; + fn QuerySourceConditions( + &self, + szsource: &windows_core::PCWSTR, + pdwcount: *mut u32, + ppszconditionnames: *mut *mut windows_core::PWSTR, + ) -> windows_core::Result<()>; + fn QueryEventAttributes( + &self, + dweventcategory: u32, + pdwcount: *mut u32, + ppdwattrids: *mut *mut u32, + ppszattrdescs: *mut *mut windows_core::PWSTR, + ppvtattrtypes: *mut *mut u16, + ) -> windows_core::Result<()>; + fn TranslateToItemIDs( + &self, + szsource: &windows_core::PCWSTR, + dweventcategory: u32, + szconditionname: &windows_core::PCWSTR, + szsubconditionname: &windows_core::PCWSTR, + dwcount: u32, + pdwassocattrids: *const u32, + ppszattritemids: *mut *mut windows_core::PWSTR, + ppsznodenames: *mut *mut windows_core::PWSTR, + ppclsids: *mut *mut windows_core::GUID, + ) -> windows_core::Result<()>; + fn GetConditionState( + &self, + szsource: &windows_core::PCWSTR, + szconditionname: &windows_core::PCWSTR, + dwnumeventattrs: u32, + pdwattributeids: *const u32, + ) -> windows_core::Result<*mut __MIDL___MIDL_itf_opc_ae_0000_0001_0006>; + fn EnableConditionByArea( + &self, + dwnumareas: u32, + pszareas: *const windows_core::PCWSTR, + ) -> windows_core::Result<()>; + fn EnableConditionBySource( + &self, + dwnumsources: u32, + pszsources: *const windows_core::PCWSTR, + ) -> windows_core::Result<()>; + fn DisableConditionByArea( + &self, + dwnumareas: u32, + pszareas: *const windows_core::PCWSTR, + ) -> windows_core::Result<()>; + fn DisableConditionBySource( + &self, + dwnumsources: u32, + pszsources: *const windows_core::PCWSTR, + ) -> windows_core::Result<()>; + fn AckCondition( + &self, + dwcount: u32, + szacknowledgerid: &windows_core::PCWSTR, + szcomment: &windows_core::PCWSTR, + pszsource: *const windows_core::PCWSTR, + pszconditionname: *const windows_core::PCWSTR, + pftactivetime: *const windows::Win32::Foundation::FILETIME, + pdwcookie: *const u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn CreateAreaBrowser( + &self, + riid: *const windows_core::GUID, + ) -> windows_core::Result; +} +impl IOPCEventServer_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn GetStatus( + this: *mut core::ffi::c_void, + ppeventserverstatus: *mut *mut __MIDL___MIDL_itf_opc_ae_0000_0001_0005, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCEventServer_Impl::GetStatus(this) { + Ok(ok__) => { + ppeventserverstatus.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn CreateEventSubscription< + Identity: IOPCEventServer_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + bactive: windows_core::BOOL, + dwbuffertime: u32, + dwmaxsize: u32, + hclientsubscription: u32, + riid: *const windows_core::GUID, + ppunk: *mut *mut core::ffi::c_void, + pdwrevisedbuffertime: *mut u32, + pdwrevisedmaxsize: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventServer_Impl::CreateEventSubscription( + this, + core::mem::transmute_copy(&bactive), + core::mem::transmute_copy(&dwbuffertime), + core::mem::transmute_copy(&dwmaxsize), + core::mem::transmute_copy(&hclientsubscription), + core::mem::transmute_copy(&riid), + core::mem::transmute_copy(&ppunk), + core::mem::transmute_copy(&pdwrevisedbuffertime), + core::mem::transmute_copy(&pdwrevisedmaxsize), + ) + .into() + } + } + unsafe extern "system" fn QueryAvailableFilters< + Identity: IOPCEventServer_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pdwfiltermask: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCEventServer_Impl::QueryAvailableFilters(this) { + Ok(ok__) => { + pdwfiltermask.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn QueryEventCategories< + Identity: IOPCEventServer_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dweventtype: u32, + pdwcount: *mut u32, + ppdweventcategories: *mut *mut u32, + ppszeventcategorydescs: *mut *mut windows_core::PWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventServer_Impl::QueryEventCategories( + this, + core::mem::transmute_copy(&dweventtype), + core::mem::transmute_copy(&pdwcount), + core::mem::transmute_copy(&ppdweventcategories), + core::mem::transmute_copy(&ppszeventcategorydescs), + ) + .into() + } + } + unsafe extern "system" fn QueryConditionNames< + Identity: IOPCEventServer_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dweventcategory: u32, + pdwcount: *mut u32, + ppszconditionnames: *mut *mut windows_core::PWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventServer_Impl::QueryConditionNames( + this, + core::mem::transmute_copy(&dweventcategory), + core::mem::transmute_copy(&pdwcount), + core::mem::transmute_copy(&ppszconditionnames), + ) + .into() + } + } + unsafe extern "system" fn QuerySubConditionNames< + Identity: IOPCEventServer_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + szconditionname: windows_core::PCWSTR, + pdwcount: *mut u32, + ppszsubconditionnames: *mut *mut windows_core::PWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventServer_Impl::QuerySubConditionNames( + this, + core::mem::transmute(&szconditionname), + core::mem::transmute_copy(&pdwcount), + core::mem::transmute_copy(&ppszsubconditionnames), + ) + .into() + } + } + unsafe extern "system" fn QuerySourceConditions< + Identity: IOPCEventServer_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + szsource: windows_core::PCWSTR, + pdwcount: *mut u32, + ppszconditionnames: *mut *mut windows_core::PWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventServer_Impl::QuerySourceConditions( + this, + core::mem::transmute(&szsource), + core::mem::transmute_copy(&pdwcount), + core::mem::transmute_copy(&ppszconditionnames), + ) + .into() + } + } + unsafe extern "system" fn QueryEventAttributes< + Identity: IOPCEventServer_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dweventcategory: u32, + pdwcount: *mut u32, + ppdwattrids: *mut *mut u32, + ppszattrdescs: *mut *mut windows_core::PWSTR, + ppvtattrtypes: *mut *mut u16, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventServer_Impl::QueryEventAttributes( + this, + core::mem::transmute_copy(&dweventcategory), + core::mem::transmute_copy(&pdwcount), + core::mem::transmute_copy(&ppdwattrids), + core::mem::transmute_copy(&ppszattrdescs), + core::mem::transmute_copy(&ppvtattrtypes), + ) + .into() + } + } + unsafe extern "system" fn TranslateToItemIDs< + Identity: IOPCEventServer_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + szsource: windows_core::PCWSTR, + dweventcategory: u32, + szconditionname: windows_core::PCWSTR, + szsubconditionname: windows_core::PCWSTR, + dwcount: u32, + pdwassocattrids: *const u32, + ppszattritemids: *mut *mut windows_core::PWSTR, + ppsznodenames: *mut *mut windows_core::PWSTR, + ppclsids: *mut *mut windows_core::GUID, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventServer_Impl::TranslateToItemIDs( + this, + core::mem::transmute(&szsource), + core::mem::transmute_copy(&dweventcategory), + core::mem::transmute(&szconditionname), + core::mem::transmute(&szsubconditionname), + core::mem::transmute_copy(&dwcount), + core::mem::transmute_copy(&pdwassocattrids), + core::mem::transmute_copy(&ppszattritemids), + core::mem::transmute_copy(&ppsznodenames), + core::mem::transmute_copy(&ppclsids), + ) + .into() + } + } + unsafe extern "system" fn GetConditionState< + Identity: IOPCEventServer_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + szsource: windows_core::PCWSTR, + szconditionname: windows_core::PCWSTR, + dwnumeventattrs: u32, + pdwattributeids: *const u32, + ppconditionstate: *mut *mut __MIDL___MIDL_itf_opc_ae_0000_0001_0006, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCEventServer_Impl::GetConditionState( + this, + core::mem::transmute(&szsource), + core::mem::transmute(&szconditionname), + core::mem::transmute_copy(&dwnumeventattrs), + core::mem::transmute_copy(&pdwattributeids), + ) { + Ok(ok__) => { + ppconditionstate.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn EnableConditionByArea< + Identity: IOPCEventServer_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwnumareas: u32, + pszareas: *const windows_core::PCWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventServer_Impl::EnableConditionByArea( + this, + core::mem::transmute_copy(&dwnumareas), + core::mem::transmute_copy(&pszareas), + ) + .into() + } + } + unsafe extern "system" fn EnableConditionBySource< + Identity: IOPCEventServer_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwnumsources: u32, + pszsources: *const windows_core::PCWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventServer_Impl::EnableConditionBySource( + this, + core::mem::transmute_copy(&dwnumsources), + core::mem::transmute_copy(&pszsources), + ) + .into() + } + } + unsafe extern "system" fn DisableConditionByArea< + Identity: IOPCEventServer_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwnumareas: u32, + pszareas: *const windows_core::PCWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventServer_Impl::DisableConditionByArea( + this, + core::mem::transmute_copy(&dwnumareas), + core::mem::transmute_copy(&pszareas), + ) + .into() + } + } + unsafe extern "system" fn DisableConditionBySource< + Identity: IOPCEventServer_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwnumsources: u32, + pszsources: *const windows_core::PCWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventServer_Impl::DisableConditionBySource( + this, + core::mem::transmute_copy(&dwnumsources), + core::mem::transmute_copy(&pszsources), + ) + .into() + } + } + unsafe extern "system" fn AckCondition< + Identity: IOPCEventServer_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwcount: u32, + szacknowledgerid: windows_core::PCWSTR, + szcomment: windows_core::PCWSTR, + pszsource: *const windows_core::PCWSTR, + pszconditionname: *const windows_core::PCWSTR, + pftactivetime: *const windows::Win32::Foundation::FILETIME, + pdwcookie: *const u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventServer_Impl::AckCondition( + this, + core::mem::transmute_copy(&dwcount), + core::mem::transmute(&szacknowledgerid), + core::mem::transmute(&szcomment), + core::mem::transmute_copy(&pszsource), + core::mem::transmute_copy(&pszconditionname), + core::mem::transmute_copy(&pftactivetime), + core::mem::transmute_copy(&pdwcookie), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn CreateAreaBrowser< + Identity: IOPCEventServer_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + riid: *const windows_core::GUID, + ppunk: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCEventServer_Impl::CreateAreaBrowser( + this, + core::mem::transmute_copy(&riid), + ) { + Ok(ok__) => { + ppunk.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + Self { + base__: windows_core::IUnknown_Vtbl::new::(), + GetStatus: GetStatus::, + CreateEventSubscription: CreateEventSubscription::, + QueryAvailableFilters: QueryAvailableFilters::, + QueryEventCategories: QueryEventCategories::, + QueryConditionNames: QueryConditionNames::, + QuerySubConditionNames: QuerySubConditionNames::, + QuerySourceConditions: QuerySourceConditions::, + QueryEventAttributes: QueryEventAttributes::, + TranslateToItemIDs: TranslateToItemIDs::, + GetConditionState: GetConditionState::, + EnableConditionByArea: EnableConditionByArea::, + EnableConditionBySource: EnableConditionBySource::, + DisableConditionByArea: DisableConditionByArea::, + DisableConditionBySource: DisableConditionBySource::, + AckCondition: AckCondition::, + CreateAreaBrowser: CreateAreaBrowser::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +impl windows_core::RuntimeName for IOPCEventServer {} +windows_core::imp::define_interface!( + IOPCEventServer2, + IOPCEventServer2_Vtbl, + 0x71bbe88e_9564_4bcd_bcfc_71c558d94f2d +); +impl core::ops::Deref for IOPCEventServer2 { + type Target = IOPCEventServer; + fn deref(&self) -> &Self::Target { + unsafe { core::mem::transmute(self) } + } +} +windows_core::imp::interface_hierarchy!(IOPCEventServer2, windows_core::IUnknown, IOPCEventServer); +impl IOPCEventServer2 { + pub unsafe fn EnableConditionByArea2( + &self, + dwnumareas: u32, + pszareas: *const windows_core::PCWSTR, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).EnableConditionByArea2)( + windows_core::Interface::as_raw(self), + dwnumareas, + pszareas, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn EnableConditionBySource2( + &self, + dwnumsources: u32, + pszsources: *const windows_core::PCWSTR, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).EnableConditionBySource2)( + windows_core::Interface::as_raw(self), + dwnumsources, + pszsources, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn DisableConditionByArea2( + &self, + dwnumareas: u32, + pszareas: *const windows_core::PCWSTR, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).DisableConditionByArea2)( + windows_core::Interface::as_raw(self), + dwnumareas, + pszareas, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn DisableConditionBySource2( + &self, + dwnumsources: u32, + pszsources: *const windows_core::PCWSTR, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).DisableConditionBySource2)( + windows_core::Interface::as_raw(self), + dwnumsources, + pszsources, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn GetEnableStateByArea( + &self, + dwnumareas: u32, + pszareas: *const windows_core::PCWSTR, + pbenabled: *mut *mut windows_core::BOOL, + pbeffectivelyenabled: *mut *mut windows_core::BOOL, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).GetEnableStateByArea)( + windows_core::Interface::as_raw(self), + dwnumareas, + pszareas, + pbenabled as _, + pbeffectivelyenabled as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn GetEnableStateBySource( + &self, + dwnumsources: u32, + pszsources: *const windows_core::PCWSTR, + pbenabled: *mut *mut windows_core::BOOL, + pbeffectivelyenabled: *mut *mut windows_core::BOOL, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).GetEnableStateBySource)( + windows_core::Interface::as_raw(self), + dwnumsources, + pszsources, + pbenabled as _, + pbeffectivelyenabled as _, + pperrors as _, + ) + .ok() + } + } +} +#[repr(C)] +#[doc(hidden)] +pub struct IOPCEventServer2_Vtbl { + pub base__: IOPCEventServer_Vtbl, + pub EnableConditionByArea2: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const windows_core::PCWSTR, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub EnableConditionBySource2: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const windows_core::PCWSTR, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub DisableConditionByArea2: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const windows_core::PCWSTR, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub DisableConditionBySource2: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const windows_core::PCWSTR, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub GetEnableStateByArea: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const windows_core::PCWSTR, + *mut *mut windows_core::BOOL, + *mut *mut windows_core::BOOL, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub GetEnableStateBySource: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const windows_core::PCWSTR, + *mut *mut windows_core::BOOL, + *mut *mut windows_core::BOOL, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, +} +pub trait IOPCEventServer2_Impl: IOPCEventServer_Impl { + fn EnableConditionByArea2( + &self, + dwnumareas: u32, + pszareas: *const windows_core::PCWSTR, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn EnableConditionBySource2( + &self, + dwnumsources: u32, + pszsources: *const windows_core::PCWSTR, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn DisableConditionByArea2( + &self, + dwnumareas: u32, + pszareas: *const windows_core::PCWSTR, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn DisableConditionBySource2( + &self, + dwnumsources: u32, + pszsources: *const windows_core::PCWSTR, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn GetEnableStateByArea( + &self, + dwnumareas: u32, + pszareas: *const windows_core::PCWSTR, + pbenabled: *mut *mut windows_core::BOOL, + pbeffectivelyenabled: *mut *mut windows_core::BOOL, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn GetEnableStateBySource( + &self, + dwnumsources: u32, + pszsources: *const windows_core::PCWSTR, + pbenabled: *mut *mut windows_core::BOOL, + pbeffectivelyenabled: *mut *mut windows_core::BOOL, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; +} +impl IOPCEventServer2_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn EnableConditionByArea2< + Identity: IOPCEventServer2_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwnumareas: u32, + pszareas: *const windows_core::PCWSTR, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventServer2_Impl::EnableConditionByArea2( + this, + core::mem::transmute_copy(&dwnumareas), + core::mem::transmute_copy(&pszareas), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn EnableConditionBySource2< + Identity: IOPCEventServer2_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwnumsources: u32, + pszsources: *const windows_core::PCWSTR, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventServer2_Impl::EnableConditionBySource2( + this, + core::mem::transmute_copy(&dwnumsources), + core::mem::transmute_copy(&pszsources), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn DisableConditionByArea2< + Identity: IOPCEventServer2_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwnumareas: u32, + pszareas: *const windows_core::PCWSTR, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventServer2_Impl::DisableConditionByArea2( + this, + core::mem::transmute_copy(&dwnumareas), + core::mem::transmute_copy(&pszareas), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn DisableConditionBySource2< + Identity: IOPCEventServer2_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwnumsources: u32, + pszsources: *const windows_core::PCWSTR, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventServer2_Impl::DisableConditionBySource2( + this, + core::mem::transmute_copy(&dwnumsources), + core::mem::transmute_copy(&pszsources), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn GetEnableStateByArea< + Identity: IOPCEventServer2_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwnumareas: u32, + pszareas: *const windows_core::PCWSTR, + pbenabled: *mut *mut windows_core::BOOL, + pbeffectivelyenabled: *mut *mut windows_core::BOOL, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventServer2_Impl::GetEnableStateByArea( + this, + core::mem::transmute_copy(&dwnumareas), + core::mem::transmute_copy(&pszareas), + core::mem::transmute_copy(&pbenabled), + core::mem::transmute_copy(&pbeffectivelyenabled), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn GetEnableStateBySource< + Identity: IOPCEventServer2_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwnumsources: u32, + pszsources: *const windows_core::PCWSTR, + pbenabled: *mut *mut windows_core::BOOL, + pbeffectivelyenabled: *mut *mut windows_core::BOOL, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventServer2_Impl::GetEnableStateBySource( + this, + core::mem::transmute_copy(&dwnumsources), + core::mem::transmute_copy(&pszsources), + core::mem::transmute_copy(&pbenabled), + core::mem::transmute_copy(&pbeffectivelyenabled), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + Self { + base__: IOPCEventServer_Vtbl::new::(), + EnableConditionByArea2: EnableConditionByArea2::, + EnableConditionBySource2: EnableConditionBySource2::, + DisableConditionByArea2: DisableConditionByArea2::, + DisableConditionBySource2: DisableConditionBySource2::, + GetEnableStateByArea: GetEnableStateByArea::, + GetEnableStateBySource: GetEnableStateBySource::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + || iid == &::IID + } +} +impl windows_core::RuntimeName for IOPCEventServer2 {} +windows_core::imp::define_interface!( + IOPCEventSink, + IOPCEventSink_Vtbl, + 0x6516885f_5783_11d1_84a0_00608cb8a7e9 +); +windows_core::imp::interface_hierarchy!(IOPCEventSink, windows_core::IUnknown); +impl IOPCEventSink { + pub unsafe fn OnEvent( + &self, + hclientsubscription: u32, + brefresh: bool, + blastrefresh: bool, + pevents: &[__MIDL___MIDL_itf_opc_ae_0000_0001_0004], + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).OnEvent)( + windows_core::Interface::as_raw(self), + hclientsubscription, + brefresh.into(), + blastrefresh.into(), + pevents.len().try_into().unwrap(), + core::mem::transmute(pevents.as_ptr()), + ) + .ok() + } + } +} +#[repr(C)] +#[doc(hidden)] +pub struct IOPCEventSink_Vtbl { + pub base__: windows_core::IUnknown_Vtbl, + pub OnEvent: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + windows_core::BOOL, + windows_core::BOOL, + u32, + *const __MIDL___MIDL_itf_opc_ae_0000_0001_0004, + ) -> windows_core::HRESULT, +} +pub trait IOPCEventSink_Impl: windows_core::IUnknownImpl { + fn OnEvent( + &self, + hclientsubscription: u32, + brefresh: windows_core::BOOL, + blastrefresh: windows_core::BOOL, + dwcount: u32, + pevents: *const __MIDL___MIDL_itf_opc_ae_0000_0001_0004, + ) -> windows_core::Result<()>; +} +impl IOPCEventSink_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn OnEvent( + this: *mut core::ffi::c_void, + hclientsubscription: u32, + brefresh: windows_core::BOOL, + blastrefresh: windows_core::BOOL, + dwcount: u32, + pevents: *const __MIDL___MIDL_itf_opc_ae_0000_0001_0004, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventSink_Impl::OnEvent( + this, + core::mem::transmute_copy(&hclientsubscription), + core::mem::transmute_copy(&brefresh), + core::mem::transmute_copy(&blastrefresh), + core::mem::transmute_copy(&dwcount), + core::mem::transmute_copy(&pevents), + ) + .into() + } + } + Self { + base__: windows_core::IUnknown_Vtbl::new::(), + OnEvent: OnEvent::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +impl windows_core::RuntimeName for IOPCEventSink {} +windows_core::imp::define_interface!( + IOPCEventSubscriptionMgt, + IOPCEventSubscriptionMgt_Vtbl, + 0x65168855_5783_11d1_84a0_00608cb8a7e9 +); +windows_core::imp::interface_hierarchy!(IOPCEventSubscriptionMgt, windows_core::IUnknown); +impl IOPCEventSubscriptionMgt { + pub unsafe fn SetFilter( + &self, + dweventtype: u32, + pdweventcategories: &[u32], + dwlowseverity: u32, + dwhighseverity: u32, + pszarealist: &[windows_core::PCWSTR], + pszsourcelist: &[windows_core::PCWSTR], + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).SetFilter)( + windows_core::Interface::as_raw(self), + dweventtype, + pdweventcategories.len().try_into().unwrap(), + core::mem::transmute(pdweventcategories.as_ptr()), + dwlowseverity, + dwhighseverity, + pszarealist.len().try_into().unwrap(), + core::mem::transmute(pszarealist.as_ptr()), + pszsourcelist.len().try_into().unwrap(), + core::mem::transmute(pszsourcelist.as_ptr()), + ) + .ok() + } + } + pub unsafe fn GetFilter( + &self, + pdweventtype: *mut u32, + pdwnumcategories: *mut u32, + ppdweventcategories: *mut *mut u32, + pdwlowseverity: *mut u32, + pdwhighseverity: *mut u32, + pdwnumareas: *mut u32, + ppszarealist: *mut *mut windows_core::PWSTR, + pdwnumsources: *mut u32, + ppszsourcelist: *mut *mut windows_core::PWSTR, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).GetFilter)( + windows_core::Interface::as_raw(self), + pdweventtype as _, + pdwnumcategories as _, + ppdweventcategories as _, + pdwlowseverity as _, + pdwhighseverity as _, + pdwnumareas as _, + ppszarealist as _, + pdwnumsources as _, + ppszsourcelist as _, + ) + .ok() + } + } + pub unsafe fn SelectReturnedAttributes( + &self, + dweventcategory: u32, + dwattributeids: &[u32], + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).SelectReturnedAttributes)( + windows_core::Interface::as_raw(self), + dweventcategory, + dwattributeids.len().try_into().unwrap(), + core::mem::transmute(dwattributeids.as_ptr()), + ) + .ok() + } + } + pub unsafe fn GetReturnedAttributes( + &self, + dweventcategory: u32, + pdwcount: *mut u32, + ppdwattributeids: *mut *mut u32, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).GetReturnedAttributes)( + windows_core::Interface::as_raw(self), + dweventcategory, + pdwcount as _, + ppdwattributeids as _, + ) + .ok() + } + } + pub unsafe fn Refresh(&self, dwconnection: u32) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).Refresh)( + windows_core::Interface::as_raw(self), + dwconnection, + ) + .ok() + } + } + pub unsafe fn CancelRefresh(&self, dwconnection: u32) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).CancelRefresh)( + windows_core::Interface::as_raw(self), + dwconnection, + ) + .ok() + } + } + pub unsafe fn GetState( + &self, + pbactive: *mut windows_core::BOOL, + pdwbuffertime: *mut u32, + pdwmaxsize: *mut u32, + phclientsubscription: *mut u32, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).GetState)( + windows_core::Interface::as_raw(self), + pbactive as _, + pdwbuffertime as _, + pdwmaxsize as _, + phclientsubscription as _, + ) + .ok() + } + } + pub unsafe fn SetState( + &self, + pbactive: *const windows_core::BOOL, + pdwbuffertime: *const u32, + pdwmaxsize: *const u32, + hclientsubscription: u32, + pdwrevisedbuffertime: *mut u32, + pdwrevisedmaxsize: *mut u32, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).SetState)( + windows_core::Interface::as_raw(self), + pbactive, + pdwbuffertime, + pdwmaxsize, + hclientsubscription, + pdwrevisedbuffertime as _, + pdwrevisedmaxsize as _, + ) + .ok() + } + } +} +#[repr(C)] +#[doc(hidden)] +pub struct IOPCEventSubscriptionMgt_Vtbl { + pub base__: windows_core::IUnknown_Vtbl, + pub SetFilter: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + u32, + *const u32, + u32, + u32, + u32, + *const windows_core::PCWSTR, + u32, + *const windows_core::PCWSTR, + ) -> windows_core::HRESULT, + pub GetFilter: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut u32, + *mut u32, + *mut *mut u32, + *mut u32, + *mut u32, + *mut u32, + *mut *mut windows_core::PWSTR, + *mut u32, + *mut *mut windows_core::PWSTR, + ) -> windows_core::HRESULT, + pub SelectReturnedAttributes: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + u32, + *const u32, + ) -> windows_core::HRESULT, + pub GetReturnedAttributes: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *mut u32, + *mut *mut u32, + ) -> windows_core::HRESULT, + pub Refresh: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT, + pub CancelRefresh: + unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT, + pub GetState: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows_core::BOOL, + *mut u32, + *mut u32, + *mut u32, + ) -> windows_core::HRESULT, + pub SetState: unsafe extern "system" fn( + *mut core::ffi::c_void, + *const windows_core::BOOL, + *const u32, + *const u32, + u32, + *mut u32, + *mut u32, + ) -> windows_core::HRESULT, +} +pub trait IOPCEventSubscriptionMgt_Impl: windows_core::IUnknownImpl { + fn SetFilter( + &self, + dweventtype: u32, + dwnumcategories: u32, + pdweventcategories: *const u32, + dwlowseverity: u32, + dwhighseverity: u32, + dwnumareas: u32, + pszarealist: *const windows_core::PCWSTR, + dwnumsources: u32, + pszsourcelist: *const windows_core::PCWSTR, + ) -> windows_core::Result<()>; + fn GetFilter( + &self, + pdweventtype: *mut u32, + pdwnumcategories: *mut u32, + ppdweventcategories: *mut *mut u32, + pdwlowseverity: *mut u32, + pdwhighseverity: *mut u32, + pdwnumareas: *mut u32, + ppszarealist: *mut *mut windows_core::PWSTR, + pdwnumsources: *mut u32, + ppszsourcelist: *mut *mut windows_core::PWSTR, + ) -> windows_core::Result<()>; + fn SelectReturnedAttributes( + &self, + dweventcategory: u32, + dwcount: u32, + dwattributeids: *const u32, + ) -> windows_core::Result<()>; + fn GetReturnedAttributes( + &self, + dweventcategory: u32, + pdwcount: *mut u32, + ppdwattributeids: *mut *mut u32, + ) -> windows_core::Result<()>; + fn Refresh(&self, dwconnection: u32) -> windows_core::Result<()>; + fn CancelRefresh(&self, dwconnection: u32) -> windows_core::Result<()>; + fn GetState( + &self, + pbactive: *mut windows_core::BOOL, + pdwbuffertime: *mut u32, + pdwmaxsize: *mut u32, + phclientsubscription: *mut u32, + ) -> windows_core::Result<()>; + fn SetState( + &self, + pbactive: *const windows_core::BOOL, + pdwbuffertime: *const u32, + pdwmaxsize: *const u32, + hclientsubscription: u32, + pdwrevisedbuffertime: *mut u32, + pdwrevisedmaxsize: *mut u32, + ) -> windows_core::Result<()>; +} +impl IOPCEventSubscriptionMgt_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn SetFilter< + Identity: IOPCEventSubscriptionMgt_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dweventtype: u32, + dwnumcategories: u32, + pdweventcategories: *const u32, + dwlowseverity: u32, + dwhighseverity: u32, + dwnumareas: u32, + pszarealist: *const windows_core::PCWSTR, + dwnumsources: u32, + pszsourcelist: *const windows_core::PCWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventSubscriptionMgt_Impl::SetFilter( + this, + core::mem::transmute_copy(&dweventtype), + core::mem::transmute_copy(&dwnumcategories), + core::mem::transmute_copy(&pdweventcategories), + core::mem::transmute_copy(&dwlowseverity), + core::mem::transmute_copy(&dwhighseverity), + core::mem::transmute_copy(&dwnumareas), + core::mem::transmute_copy(&pszarealist), + core::mem::transmute_copy(&dwnumsources), + core::mem::transmute_copy(&pszsourcelist), + ) + .into() + } + } + unsafe extern "system" fn GetFilter< + Identity: IOPCEventSubscriptionMgt_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pdweventtype: *mut u32, + pdwnumcategories: *mut u32, + ppdweventcategories: *mut *mut u32, + pdwlowseverity: *mut u32, + pdwhighseverity: *mut u32, + pdwnumareas: *mut u32, + ppszarealist: *mut *mut windows_core::PWSTR, + pdwnumsources: *mut u32, + ppszsourcelist: *mut *mut windows_core::PWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventSubscriptionMgt_Impl::GetFilter( + this, + core::mem::transmute_copy(&pdweventtype), + core::mem::transmute_copy(&pdwnumcategories), + core::mem::transmute_copy(&ppdweventcategories), + core::mem::transmute_copy(&pdwlowseverity), + core::mem::transmute_copy(&pdwhighseverity), + core::mem::transmute_copy(&pdwnumareas), + core::mem::transmute_copy(&ppszarealist), + core::mem::transmute_copy(&pdwnumsources), + core::mem::transmute_copy(&ppszsourcelist), + ) + .into() + } + } + unsafe extern "system" fn SelectReturnedAttributes< + Identity: IOPCEventSubscriptionMgt_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dweventcategory: u32, + dwcount: u32, + dwattributeids: *const u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventSubscriptionMgt_Impl::SelectReturnedAttributes( + this, + core::mem::transmute_copy(&dweventcategory), + core::mem::transmute_copy(&dwcount), + core::mem::transmute_copy(&dwattributeids), + ) + .into() + } + } + unsafe extern "system" fn GetReturnedAttributes< + Identity: IOPCEventSubscriptionMgt_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dweventcategory: u32, + pdwcount: *mut u32, + ppdwattributeids: *mut *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventSubscriptionMgt_Impl::GetReturnedAttributes( + this, + core::mem::transmute_copy(&dweventcategory), + core::mem::transmute_copy(&pdwcount), + core::mem::transmute_copy(&ppdwattributeids), + ) + .into() + } + } + unsafe extern "system" fn Refresh< + Identity: IOPCEventSubscriptionMgt_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwconnection: u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventSubscriptionMgt_Impl::Refresh( + this, + core::mem::transmute_copy(&dwconnection), + ) + .into() + } + } + unsafe extern "system" fn CancelRefresh< + Identity: IOPCEventSubscriptionMgt_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwconnection: u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventSubscriptionMgt_Impl::CancelRefresh( + this, + core::mem::transmute_copy(&dwconnection), + ) + .into() + } + } + unsafe extern "system" fn GetState< + Identity: IOPCEventSubscriptionMgt_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pbactive: *mut windows_core::BOOL, + pdwbuffertime: *mut u32, + pdwmaxsize: *mut u32, + phclientsubscription: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventSubscriptionMgt_Impl::GetState( + this, + core::mem::transmute_copy(&pbactive), + core::mem::transmute_copy(&pdwbuffertime), + core::mem::transmute_copy(&pdwmaxsize), + core::mem::transmute_copy(&phclientsubscription), + ) + .into() + } + } + unsafe extern "system" fn SetState< + Identity: IOPCEventSubscriptionMgt_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pbactive: *const windows_core::BOOL, + pdwbuffertime: *const u32, + pdwmaxsize: *const u32, + hclientsubscription: u32, + pdwrevisedbuffertime: *mut u32, + pdwrevisedmaxsize: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEventSubscriptionMgt_Impl::SetState( + this, + core::mem::transmute_copy(&pbactive), + core::mem::transmute_copy(&pdwbuffertime), + core::mem::transmute_copy(&pdwmaxsize), + core::mem::transmute_copy(&hclientsubscription), + core::mem::transmute_copy(&pdwrevisedbuffertime), + core::mem::transmute_copy(&pdwrevisedmaxsize), + ) + .into() + } + } + Self { + base__: windows_core::IUnknown_Vtbl::new::(), + SetFilter: SetFilter::, + GetFilter: GetFilter::, + SelectReturnedAttributes: SelectReturnedAttributes::, + GetReturnedAttributes: GetReturnedAttributes::, + Refresh: Refresh::, + CancelRefresh: CancelRefresh::, + GetState: GetState::, + SetState: SetState::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +impl windows_core::RuntimeName for IOPCEventSubscriptionMgt {} +windows_core::imp::define_interface!( + IOPCEventSubscriptionMgt2, + IOPCEventSubscriptionMgt2_Vtbl, + 0x94c955dc_3684_4ccb_afab_f898ce19aac3 +); +impl core::ops::Deref for IOPCEventSubscriptionMgt2 { + type Target = IOPCEventSubscriptionMgt; + fn deref(&self) -> &Self::Target { + unsafe { core::mem::transmute(self) } + } +} +windows_core::imp::interface_hierarchy!( + IOPCEventSubscriptionMgt2, + windows_core::IUnknown, + IOPCEventSubscriptionMgt +); +impl IOPCEventSubscriptionMgt2 { + pub unsafe fn SetKeepAlive(&self, dwkeepalivetime: u32) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).SetKeepAlive)( + windows_core::Interface::as_raw(self), + dwkeepalivetime, + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn GetKeepAlive(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).GetKeepAlive)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } +} +#[repr(C)] +#[doc(hidden)] +pub struct IOPCEventSubscriptionMgt2_Vtbl { + pub base__: IOPCEventSubscriptionMgt_Vtbl, + pub SetKeepAlive: + unsafe extern "system" fn(*mut core::ffi::c_void, u32, *mut u32) -> windows_core::HRESULT, + pub GetKeepAlive: + unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, +} +pub trait IOPCEventSubscriptionMgt2_Impl: IOPCEventSubscriptionMgt_Impl { + fn SetKeepAlive(&self, dwkeepalivetime: u32) -> windows_core::Result; + fn GetKeepAlive(&self) -> windows_core::Result; +} +impl IOPCEventSubscriptionMgt2_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn SetKeepAlive< + Identity: IOPCEventSubscriptionMgt2_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwkeepalivetime: u32, + pdwrevisedkeepalivetime: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCEventSubscriptionMgt2_Impl::SetKeepAlive( + this, + core::mem::transmute_copy(&dwkeepalivetime), + ) { + Ok(ok__) => { + pdwrevisedkeepalivetime.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn GetKeepAlive< + Identity: IOPCEventSubscriptionMgt2_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pdwkeepalivetime: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCEventSubscriptionMgt2_Impl::GetKeepAlive(this) { + Ok(ok__) => { + pdwkeepalivetime.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + Self { + base__: IOPCEventSubscriptionMgt_Vtbl::new::(), + SetKeepAlive: SetKeepAlive::, + GetKeepAlive: GetKeepAlive::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + || iid == &::IID + } +} +impl windows_core::RuntimeName for IOPCEventSubscriptionMgt2 {} +pub const OPCAE_BROWSE_DOWN: __MIDL___MIDL_itf_opc_ae_0000_0001_0001 = + __MIDL___MIDL_itf_opc_ae_0000_0001_0001(2i32); +pub const OPCAE_BROWSE_TO: __MIDL___MIDL_itf_opc_ae_0000_0001_0001 = + __MIDL___MIDL_itf_opc_ae_0000_0001_0001(3i32); +pub const OPCAE_BROWSE_UP: __MIDL___MIDL_itf_opc_ae_0000_0001_0001 = + __MIDL___MIDL_itf_opc_ae_0000_0001_0001(1i32); +pub const OPCAE_STATUS_COMM_FAULT: __MIDL___MIDL_itf_opc_ae_0000_0001_0003 = + __MIDL___MIDL_itf_opc_ae_0000_0001_0003(6i32); +pub const OPCAE_STATUS_FAILED: __MIDL___MIDL_itf_opc_ae_0000_0001_0003 = + __MIDL___MIDL_itf_opc_ae_0000_0001_0003(2i32); +pub const OPCAE_STATUS_NOCONFIG: __MIDL___MIDL_itf_opc_ae_0000_0001_0003 = + __MIDL___MIDL_itf_opc_ae_0000_0001_0003(3i32); +pub const OPCAE_STATUS_RUNNING: __MIDL___MIDL_itf_opc_ae_0000_0001_0003 = + __MIDL___MIDL_itf_opc_ae_0000_0001_0003(1i32); +pub const OPCAE_STATUS_SUSPENDED: __MIDL___MIDL_itf_opc_ae_0000_0001_0003 = + __MIDL___MIDL_itf_opc_ae_0000_0001_0003(4i32); +pub const OPCAE_STATUS_TEST: __MIDL___MIDL_itf_opc_ae_0000_0001_0003 = + __MIDL___MIDL_itf_opc_ae_0000_0001_0003(5i32); +windows_core::imp::define_interface!( + OPCEventServerCATID, + OPCEventServerCATID_Vtbl, + 0x58e13251_ac87_11d1_84d5_00608cb8a7e9 +); +windows_core::imp::interface_hierarchy!(OPCEventServerCATID, windows_core::IUnknown); +#[repr(C)] +#[doc(hidden)] +pub struct OPCEventServerCATID_Vtbl { + pub base__: windows_core::IUnknown_Vtbl, +} +pub trait OPCEventServerCATID_Impl: windows_core::IUnknownImpl {} +impl OPCEventServerCATID_Vtbl { + pub const fn new() -> Self { + Self { + base__: windows_core::IUnknown_Vtbl::new::(), + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +impl windows_core::RuntimeName for OPCEventServerCATID {} +pub const OPC_ALL_EVENTS: u32 = 7u32; +pub const OPC_AREA: __MIDL___MIDL_itf_opc_ae_0000_0001_0002 = + __MIDL___MIDL_itf_opc_ae_0000_0001_0002(1i32); +pub const OPC_CATEGORY_DESCRIPTION_AE10: windows_core::PCWSTR = + windows_core::w!("OPC Alarm & Event Server Version 1.0"); +pub const OPC_CHANGE_ACK_STATE: u32 = 2u32; +pub const OPC_CHANGE_ACTIVE_STATE: u32 = 1u32; +pub const OPC_CHANGE_ATTRIBUTE: u32 = 128u32; +pub const OPC_CHANGE_ENABLE_STATE: u32 = 4u32; +pub const OPC_CHANGE_MESSAGE: u32 = 64u32; +pub const OPC_CHANGE_QUALITY: u32 = 8u32; +pub const OPC_CHANGE_SEVERITY: u32 = 16u32; +pub const OPC_CHANGE_SUBCONDITION: u32 = 32u32; +pub const OPC_CONDITION_ACKED: u32 = 4u32; +pub const OPC_CONDITION_ACTIVE: u32 = 2u32; +pub const OPC_CONDITION_ENABLED: u32 = 1u32; +pub const OPC_CONDITION_EVENT: u32 = 4u32; +pub const OPC_FILTER_BY_AREA: u32 = 8u32; +pub const OPC_FILTER_BY_CATEGORY: u32 = 2u32; +pub const OPC_FILTER_BY_EVENT: u32 = 1u32; +pub const OPC_FILTER_BY_SEVERITY: u32 = 4u32; +pub const OPC_FILTER_BY_SOURCE: u32 = 16u32; +pub const OPC_SIMPLE_EVENT: u32 = 1u32; +pub const OPC_SOURCE: __MIDL___MIDL_itf_opc_ae_0000_0001_0002 = + __MIDL___MIDL_itf_opc_ae_0000_0001_0002(2i32); +pub const OPC_TRACKING_EVENT: u32 = 2u32; +#[repr(transparent)] +#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] +pub struct __MIDL___MIDL_itf_opc_ae_0000_0001_0001(pub i32); +#[repr(transparent)] +#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] +pub struct __MIDL___MIDL_itf_opc_ae_0000_0001_0002(pub i32); +#[repr(transparent)] +#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] +pub struct __MIDL___MIDL_itf_opc_ae_0000_0001_0003(pub i32); +#[repr(C)] +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct __MIDL___MIDL_itf_opc_ae_0000_0001_0004 { + pub wChangeMask: u16, + pub wNewState: u16, + pub szSource: windows_core::PWSTR, + pub ftTime: windows::Win32::Foundation::FILETIME, + pub szMessage: windows_core::PWSTR, + pub dwEventType: u32, + pub dwEventCategory: u32, + pub dwSeverity: u32, + pub szConditionName: windows_core::PWSTR, + pub szSubconditionName: windows_core::PWSTR, + pub wQuality: u16, + pub wReserved: u16, + pub bAckRequired: windows_core::BOOL, + pub ftActiveTime: windows::Win32::Foundation::FILETIME, + pub dwCookie: u32, + pub dwNumEventAttrs: u32, + pub pEventAttributes: *mut windows::Win32::System::Variant::VARIANT, + pub szActorID: windows_core::PWSTR, +} +impl Default for __MIDL___MIDL_itf_opc_ae_0000_0001_0004 { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Clone, Copy, Debug, Default, PartialEq)] +pub struct __MIDL___MIDL_itf_opc_ae_0000_0001_0005 { + pub ftStartTime: windows::Win32::Foundation::FILETIME, + pub ftCurrentTime: windows::Win32::Foundation::FILETIME, + pub ftLastUpdateTime: windows::Win32::Foundation::FILETIME, + pub dwServerState: __MIDL___MIDL_itf_opc_ae_0000_0001_0003, + pub wMajorVersion: u16, + pub wMinorVersion: u16, + pub wBuildNumber: u16, + pub wReserved: u16, + pub szVendorInfo: windows_core::PWSTR, +} +#[repr(C)] +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct __MIDL___MIDL_itf_opc_ae_0000_0001_0006 { + pub wState: u16, + pub wReserved1: u16, + pub szActiveSubCondition: windows_core::PWSTR, + pub szASCDefinition: windows_core::PWSTR, + pub dwASCSeverity: u32, + pub szASCDescription: windows_core::PWSTR, + pub wQuality: u16, + pub wReserved2: u16, + pub ftLastAckTime: windows::Win32::Foundation::FILETIME, + pub ftSubCondLastActive: windows::Win32::Foundation::FILETIME, + pub ftCondLastActive: windows::Win32::Foundation::FILETIME, + pub ftCondLastInactive: windows::Win32::Foundation::FILETIME, + pub szAcknowledgerID: windows_core::PWSTR, + pub szComment: windows_core::PWSTR, + pub dwNumSCs: u32, + pub pszSCNames: *mut windows_core::PWSTR, + pub pszSCDefinitions: *mut windows_core::PWSTR, + pub pdwSCSeverities: *mut u32, + pub pszSCDescriptions: *mut windows_core::PWSTR, + pub dwNumEventAttrs: u32, + pub pEventAttributes: *mut windows::Win32::System::Variant::VARIANT, + pub pErrors: *mut windows_core::HRESULT, +} +impl Default for __MIDL___MIDL_itf_opc_ae_0000_0001_0006 { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } +} diff --git a/opc_ae_bindings/src/lib.rs b/opc_ae_bindings/src/lib.rs new file mode 100644 index 0000000..892ac88 --- /dev/null +++ b/opc_ae_bindings/src/lib.rs @@ -0,0 +1,3 @@ +mod bindings; + +pub use bindings::*; diff --git a/opc_comn_bindings/.gitignore b/opc_comn_bindings/.gitignore new file mode 100644 index 0000000..ea8c4bf --- /dev/null +++ b/opc_comn_bindings/.gitignore @@ -0,0 +1 @@ +/target diff --git a/opc_comn_bindings/.metadata/.gitignore b/opc_comn_bindings/.metadata/.gitignore new file mode 100644 index 0000000..1746e32 --- /dev/null +++ b/opc_comn_bindings/.metadata/.gitignore @@ -0,0 +1,2 @@ +bin +obj diff --git a/opc_comn_bindings/.metadata/generate.proj b/opc_comn_bindings/.metadata/generate.proj new file mode 100644 index 0000000..bce230e --- /dev/null +++ b/opc_comn_bindings/.metadata/generate.proj @@ -0,0 +1,17 @@ + + + + ../.windows/winmd/OPCCOMN.winmd + 0.0.0.1 + $(CompiledHeadersDir) + + + + + + @(Headers) + OPCCOMN + true + + + \ No newline at end of file diff --git a/opc_comn_bindings/.metadata/main.cpp b/opc_comn_bindings/.metadata/main.cpp new file mode 100644 index 0000000..aae7e26 --- /dev/null +++ b/opc_comn_bindings/.metadata/main.cpp @@ -0,0 +1,3 @@ +#include + +#include "opccomn.h" diff --git a/opc_da_bindings/.metadata/OPCComn.idl b/opc_comn_bindings/.metadata/opccomn.idl similarity index 100% rename from opc_da_bindings/.metadata/OPCComn.idl rename to opc_comn_bindings/.metadata/opccomn.idl diff --git a/opc_comn_bindings/.windows/winmd/OPCCOMN.winmd b/opc_comn_bindings/.windows/winmd/OPCCOMN.winmd new file mode 100644 index 0000000000000000000000000000000000000000..09c52e113b4e661087e1d389c84d7e8ed8b9b0e0 GIT binary patch literal 3584 zcmeHJU2GIp6h3ozXWLzDmu*q`kvMhRAgOLB)dyoGZFft%(x0WY8Cv>Y#*AdAN;f$J`T>+9hbW2>IOzN zTghAIh^6L~jA|IBqYQDyDj14pD2cwbk~6bBR#g?M_d=&S0J*%+(IB#a_YIijA0p9oi^wqGAu*5qM*K(7GRBsdyH857Ho{Wf-^56>rU30q(iA z<<43Kpt8)P5^+}zbRMpb;|Y$Unye7kvTX z5!|%Tu%2kzu{2}ECXZhN?p{U*({Kr8+&zeP4ki=W|B1K@6N|R%<`6j};c%(*egIlV z_(N)j``p~==u}{%@$0e4*yx-`uu*L|4yj6V>kPmooRtEw7r7tCq*oyTA@)AXeJK0k z8RQ|j0!Ptj4Um2%6i_q9j*0*jmEuZp82f8dp$z@%Atr1`m}{#Lh@#NAkU)}$s^KN6 z22}K1i#9hlz^wcx3n6xCR(=XLh>8f$%1w|EHF}6`64krtpk#>S<)SrG2&za#nw696 zH3+)^(J-5adrN2=%)p8gnr0W_ffA}^8$c@OSpc$qwh9t@^%r+si5Wj`!Oe;F=# zF)6}4dNA05%?EgV1(E)k(9f57PKvn>Aos!a4SElVj&eRz7U%Ehz%b8bS^Q!q49|lP zn;)BuEr4wWG_nYul}5G_nuHvOTEq!hg1ebPc{iT#TKERuMt&7np%$8?dTA95!i+>d z^^D{!@+p{Mq)GUQ&-h6Hv!8gqOx9Oq;U6HrKwhc%J}u~6>37l5dK5{5RYj2OOU2XN z8sk>CW;^SlrN_(`biM(|&|wsE;>Ayvq)zU1n;BK-_&G?I$@#p!XA8HIMmB~29yG?g z)5*j}%glM096S*t$NPGEA+F&7!!u^knYu(DKXT-PvgubShShv?$EX>g2h?-{hYH87FqK%v_l{FDwA z91gvh{}^wxEOjDj44VsvxM|qV0?g;#uP@-@c375adC(fkV1z7H1?dUf;kiX=yUJMH z%z0%lvM(&6*iQ7znFglc&s7@*vG=0|2bUeeps~{+A-z+}gEuuUEo8?hKZM(zp$6dCjJ}ge`$Psp&TK4ej6=2l~0q z9iY9$`H175#c|&qNPAh))^gi%GcBD`=yiYGc$_y~>OcQQ|6lFCA!pDtDV=!te*Hv5BbuRMGp_Y#Vr|1O^k+X;x^eYgND=6u3O#?cA_44V# zFY6BUzH#crw;x=*G6}FKg@&byzicKqas89CQ*Rxck59^7FE$-GxrZkCuc^hm6Hy*p zNLEO?nTmHO*YaH4v=X}BqiP1^?2Kt~9?R-<-@%)811PORy6c$YUMEMz{p_yG?*D}T H7) literal 0 HcmV?d00001 diff --git a/opc_comn_bindings/Cargo.toml b/opc_comn_bindings/Cargo.toml new file mode 100644 index 0000000..98a4172 --- /dev/null +++ b/opc_comn_bindings/Cargo.toml @@ -0,0 +1,22 @@ +[package] +name = "opc_comn_bindings" +version = "0.3.0" +edition = "2024" +description = "OPC Historical Data Access bindings" +readme = "README.md" +repository = "https://github.com/Ronbb/rust_opc" +license = "MIT" +keywords = ["bindings", "comn", "opc", "opccomn"] +exclude = [".metadata/*", ".windows/*", "build.rs"] + +[package.metadata.docs.rs] +default-target = "x86_64-pc-windows-msvc" +targets = [] + +[dependencies] +windows = { workspace = true } +windows-core = { workspace = true } +windows-targets = { workspace = true } + +[build-dependencies] +windows-bindgen = { workspace = true } diff --git a/opc_comn_bindings/README.md b/opc_comn_bindings/README.md new file mode 100644 index 0000000..d4e23a4 --- /dev/null +++ b/opc_comn_bindings/README.md @@ -0,0 +1,18 @@ +# OPC Common Bindings + +Please see docs on [docs.rs](https://docs.rs/opc_comn_bindings/). + +## Example + +```rust +// TODO +``` + +## Rebuild metadata + +Open **Developer Powershell for VS2022**. + +```batch +cd .metadata +dotnet build +``` diff --git a/opc_comn_bindings/build.rs b/opc_comn_bindings/build.rs new file mode 100644 index 0000000..2c9cbd4 --- /dev/null +++ b/opc_comn_bindings/build.rs @@ -0,0 +1,19 @@ +fn main() { + println!("cargo:rerun-if-changed=build.rs"); + println!("cargo:rerun-if-changed=.windows/winmd/OPCCOMN.winmd"); + + windows_bindgen::bindgen([ + "--in", + ".windows/winmd/OPCCOMN.winmd", + "default", + "--out", + "src/bindings.rs", + "--reference", + "windows,skip-root,Windows", + "--filter", + "OPCCOMN", + "--flat", + "--implement", + ]) + .unwrap(); +} diff --git a/opc_comn_bindings/src/bindings.rs b/opc_comn_bindings/src/bindings.rs new file mode 100644 index 0000000..30d4c77 --- /dev/null +++ b/opc_comn_bindings/src/bindings.rs @@ -0,0 +1,781 @@ +// Bindings generated by `windows-bindgen` 0.62.1 + +#![allow( + non_snake_case, + non_upper_case_globals, + non_camel_case_types, + dead_code, + clippy::all +)] + +windows_core::imp::define_interface!( + IOPCCommon, + IOPCCommon_Vtbl, + 0xf31dfde2_07b6_11d2_b2d8_0060083ba1fb +); +windows_core::imp::interface_hierarchy!(IOPCCommon, windows_core::IUnknown); +impl IOPCCommon { + pub unsafe fn SetLocaleID(&self, dwlcid: u32) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).SetLocaleID)( + windows_core::Interface::as_raw(self), + dwlcid, + ) + .ok() + } + } + pub unsafe fn GetLocaleID(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).GetLocaleID)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn QueryAvailableLocaleIDs( + &self, + pdwcount: *mut u32, + pdwlcid: *mut *mut u32, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).QueryAvailableLocaleIDs)( + windows_core::Interface::as_raw(self), + pdwcount as _, + pdwlcid as _, + ) + .ok() + } + } + pub unsafe fn GetErrorString( + &self, + dwerror: windows_core::HRESULT, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).GetErrorString)( + windows_core::Interface::as_raw(self), + dwerror, + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn SetClientName(&self, szname: P0) -> windows_core::Result<()> + where + P0: windows_core::Param, + { + unsafe { + (windows_core::Interface::vtable(self).SetClientName)( + windows_core::Interface::as_raw(self), + szname.param().abi(), + ) + .ok() + } + } +} +#[repr(C)] +#[doc(hidden)] +pub struct IOPCCommon_Vtbl { + pub base__: windows_core::IUnknown_Vtbl, + pub SetLocaleID: + unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT, + pub GetLocaleID: + unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, + pub QueryAvailableLocaleIDs: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut u32, + *mut *mut u32, + ) -> windows_core::HRESULT, + pub GetErrorString: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows_core::HRESULT, + *mut windows_core::PWSTR, + ) -> windows_core::HRESULT, + pub SetClientName: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows_core::PCWSTR, + ) -> windows_core::HRESULT, +} +pub trait IOPCCommon_Impl: windows_core::IUnknownImpl { + fn SetLocaleID(&self, dwlcid: u32) -> windows_core::Result<()>; + fn GetLocaleID(&self) -> windows_core::Result; + fn QueryAvailableLocaleIDs( + &self, + pdwcount: *mut u32, + pdwlcid: *mut *mut u32, + ) -> windows_core::Result<()>; + fn GetErrorString( + &self, + dwerror: windows_core::HRESULT, + ) -> windows_core::Result; + fn SetClientName(&self, szname: &windows_core::PCWSTR) -> windows_core::Result<()>; +} +impl IOPCCommon_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn SetLocaleID( + this: *mut core::ffi::c_void, + dwlcid: u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCCommon_Impl::SetLocaleID(this, core::mem::transmute_copy(&dwlcid)).into() + } + } + unsafe extern "system" fn GetLocaleID( + this: *mut core::ffi::c_void, + pdwlcid: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCCommon_Impl::GetLocaleID(this) { + Ok(ok__) => { + pdwlcid.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn QueryAvailableLocaleIDs< + Identity: IOPCCommon_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pdwcount: *mut u32, + pdwlcid: *mut *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCCommon_Impl::QueryAvailableLocaleIDs( + this, + core::mem::transmute_copy(&pdwcount), + core::mem::transmute_copy(&pdwlcid), + ) + .into() + } + } + unsafe extern "system" fn GetErrorString( + this: *mut core::ffi::c_void, + dwerror: windows_core::HRESULT, + ppstring: *mut windows_core::PWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCCommon_Impl::GetErrorString(this, core::mem::transmute_copy(&dwerror)) { + Ok(ok__) => { + ppstring.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn SetClientName( + this: *mut core::ffi::c_void, + szname: windows_core::PCWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCCommon_Impl::SetClientName(this, core::mem::transmute(&szname)).into() + } + } + Self { + base__: windows_core::IUnknown_Vtbl::new::(), + SetLocaleID: SetLocaleID::, + GetLocaleID: GetLocaleID::, + QueryAvailableLocaleIDs: QueryAvailableLocaleIDs::, + GetErrorString: GetErrorString::, + SetClientName: SetClientName::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +impl windows_core::RuntimeName for IOPCCommon {} +windows_core::imp::define_interface!( + IOPCEnumGUID, + IOPCEnumGUID_Vtbl, + 0x55c382c8_21c7_4e88_96c1_becfb1e3f483 +); +windows_core::imp::interface_hierarchy!(IOPCEnumGUID, windows_core::IUnknown); +impl IOPCEnumGUID { + pub unsafe fn Next( + &self, + rgelt: &mut [windows_core::GUID], + pceltfetched: *mut u32, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).Next)( + windows_core::Interface::as_raw(self), + rgelt.len().try_into().unwrap(), + core::mem::transmute(rgelt.as_ptr()), + pceltfetched as _, + ) + .ok() + } + } + pub unsafe fn Skip(&self, celt: u32) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).Skip)( + windows_core::Interface::as_raw(self), + celt, + ) + .ok() + } + } + pub unsafe fn Reset(&self) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self)) + .ok() + } + } + pub unsafe fn Clone(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).Clone)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } +} +#[repr(C)] +#[doc(hidden)] +pub struct IOPCEnumGUID_Vtbl { + pub base__: windows_core::IUnknown_Vtbl, + pub Next: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *mut windows_core::GUID, + *mut u32, + ) -> windows_core::HRESULT, + pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT, + pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, + pub Clone: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT, +} +pub trait IOPCEnumGUID_Impl: windows_core::IUnknownImpl { + fn Next( + &self, + celt: u32, + rgelt: *mut windows_core::GUID, + pceltfetched: *mut u32, + ) -> windows_core::Result<()>; + fn Skip(&self, celt: u32) -> windows_core::Result<()>; + fn Reset(&self) -> windows_core::Result<()>; + fn Clone(&self) -> windows_core::Result; +} +impl IOPCEnumGUID_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn Next( + this: *mut core::ffi::c_void, + celt: u32, + rgelt: *mut windows_core::GUID, + pceltfetched: *mut u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEnumGUID_Impl::Next( + this, + core::mem::transmute_copy(&celt), + core::mem::transmute_copy(&rgelt), + core::mem::transmute_copy(&pceltfetched), + ) + .into() + } + } + unsafe extern "system" fn Skip( + this: *mut core::ffi::c_void, + celt: u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEnumGUID_Impl::Skip(this, core::mem::transmute_copy(&celt)).into() + } + } + unsafe extern "system" fn Reset( + this: *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCEnumGUID_Impl::Reset(this).into() + } + } + unsafe extern "system" fn Clone( + this: *mut core::ffi::c_void, + ppenum: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCEnumGUID_Impl::Clone(this) { + Ok(ok__) => { + ppenum.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + Self { + base__: windows_core::IUnknown_Vtbl::new::(), + Next: Next::, + Skip: Skip::, + Reset: Reset::, + Clone: Clone::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +impl windows_core::RuntimeName for IOPCEnumGUID {} +windows_core::imp::define_interface!( + IOPCServerList, + IOPCServerList_Vtbl, + 0x13486d50_4821_11d2_a494_3cb306c10000 +); +windows_core::imp::interface_hierarchy!(IOPCServerList, windows_core::IUnknown); +impl IOPCServerList { + pub unsafe fn EnumClassesOfCategories( + &self, + rgcatidimpl: &[windows_core::GUID], + rgcatidreq: &[windows_core::GUID], + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).EnumClassesOfCategories)( + windows_core::Interface::as_raw(self), + rgcatidimpl.len().try_into().unwrap(), + core::mem::transmute(rgcatidimpl.as_ptr()), + rgcatidreq.len().try_into().unwrap(), + core::mem::transmute(rgcatidreq.as_ptr()), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub unsafe fn GetClassDetails( + &self, + clsid: *const windows_core::GUID, + ppszprogid: *mut windows_core::PWSTR, + ppszusertype: *mut windows_core::PWSTR, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).GetClassDetails)( + windows_core::Interface::as_raw(self), + clsid, + ppszprogid as _, + ppszusertype as _, + ) + .ok() + } + } + pub unsafe fn CLSIDFromProgID( + &self, + szprogid: P0, + ) -> windows_core::Result + where + P0: windows_core::Param, + { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).CLSIDFromProgID)( + windows_core::Interface::as_raw(self), + szprogid.param().abi(), + &mut result__, + ) + .map(|| result__) + } + } +} +#[repr(C)] +#[doc(hidden)] +pub struct IOPCServerList_Vtbl { + pub base__: windows_core::IUnknown_Vtbl, + pub EnumClassesOfCategories: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const windows_core::GUID, + u32, + *const windows_core::GUID, + *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT, + pub GetClassDetails: unsafe extern "system" fn( + *mut core::ffi::c_void, + *const windows_core::GUID, + *mut windows_core::PWSTR, + *mut windows_core::PWSTR, + ) -> windows_core::HRESULT, + pub CLSIDFromProgID: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows_core::PCWSTR, + *mut windows_core::GUID, + ) -> windows_core::HRESULT, +} +pub trait IOPCServerList_Impl: windows_core::IUnknownImpl { + fn EnumClassesOfCategories( + &self, + cimplemented: u32, + rgcatidimpl: *const windows_core::GUID, + crequired: u32, + rgcatidreq: *const windows_core::GUID, + ) -> windows_core::Result; + fn GetClassDetails( + &self, + clsid: *const windows_core::GUID, + ppszprogid: *mut windows_core::PWSTR, + ppszusertype: *mut windows_core::PWSTR, + ) -> windows_core::Result<()>; + fn CLSIDFromProgID( + &self, + szprogid: &windows_core::PCWSTR, + ) -> windows_core::Result; +} +impl IOPCServerList_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn EnumClassesOfCategories< + Identity: IOPCServerList_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + cimplemented: u32, + rgcatidimpl: *const windows_core::GUID, + crequired: u32, + rgcatidreq: *const windows_core::GUID, + ppenumclsid: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCServerList_Impl::EnumClassesOfCategories( + this, + core::mem::transmute_copy(&cimplemented), + core::mem::transmute_copy(&rgcatidimpl), + core::mem::transmute_copy(&crequired), + core::mem::transmute_copy(&rgcatidreq), + ) { + Ok(ok__) => { + ppenumclsid.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn GetClassDetails< + Identity: IOPCServerList_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + clsid: *const windows_core::GUID, + ppszprogid: *mut windows_core::PWSTR, + ppszusertype: *mut windows_core::PWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCServerList_Impl::GetClassDetails( + this, + core::mem::transmute_copy(&clsid), + core::mem::transmute_copy(&ppszprogid), + core::mem::transmute_copy(&ppszusertype), + ) + .into() + } + } + unsafe extern "system" fn CLSIDFromProgID< + Identity: IOPCServerList_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + szprogid: windows_core::PCWSTR, + clsid: *mut windows_core::GUID, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCServerList_Impl::CLSIDFromProgID(this, core::mem::transmute(&szprogid)) { + Ok(ok__) => { + clsid.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + Self { + base__: windows_core::IUnknown_Vtbl::new::(), + EnumClassesOfCategories: EnumClassesOfCategories::, + GetClassDetails: GetClassDetails::, + CLSIDFromProgID: CLSIDFromProgID::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +impl windows_core::RuntimeName for IOPCServerList {} +windows_core::imp::define_interface!( + IOPCServerList2, + IOPCServerList2_Vtbl, + 0x9dd0b56c_ad9e_43ee_8305_487f3188bf7a +); +windows_core::imp::interface_hierarchy!(IOPCServerList2, windows_core::IUnknown); +impl IOPCServerList2 { + pub unsafe fn EnumClassesOfCategories( + &self, + rgcatidimpl: &[windows_core::GUID], + rgcatidreq: &[windows_core::GUID], + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).EnumClassesOfCategories)( + windows_core::Interface::as_raw(self), + rgcatidimpl.len().try_into().unwrap(), + core::mem::transmute(rgcatidimpl.as_ptr()), + rgcatidreq.len().try_into().unwrap(), + core::mem::transmute(rgcatidreq.as_ptr()), + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub unsafe fn GetClassDetails( + &self, + clsid: *const windows_core::GUID, + ppszprogid: *mut windows_core::PWSTR, + ppszusertype: *mut windows_core::PWSTR, + ppszverindprogid: *mut windows_core::PWSTR, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).GetClassDetails)( + windows_core::Interface::as_raw(self), + clsid, + ppszprogid as _, + ppszusertype as _, + ppszverindprogid as _, + ) + .ok() + } + } + pub unsafe fn CLSIDFromProgID( + &self, + szprogid: P0, + ) -> windows_core::Result + where + P0: windows_core::Param, + { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).CLSIDFromProgID)( + windows_core::Interface::as_raw(self), + szprogid.param().abi(), + &mut result__, + ) + .map(|| result__) + } + } +} +#[repr(C)] +#[doc(hidden)] +pub struct IOPCServerList2_Vtbl { + pub base__: windows_core::IUnknown_Vtbl, + pub EnumClassesOfCategories: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const windows_core::GUID, + u32, + *const windows_core::GUID, + *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT, + pub GetClassDetails: unsafe extern "system" fn( + *mut core::ffi::c_void, + *const windows_core::GUID, + *mut windows_core::PWSTR, + *mut windows_core::PWSTR, + *mut windows_core::PWSTR, + ) -> windows_core::HRESULT, + pub CLSIDFromProgID: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows_core::PCWSTR, + *mut windows_core::GUID, + ) -> windows_core::HRESULT, +} +pub trait IOPCServerList2_Impl: windows_core::IUnknownImpl { + fn EnumClassesOfCategories( + &self, + cimplemented: u32, + rgcatidimpl: *const windows_core::GUID, + crequired: u32, + rgcatidreq: *const windows_core::GUID, + ) -> windows_core::Result; + fn GetClassDetails( + &self, + clsid: *const windows_core::GUID, + ppszprogid: *mut windows_core::PWSTR, + ppszusertype: *mut windows_core::PWSTR, + ppszverindprogid: *mut windows_core::PWSTR, + ) -> windows_core::Result<()>; + fn CLSIDFromProgID( + &self, + szprogid: &windows_core::PCWSTR, + ) -> windows_core::Result; +} +impl IOPCServerList2_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn EnumClassesOfCategories< + Identity: IOPCServerList2_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + cimplemented: u32, + rgcatidimpl: *const windows_core::GUID, + crequired: u32, + rgcatidreq: *const windows_core::GUID, + ppenumclsid: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCServerList2_Impl::EnumClassesOfCategories( + this, + core::mem::transmute_copy(&cimplemented), + core::mem::transmute_copy(&rgcatidimpl), + core::mem::transmute_copy(&crequired), + core::mem::transmute_copy(&rgcatidreq), + ) { + Ok(ok__) => { + ppenumclsid.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn GetClassDetails< + Identity: IOPCServerList2_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + clsid: *const windows_core::GUID, + ppszprogid: *mut windows_core::PWSTR, + ppszusertype: *mut windows_core::PWSTR, + ppszverindprogid: *mut windows_core::PWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCServerList2_Impl::GetClassDetails( + this, + core::mem::transmute_copy(&clsid), + core::mem::transmute_copy(&ppszprogid), + core::mem::transmute_copy(&ppszusertype), + core::mem::transmute_copy(&ppszverindprogid), + ) + .into() + } + } + unsafe extern "system" fn CLSIDFromProgID< + Identity: IOPCServerList2_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + szprogid: windows_core::PCWSTR, + clsid: *mut windows_core::GUID, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCServerList2_Impl::CLSIDFromProgID(this, core::mem::transmute(&szprogid)) { + Ok(ok__) => { + clsid.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + Self { + base__: windows_core::IUnknown_Vtbl::new::(), + EnumClassesOfCategories: EnumClassesOfCategories::, + GetClassDetails: GetClassDetails::, + CLSIDFromProgID: CLSIDFromProgID::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +impl windows_core::RuntimeName for IOPCServerList2 {} +windows_core::imp::define_interface!( + IOPCShutdown, + IOPCShutdown_Vtbl, + 0xf31dfde1_07b6_11d2_b2d8_0060083ba1fb +); +windows_core::imp::interface_hierarchy!(IOPCShutdown, windows_core::IUnknown); +impl IOPCShutdown { + pub unsafe fn ShutdownRequest(&self, szreason: P0) -> windows_core::Result<()> + where + P0: windows_core::Param, + { + unsafe { + (windows_core::Interface::vtable(self).ShutdownRequest)( + windows_core::Interface::as_raw(self), + szreason.param().abi(), + ) + .ok() + } + } +} +#[repr(C)] +#[doc(hidden)] +pub struct IOPCShutdown_Vtbl { + pub base__: windows_core::IUnknown_Vtbl, + pub ShutdownRequest: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows_core::PCWSTR, + ) -> windows_core::HRESULT, +} +pub trait IOPCShutdown_Impl: windows_core::IUnknownImpl { + fn ShutdownRequest(&self, szreason: &windows_core::PCWSTR) -> windows_core::Result<()>; +} +impl IOPCShutdown_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn ShutdownRequest< + Identity: IOPCShutdown_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + szreason: windows_core::PCWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCShutdown_Impl::ShutdownRequest(this, core::mem::transmute(&szreason)).into() + } + } + Self { + base__: windows_core::IUnknown_Vtbl::new::(), + ShutdownRequest: ShutdownRequest::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +impl windows_core::RuntimeName for IOPCShutdown {} diff --git a/opc_comn_bindings/src/lib.rs b/opc_comn_bindings/src/lib.rs new file mode 100644 index 0000000..892ac88 --- /dev/null +++ b/opc_comn_bindings/src/lib.rs @@ -0,0 +1,3 @@ +mod bindings; + +pub use bindings::*; diff --git a/opc_da/Cargo.toml b/opc_da/Cargo.toml index 3a6a168..e32de6a 100644 --- a/opc_da/Cargo.toml +++ b/opc_da/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "opc_da" -version = "0.3.0" +version = "0.3.1" edition = "2024" description = "OPC Data Access" repository = "https://github.com/Ronbb/rust_opc" @@ -14,7 +14,8 @@ targets = [] [dependencies] actix = "0.13.5" globset = "0.4.16" -opc_da_bindings = { version = "0.3.0", path = "../opc_da_bindings" } +opc_comn_bindings = { version = "0.3.0", path = "../opc_comn_bindings" } +opc_da_bindings = { version = "0.3.1", path = "../opc_da_bindings" } tokio = { version = "1.46.1", features = ["full", "rt-multi-thread"] } windows = { version = "0.61.3", features = [ "Win32_Foundation", diff --git a/opc_da/src/client/traits/client.rs b/opc_da/src/client/traits/client.rs index 10936fe..ec7495f 100644 --- a/opc_da/src/client/traits/client.rs +++ b/opc_da/src/client/traits/client.rs @@ -21,7 +21,7 @@ pub trait ClientTrait for Client { /// - `IOPCBrowseServerAddressSpace` for browsing the address space pub struct Server { pub(crate) server: opc_da_bindings::IOPCServer, - pub(crate) common: opc_da_bindings::IOPCCommon, + pub(crate) common: opc_comn_bindings::IOPCCommon, pub(crate) connection_point_container: windows::Win32::System::Com::IConnectionPointContainer, pub(crate) item_properties: opc_da_bindings::IOPCItemProperties, pub(crate) server_public_groups: Option, @@ -62,7 +62,7 @@ impl ServerTrait for Server { } impl CommonTrait for Server { - fn interface(&self) -> windows::core::Result<&opc_da_bindings::IOPCCommon> { + fn interface(&self) -> windows::core::Result<&opc_comn_bindings::IOPCCommon> { Ok(&self.common) } } diff --git a/opc_da/src/client/v3/mod.rs b/opc_da/src/client/v3/mod.rs index ccae580..fa485a5 100644 --- a/opc_da/src/client/v3/mod.rs +++ b/opc_da/src/client/v3/mod.rs @@ -6,12 +6,12 @@ use windows::core::Interface as _; use super::{ + ClientTrait, traits::{ AsyncIo2Trait, AsyncIo3Trait, BrowseTrait, CommonTrait, ConnectionPointContainerTrait, GroupStateMgt2Trait, GroupStateMgtTrait, ItemDeadbandMgtTrait, ItemIoTrait, ItemMgtTrait, ItemSamplingMgtTrait, ServerTrait, SyncIo2Trait, SyncIoTrait, }, - ClientTrait, }; /// Client for OPC DA 3.0 servers. @@ -31,7 +31,7 @@ impl ClientTrait for Client { /// - `IOPCItemIO` for direct item read/write operations pub struct Server { pub(crate) server: opc_da_bindings::IOPCServer, - pub(crate) common: opc_da_bindings::IOPCCommon, + pub(crate) common: opc_comn_bindings::IOPCCommon, pub(crate) connection_point_container: windows::Win32::System::Com::IConnectionPointContainer, pub(crate) browse: opc_da_bindings::IOPCBrowse, pub(crate) item_io: opc_da_bindings::IOPCItemIO, @@ -58,7 +58,7 @@ impl ServerTrait for Server { } impl CommonTrait for Server { - fn interface(&self) -> windows::core::Result<&opc_da_bindings::IOPCCommon> { + fn interface(&self) -> windows::core::Result<&opc_comn_bindings::IOPCCommon> { Ok(&self.common) } } diff --git a/opc_da/src/server/com/server.rs b/opc_da/src/server/com/server.rs index 1e404ae..6cf251a 100644 --- a/opc_da/src/server/com/server.rs +++ b/opc_da/src/server/com/server.rs @@ -14,7 +14,7 @@ use super::{ #[windows::core::implement( // implicit implement IUnknown opc_da_bindings::IOPCServer, - opc_da_bindings::IOPCCommon, + opc_comn_bindings::IOPCCommon, windows::Win32::System::Com::IConnectionPointContainer, opc_da_bindings::IOPCItemProperties, opc_da_bindings::IOPCBrowse, @@ -122,7 +122,7 @@ impl opc_da_bindings::IOPCServer_Impl for Server_Impl< // 1.0 N/A // 2.0 required // 3.0 required -impl opc_da_bindings::IOPCCommon_Impl for Server_Impl { +impl opc_comn_bindings::IOPCCommon_Impl for Server_Impl { fn SetLocaleID(&self, locale_id: u32) -> windows::core::Result<()> { self.set_locale_id(locale_id) } diff --git a/opc_da_bindings/.metadata/generate.proj b/opc_da_bindings/.metadata/generate.proj index c0be630..a65f77e 100644 --- a/opc_da_bindings/.metadata/generate.proj +++ b/opc_da_bindings/.metadata/generate.proj @@ -6,8 +6,8 @@ $(CompiledHeadersDir) - - + + @(Headers) OPCDA diff --git a/opc_da_bindings/.metadata/main.cpp b/opc_da_bindings/.metadata/main.cpp index 3b3be26..a78c1e4 100644 --- a/opc_da_bindings/.metadata/main.cpp +++ b/opc_da_bindings/.metadata/main.cpp @@ -1,4 +1,3 @@ #include -#include "opccomn.h" #include "opcda.h" diff --git a/opc_da_bindings/.windows/winmd/OPCDA.winmd b/opc_da_bindings/.windows/winmd/OPCDA.winmd index 9e9554f1a6eb3be9c2c1442135d02b86b46f47f7..8801ed3e4029a3ddfe61aecbcec458c955bcaae6 100644 GIT binary patch literal 19456 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 windows_core::Result<()> { - unsafe { - (windows_core::Interface::vtable(self).SetLocaleID)( - windows_core::Interface::as_raw(self), - dwlcid, - ) - .ok() - } - } - pub unsafe fn GetLocaleID(&self) -> windows_core::Result { - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).GetLocaleID)( - windows_core::Interface::as_raw(self), - &mut result__, - ) - .map(|| result__) - } - } - pub unsafe fn QueryAvailableLocaleIDs( - &self, - pdwcount: *mut u32, - pdwlcid: *mut *mut u32, - ) -> windows_core::Result<()> { - unsafe { - (windows_core::Interface::vtable(self).QueryAvailableLocaleIDs)( - windows_core::Interface::as_raw(self), - pdwcount as _, - pdwlcid as _, - ) - .ok() - } - } - pub unsafe fn GetErrorString( - &self, - dwerror: windows_core::HRESULT, - ) -> windows_core::Result { - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).GetErrorString)( - windows_core::Interface::as_raw(self), - dwerror, - &mut result__, - ) - .map(|| result__) - } - } - pub unsafe fn SetClientName(&self, szname: P0) -> windows_core::Result<()> - where - P0: windows_core::Param, - { - unsafe { - (windows_core::Interface::vtable(self).SetClientName)( - windows_core::Interface::as_raw(self), - szname.param().abi(), - ) - .ok() - } - } -} -#[repr(C)] -#[doc(hidden)] -pub struct IOPCCommon_Vtbl { - pub base__: windows_core::IUnknown_Vtbl, - pub SetLocaleID: - unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT, - pub GetLocaleID: - unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT, - pub QueryAvailableLocaleIDs: unsafe extern "system" fn( - *mut core::ffi::c_void, - *mut u32, - *mut *mut u32, - ) -> windows_core::HRESULT, - pub GetErrorString: unsafe extern "system" fn( - *mut core::ffi::c_void, - windows_core::HRESULT, - *mut windows_core::PWSTR, - ) -> windows_core::HRESULT, - pub SetClientName: unsafe extern "system" fn( - *mut core::ffi::c_void, - windows_core::PCWSTR, - ) -> windows_core::HRESULT, -} -pub trait IOPCCommon_Impl: windows_core::IUnknownImpl { - fn SetLocaleID(&self, dwlcid: u32) -> windows_core::Result<()>; - fn GetLocaleID(&self) -> windows_core::Result; - fn QueryAvailableLocaleIDs( - &self, - pdwcount: *mut u32, - pdwlcid: *mut *mut u32, - ) -> windows_core::Result<()>; - fn GetErrorString( - &self, - dwerror: windows_core::HRESULT, - ) -> windows_core::Result; - fn SetClientName(&self, szname: &windows_core::PCWSTR) -> windows_core::Result<()>; -} -impl IOPCCommon_Vtbl { - pub const fn new() -> Self { - unsafe extern "system" fn SetLocaleID( - this: *mut core::ffi::c_void, - dwlcid: u32, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IOPCCommon_Impl::SetLocaleID(this, core::mem::transmute_copy(&dwlcid)).into() - } - } - unsafe extern "system" fn GetLocaleID( - this: *mut core::ffi::c_void, - pdwlcid: *mut u32, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IOPCCommon_Impl::GetLocaleID(this) { - Ok(ok__) => { - pdwlcid.write(core::mem::transmute(ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn QueryAvailableLocaleIDs< - Identity: IOPCCommon_Impl, - const OFFSET: isize, - >( - this: *mut core::ffi::c_void, - pdwcount: *mut u32, - pdwlcid: *mut *mut u32, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IOPCCommon_Impl::QueryAvailableLocaleIDs( - this, - core::mem::transmute_copy(&pdwcount), - core::mem::transmute_copy(&pdwlcid), - ) - .into() - } - } - unsafe extern "system" fn GetErrorString( - this: *mut core::ffi::c_void, - dwerror: windows_core::HRESULT, - ppstring: *mut windows_core::PWSTR, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IOPCCommon_Impl::GetErrorString(this, core::mem::transmute_copy(&dwerror)) { - Ok(ok__) => { - ppstring.write(core::mem::transmute(ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn SetClientName( - this: *mut core::ffi::c_void, - szname: windows_core::PCWSTR, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IOPCCommon_Impl::SetClientName(this, core::mem::transmute(&szname)).into() - } - } - Self { - base__: windows_core::IUnknown_Vtbl::new::(), - SetLocaleID: SetLocaleID::, - GetLocaleID: GetLocaleID::, - QueryAvailableLocaleIDs: QueryAvailableLocaleIDs::, - GetErrorString: GetErrorString::, - SetClientName: SetClientName::, - } - } - pub fn matches(iid: &windows_core::GUID) -> bool { - iid == &::IID - } -} -impl windows_core::RuntimeName for IOPCCommon {} windows_core::imp::define_interface!( IOPCDataCallback, IOPCDataCallback_Vtbl, @@ -1952,150 +1760,6 @@ impl IOPCDataCallback_Vtbl { } } impl windows_core::RuntimeName for IOPCDataCallback {} -windows_core::imp::define_interface!( - IOPCEnumGUID, - IOPCEnumGUID_Vtbl, - 0x55c382c8_21c7_4e88_96c1_becfb1e3f483 -); -windows_core::imp::interface_hierarchy!(IOPCEnumGUID, windows_core::IUnknown); -impl IOPCEnumGUID { - pub unsafe fn Next( - &self, - rgelt: &mut [windows_core::GUID], - pceltfetched: *mut u32, - ) -> windows_core::Result<()> { - unsafe { - (windows_core::Interface::vtable(self).Next)( - windows_core::Interface::as_raw(self), - rgelt.len().try_into().unwrap(), - core::mem::transmute(rgelt.as_ptr()), - pceltfetched as _, - ) - .ok() - } - } - pub unsafe fn Skip(&self, celt: u32) -> windows_core::Result<()> { - unsafe { - (windows_core::Interface::vtable(self).Skip)( - windows_core::Interface::as_raw(self), - celt, - ) - .ok() - } - } - pub unsafe fn Reset(&self) -> windows_core::Result<()> { - unsafe { - (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self)) - .ok() - } - } - pub unsafe fn Clone(&self) -> windows_core::Result { - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).Clone)( - windows_core::Interface::as_raw(self), - &mut result__, - ) - .and_then(|| windows_core::Type::from_abi(result__)) - } - } -} -#[repr(C)] -#[doc(hidden)] -pub struct IOPCEnumGUID_Vtbl { - pub base__: windows_core::IUnknown_Vtbl, - pub Next: unsafe extern "system" fn( - *mut core::ffi::c_void, - u32, - *mut windows_core::GUID, - *mut u32, - ) -> windows_core::HRESULT, - pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT, - pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT, - pub Clone: unsafe extern "system" fn( - *mut core::ffi::c_void, - *mut *mut core::ffi::c_void, - ) -> windows_core::HRESULT, -} -pub trait IOPCEnumGUID_Impl: windows_core::IUnknownImpl { - fn Next( - &self, - celt: u32, - rgelt: *mut windows_core::GUID, - pceltfetched: *mut u32, - ) -> windows_core::Result<()>; - fn Skip(&self, celt: u32) -> windows_core::Result<()>; - fn Reset(&self) -> windows_core::Result<()>; - fn Clone(&self) -> windows_core::Result; -} -impl IOPCEnumGUID_Vtbl { - pub const fn new() -> Self { - unsafe extern "system" fn Next( - this: *mut core::ffi::c_void, - celt: u32, - rgelt: *mut windows_core::GUID, - pceltfetched: *mut u32, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IOPCEnumGUID_Impl::Next( - this, - core::mem::transmute_copy(&celt), - core::mem::transmute_copy(&rgelt), - core::mem::transmute_copy(&pceltfetched), - ) - .into() - } - } - unsafe extern "system" fn Skip( - this: *mut core::ffi::c_void, - celt: u32, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IOPCEnumGUID_Impl::Skip(this, core::mem::transmute_copy(&celt)).into() - } - } - unsafe extern "system" fn Reset( - this: *mut core::ffi::c_void, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IOPCEnumGUID_Impl::Reset(this).into() - } - } - unsafe extern "system" fn Clone( - this: *mut core::ffi::c_void, - ppenum: *mut *mut core::ffi::c_void, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IOPCEnumGUID_Impl::Clone(this) { - Ok(ok__) => { - ppenum.write(core::mem::transmute(ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - Self { - base__: windows_core::IUnknown_Vtbl::new::(), - Next: Next::, - Skip: Skip::, - Reset: Reset::, - Clone: Clone::, - } - } - pub fn matches(iid: &windows_core::GUID) -> bool { - iid == &::IID - } -} -impl windows_core::RuntimeName for IOPCEnumGUID {} windows_core::imp::define_interface!( IOPCGroupStateMgt, IOPCGroupStateMgt_Vtbl, @@ -4160,384 +3824,6 @@ impl IOPCServer_Vtbl { } } impl windows_core::RuntimeName for IOPCServer {} -windows_core::imp::define_interface!( - IOPCServerList, - IOPCServerList_Vtbl, - 0x13486d50_4821_11d2_a494_3cb306c10000 -); -windows_core::imp::interface_hierarchy!(IOPCServerList, windows_core::IUnknown); -impl IOPCServerList { - pub unsafe fn EnumClassesOfCategories( - &self, - rgcatidimpl: &[windows_core::GUID], - rgcatidreq: &[windows_core::GUID], - ) -> windows_core::Result { - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).EnumClassesOfCategories)( - windows_core::Interface::as_raw(self), - rgcatidimpl.len().try_into().unwrap(), - core::mem::transmute(rgcatidimpl.as_ptr()), - rgcatidreq.len().try_into().unwrap(), - core::mem::transmute(rgcatidreq.as_ptr()), - &mut result__, - ) - .and_then(|| windows_core::Type::from_abi(result__)) - } - } - pub unsafe fn GetClassDetails( - &self, - clsid: *const windows_core::GUID, - ppszprogid: *mut windows_core::PWSTR, - ppszusertype: *mut windows_core::PWSTR, - ) -> windows_core::Result<()> { - unsafe { - (windows_core::Interface::vtable(self).GetClassDetails)( - windows_core::Interface::as_raw(self), - clsid, - ppszprogid as _, - ppszusertype as _, - ) - .ok() - } - } - pub unsafe fn CLSIDFromProgID( - &self, - szprogid: P0, - ) -> windows_core::Result - where - P0: windows_core::Param, - { - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).CLSIDFromProgID)( - windows_core::Interface::as_raw(self), - szprogid.param().abi(), - &mut result__, - ) - .map(|| result__) - } - } -} -#[repr(C)] -#[doc(hidden)] -pub struct IOPCServerList_Vtbl { - pub base__: windows_core::IUnknown_Vtbl, - pub EnumClassesOfCategories: unsafe extern "system" fn( - *mut core::ffi::c_void, - u32, - *const windows_core::GUID, - u32, - *const windows_core::GUID, - *mut *mut core::ffi::c_void, - ) -> windows_core::HRESULT, - pub GetClassDetails: unsafe extern "system" fn( - *mut core::ffi::c_void, - *const windows_core::GUID, - *mut windows_core::PWSTR, - *mut windows_core::PWSTR, - ) -> windows_core::HRESULT, - pub CLSIDFromProgID: unsafe extern "system" fn( - *mut core::ffi::c_void, - windows_core::PCWSTR, - *mut windows_core::GUID, - ) -> windows_core::HRESULT, -} -pub trait IOPCServerList_Impl: windows_core::IUnknownImpl { - fn EnumClassesOfCategories( - &self, - cimplemented: u32, - rgcatidimpl: *const windows_core::GUID, - crequired: u32, - rgcatidreq: *const windows_core::GUID, - ) -> windows_core::Result; - fn GetClassDetails( - &self, - clsid: *const windows_core::GUID, - ppszprogid: *mut windows_core::PWSTR, - ppszusertype: *mut windows_core::PWSTR, - ) -> windows_core::Result<()>; - fn CLSIDFromProgID( - &self, - szprogid: &windows_core::PCWSTR, - ) -> windows_core::Result; -} -impl IOPCServerList_Vtbl { - pub const fn new() -> Self { - unsafe extern "system" fn EnumClassesOfCategories< - Identity: IOPCServerList_Impl, - const OFFSET: isize, - >( - this: *mut core::ffi::c_void, - cimplemented: u32, - rgcatidimpl: *const windows_core::GUID, - crequired: u32, - rgcatidreq: *const windows_core::GUID, - ppenumclsid: *mut *mut core::ffi::c_void, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IOPCServerList_Impl::EnumClassesOfCategories( - this, - core::mem::transmute_copy(&cimplemented), - core::mem::transmute_copy(&rgcatidimpl), - core::mem::transmute_copy(&crequired), - core::mem::transmute_copy(&rgcatidreq), - ) { - Ok(ok__) => { - ppenumclsid.write(core::mem::transmute(ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn GetClassDetails< - Identity: IOPCServerList_Impl, - const OFFSET: isize, - >( - this: *mut core::ffi::c_void, - clsid: *const windows_core::GUID, - ppszprogid: *mut windows_core::PWSTR, - ppszusertype: *mut windows_core::PWSTR, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IOPCServerList_Impl::GetClassDetails( - this, - core::mem::transmute_copy(&clsid), - core::mem::transmute_copy(&ppszprogid), - core::mem::transmute_copy(&ppszusertype), - ) - .into() - } - } - unsafe extern "system" fn CLSIDFromProgID< - Identity: IOPCServerList_Impl, - const OFFSET: isize, - >( - this: *mut core::ffi::c_void, - szprogid: windows_core::PCWSTR, - clsid: *mut windows_core::GUID, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IOPCServerList_Impl::CLSIDFromProgID(this, core::mem::transmute(&szprogid)) { - Ok(ok__) => { - clsid.write(core::mem::transmute(ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - Self { - base__: windows_core::IUnknown_Vtbl::new::(), - EnumClassesOfCategories: EnumClassesOfCategories::, - GetClassDetails: GetClassDetails::, - CLSIDFromProgID: CLSIDFromProgID::, - } - } - pub fn matches(iid: &windows_core::GUID) -> bool { - iid == &::IID - } -} -impl windows_core::RuntimeName for IOPCServerList {} -windows_core::imp::define_interface!( - IOPCServerList2, - IOPCServerList2_Vtbl, - 0x9dd0b56c_ad9e_43ee_8305_487f3188bf7a -); -windows_core::imp::interface_hierarchy!(IOPCServerList2, windows_core::IUnknown); -impl IOPCServerList2 { - pub unsafe fn EnumClassesOfCategories( - &self, - rgcatidimpl: &[windows_core::GUID], - rgcatidreq: &[windows_core::GUID], - ) -> windows_core::Result { - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).EnumClassesOfCategories)( - windows_core::Interface::as_raw(self), - rgcatidimpl.len().try_into().unwrap(), - core::mem::transmute(rgcatidimpl.as_ptr()), - rgcatidreq.len().try_into().unwrap(), - core::mem::transmute(rgcatidreq.as_ptr()), - &mut result__, - ) - .and_then(|| windows_core::Type::from_abi(result__)) - } - } - pub unsafe fn GetClassDetails( - &self, - clsid: *const windows_core::GUID, - ppszprogid: *mut windows_core::PWSTR, - ppszusertype: *mut windows_core::PWSTR, - ppszverindprogid: *mut windows_core::PWSTR, - ) -> windows_core::Result<()> { - unsafe { - (windows_core::Interface::vtable(self).GetClassDetails)( - windows_core::Interface::as_raw(self), - clsid, - ppszprogid as _, - ppszusertype as _, - ppszverindprogid as _, - ) - .ok() - } - } - pub unsafe fn CLSIDFromProgID( - &self, - szprogid: P0, - ) -> windows_core::Result - where - P0: windows_core::Param, - { - unsafe { - let mut result__ = core::mem::zeroed(); - (windows_core::Interface::vtable(self).CLSIDFromProgID)( - windows_core::Interface::as_raw(self), - szprogid.param().abi(), - &mut result__, - ) - .map(|| result__) - } - } -} -#[repr(C)] -#[doc(hidden)] -pub struct IOPCServerList2_Vtbl { - pub base__: windows_core::IUnknown_Vtbl, - pub EnumClassesOfCategories: unsafe extern "system" fn( - *mut core::ffi::c_void, - u32, - *const windows_core::GUID, - u32, - *const windows_core::GUID, - *mut *mut core::ffi::c_void, - ) -> windows_core::HRESULT, - pub GetClassDetails: unsafe extern "system" fn( - *mut core::ffi::c_void, - *const windows_core::GUID, - *mut windows_core::PWSTR, - *mut windows_core::PWSTR, - *mut windows_core::PWSTR, - ) -> windows_core::HRESULT, - pub CLSIDFromProgID: unsafe extern "system" fn( - *mut core::ffi::c_void, - windows_core::PCWSTR, - *mut windows_core::GUID, - ) -> windows_core::HRESULT, -} -pub trait IOPCServerList2_Impl: windows_core::IUnknownImpl { - fn EnumClassesOfCategories( - &self, - cimplemented: u32, - rgcatidimpl: *const windows_core::GUID, - crequired: u32, - rgcatidreq: *const windows_core::GUID, - ) -> windows_core::Result; - fn GetClassDetails( - &self, - clsid: *const windows_core::GUID, - ppszprogid: *mut windows_core::PWSTR, - ppszusertype: *mut windows_core::PWSTR, - ppszverindprogid: *mut windows_core::PWSTR, - ) -> windows_core::Result<()>; - fn CLSIDFromProgID( - &self, - szprogid: &windows_core::PCWSTR, - ) -> windows_core::Result; -} -impl IOPCServerList2_Vtbl { - pub const fn new() -> Self { - unsafe extern "system" fn EnumClassesOfCategories< - Identity: IOPCServerList2_Impl, - const OFFSET: isize, - >( - this: *mut core::ffi::c_void, - cimplemented: u32, - rgcatidimpl: *const windows_core::GUID, - crequired: u32, - rgcatidreq: *const windows_core::GUID, - ppenumclsid: *mut *mut core::ffi::c_void, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IOPCServerList2_Impl::EnumClassesOfCategories( - this, - core::mem::transmute_copy(&cimplemented), - core::mem::transmute_copy(&rgcatidimpl), - core::mem::transmute_copy(&crequired), - core::mem::transmute_copy(&rgcatidreq), - ) { - Ok(ok__) => { - ppenumclsid.write(core::mem::transmute(ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - unsafe extern "system" fn GetClassDetails< - Identity: IOPCServerList2_Impl, - const OFFSET: isize, - >( - this: *mut core::ffi::c_void, - clsid: *const windows_core::GUID, - ppszprogid: *mut windows_core::PWSTR, - ppszusertype: *mut windows_core::PWSTR, - ppszverindprogid: *mut windows_core::PWSTR, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IOPCServerList2_Impl::GetClassDetails( - this, - core::mem::transmute_copy(&clsid), - core::mem::transmute_copy(&ppszprogid), - core::mem::transmute_copy(&ppszusertype), - core::mem::transmute_copy(&ppszverindprogid), - ) - .into() - } - } - unsafe extern "system" fn CLSIDFromProgID< - Identity: IOPCServerList2_Impl, - const OFFSET: isize, - >( - this: *mut core::ffi::c_void, - szprogid: windows_core::PCWSTR, - clsid: *mut windows_core::GUID, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - match IOPCServerList2_Impl::CLSIDFromProgID(this, core::mem::transmute(&szprogid)) { - Ok(ok__) => { - clsid.write(core::mem::transmute(ok__)); - windows_core::HRESULT(0) - } - Err(err) => err.into(), - } - } - } - Self { - base__: windows_core::IUnknown_Vtbl::new::(), - EnumClassesOfCategories: EnumClassesOfCategories::, - GetClassDetails: GetClassDetails::, - CLSIDFromProgID: CLSIDFromProgID::, - } - } - pub fn matches(iid: &windows_core::GUID) -> bool { - iid == &::IID - } -} -impl windows_core::RuntimeName for IOPCServerList2 {} windows_core::imp::define_interface!( IOPCServerPublicGroups, IOPCServerPublicGroups_Vtbl, @@ -4664,63 +3950,6 @@ impl IOPCServerPublicGroups_Vtbl { } } impl windows_core::RuntimeName for IOPCServerPublicGroups {} -windows_core::imp::define_interface!( - IOPCShutdown, - IOPCShutdown_Vtbl, - 0xf31dfde1_07b6_11d2_b2d8_0060083ba1fb -); -windows_core::imp::interface_hierarchy!(IOPCShutdown, windows_core::IUnknown); -impl IOPCShutdown { - pub unsafe fn ShutdownRequest(&self, szreason: P0) -> windows_core::Result<()> - where - P0: windows_core::Param, - { - unsafe { - (windows_core::Interface::vtable(self).ShutdownRequest)( - windows_core::Interface::as_raw(self), - szreason.param().abi(), - ) - .ok() - } - } -} -#[repr(C)] -#[doc(hidden)] -pub struct IOPCShutdown_Vtbl { - pub base__: windows_core::IUnknown_Vtbl, - pub ShutdownRequest: unsafe extern "system" fn( - *mut core::ffi::c_void, - windows_core::PCWSTR, - ) -> windows_core::HRESULT, -} -pub trait IOPCShutdown_Impl: windows_core::IUnknownImpl { - fn ShutdownRequest(&self, szreason: &windows_core::PCWSTR) -> windows_core::Result<()>; -} -impl IOPCShutdown_Vtbl { - pub const fn new() -> Self { - unsafe extern "system" fn ShutdownRequest< - Identity: IOPCShutdown_Impl, - const OFFSET: isize, - >( - this: *mut core::ffi::c_void, - szreason: windows_core::PCWSTR, - ) -> windows_core::HRESULT { - unsafe { - let this: &Identity = - &*((this as *const *const ()).offset(OFFSET) as *const Identity); - IOPCShutdown_Impl::ShutdownRequest(this, core::mem::transmute(&szreason)).into() - } - } - Self { - base__: windows_core::IUnknown_Vtbl::new::(), - ShutdownRequest: ShutdownRequest::, - } - } - pub fn matches(iid: &windows_core::GUID) -> bool { - iid == &::IID - } -} -impl windows_core::RuntimeName for IOPCShutdown {} windows_core::imp::define_interface!( IOPCSyncIO, IOPCSyncIO_Vtbl, diff --git a/opc_hda_bindings/.gitignore b/opc_hda_bindings/.gitignore new file mode 100644 index 0000000..ea8c4bf --- /dev/null +++ b/opc_hda_bindings/.gitignore @@ -0,0 +1 @@ +/target diff --git a/opc_hda_bindings/.metadata/.gitignore b/opc_hda_bindings/.metadata/.gitignore new file mode 100644 index 0000000..1746e32 --- /dev/null +++ b/opc_hda_bindings/.metadata/.gitignore @@ -0,0 +1,2 @@ +bin +obj diff --git a/opc_hda_bindings/.metadata/generate.proj b/opc_hda_bindings/.metadata/generate.proj new file mode 100644 index 0000000..12daebf --- /dev/null +++ b/opc_hda_bindings/.metadata/generate.proj @@ -0,0 +1,17 @@ + + + + ../.windows/winmd/OPCHDA.winmd + 0.0.0.1 + $(CompiledHeadersDir) + + + + + + @(Headers) + OPCHDA + true + + + \ No newline at end of file diff --git a/opc_hda_bindings/.metadata/main.cpp b/opc_hda_bindings/.metadata/main.cpp new file mode 100644 index 0000000..f183697 --- /dev/null +++ b/opc_hda_bindings/.metadata/main.cpp @@ -0,0 +1,3 @@ +#include + +#include "opchda.h" diff --git a/opc_hda_bindings/.metadata/opchda.idl b/opc_hda_bindings/.metadata/opchda.idl new file mode 100644 index 0000000..83d0110 --- /dev/null +++ b/opc_hda_bindings/.metadata/opchda.idl @@ -0,0 +1,881 @@ +//============================================================================== +// TITLE: opchda.idl +// +// CONTENTS: +// +// Interface declarations for the OPC Historial Data Access specifications. +// +// (c) Copyright 1999-2003 The OPC Foundation +// ALL RIGHTS RESERVED. +// +// DISCLAIMER: +// This code is provided by the OPC Foundation solely to assist in +// understanding and use of the appropriate OPC Specification(s) and may be +// used as set forth in the License Grant section of the OPC Specification. +// This code is provided as-is and without warranty or support of any sort +// and is subject to the Warranty and Liability Disclaimers which appear +// in the printed OPC Specification. +// +// MODIFICATION LOG: +// +// Date By Notes +// ---------- --- ----- +// 2001/01/26 OPC Made revisions for version 1.1 +// 2003/01/06 RSA Fixed formatting to comply with coding guidelines. +// + +import "oaidl.idl"; + +//============================================================================== +// Category ID declarations (defined as interfaces to ensure they show up in the typelib). + +[uuid(7DE5B060-E089-11d2-A5E6-000086339399)] interface CATID_OPCHDAServer10 : IUnknown {} + +cpp_quote("#define CATID_OPCHDAServer10 IID_CATID_OPCHDAServer10") + +//============================================================================== +// Structures, Typedefs and Enumerations. + +typedef enum tagOPCHDA_SERVERSTATUS +{ + OPCHDA_UP =1, + OPCHDA_DOWN, + OPCHDA_INDETERMINATE +} +OPCHDA_SERVERSTATUS; + +typedef enum tagOPCHDA_BROWSEDIRECTION +{ + OPCHDA_BROWSE_UP =1, + OPCHDA_BROWSE_DOWN, + OPCHDA_BROWSE_DIRECT +} +OPCHDA_BROWSEDIRECTION; + +typedef enum tagOPCHDA_BROWSETYPE +{ + OPCHDA_BRANCH =1, + OPCHDA_LEAF, + OPCHDA_FLAT, + OPCHDA_ITEMS +} +OPCHDA_BROWSETYPE; + +typedef enum tagOPCHDA_ANNOTATIONCAPABILITIES +{ + OPCHDA_READANNOTATIONCAP = 0x01, + OPCHDA_INSERTANNOTATIONCAP = 0x02 +} +OPCHDA_ANNOTATIONCAPABILITIES; + + +typedef enum tagOPCHDA_UPDATECAPABILITIES +{ + OPCHDA_INSERTCAP = 0x01, + OPCHDA_REPLACECAP = 0x02, + OPCHDA_INSERTREPLACECAP = 0x04, + OPCHDA_DELETERAWCAP = 0x08, + OPCHDA_DELETEATTIMECAP = 0x10 +} +OPCHDA_UPDATECAPABILITIES; + +typedef enum tagOPCHDA_OPERATORCODES +{ + OPCHDA_EQUAL =1, + OPCHDA_LESS, + OPCHDA_LESSEQUAL, + OPCHDA_GREATER, + OPCHDA_GREATEREQUAL, + OPCHDA_NOTEQUAL +} +OPCHDA_OPERATORCODES; + +typedef enum tagOPCHDA_EDITTYPE +{ + OPCHDA_INSERT = 1, + OPCHDA_REPLACE, + OPCHDA_INSERTREPLACE, + OPCHDA_DELETE +} +OPCHDA_EDITTYPE; + +typedef enum tagOPCHDA_AGGREGATE +{ + OPCHDA_NOAGGREGATE = 0, + OPCHDA_INTERPOLATIVE, + OPCHDA_TOTAL, + OPCHDA_AVERAGE, + OPCHDA_TIMEAVERAGE, + OPCHDA_COUNT, + OPCHDA_STDEV, + OPCHDA_MINIMUMACTUALTIME, + OPCHDA_MINIMUM, + OPCHDA_MAXIMUMACTUALTIME, + OPCHDA_MAXIMUM, + OPCHDA_START, + OPCHDA_END, + OPCHDA_DELTA, + OPCHDA_REGSLOPE, + OPCHDA_REGCONST, + OPCHDA_REGDEV, + OPCHDA_VARIANCE, + OPCHDA_RANGE, + OPCHDA_DURATIONGOOD, + OPCHDA_DURATIONBAD, + OPCHDA_PERCENTGOOD, + OPCHDA_PERCENTBAD, + OPCHDA_WORSTQUALITY, + OPCHDA_ANNOTATIONS +} +OPCHDA_AGGREGATE; + +typedef DWORD OPCHANDLE; + +typedef struct tagOPCHDA_ANNOTATION +{ + OPCHANDLE hClient; + DWORD dwNumValues; + [size_is (dwNumValues)] FILETIME* ftTimeStamps; + [size_is (dwNumValues), string] LPWSTR* szAnnotation; + [size_is (dwNumValues)] FILETIME* ftAnnotationTime; + [size_is (dwNumValues), string] LPWSTR* szUser; +} +OPCHDA_ANNOTATION; + +typedef struct tagOPCHDA_MODIFIEDITEM +{ + OPCHANDLE hClient; + DWORD dwCount; + [size_is(dwCount)] FILETIME* pftTimeStamps; + [size_is(dwCount)] DWORD* pdwQualities; + [size_is(dwCount)] VARIANT* pvDataValues; + [size_is(dwCount)] FILETIME* pftModificationTime; + [size_is(dwCount)] OPCHDA_EDITTYPE* pEditType; + [size_is(dwCount)] LPWSTR* szUser; +} +OPCHDA_MODIFIEDITEM; + +typedef struct tagOPCHDA_ATTRIBUTE +{ + OPCHANDLE hClient; + DWORD dwNumValues; + DWORD dwAttributeID; + [size_is (dwNumValues)] FILETIME* ftTimeStamps; + [size_is (dwNumValues)] VARIANT* vAttributeValues; +} +OPCHDA_ATTRIBUTE; + +typedef struct tagOPCHDA_TIME +{ + BOOL bString; + [string] LPWSTR szTime; + FILETIME ftTime; +} +OPCHDA_TIME; + +typedef struct tagOPCHDA_ITEM +{ + OPCHANDLE hClient; + DWORD haAggregate; + DWORD dwCount; + [size_is(dwCount)] FILETIME* pftTimeStamps; + [size_is(dwCount)] DWORD* pdwQualities; + [size_is(dwCount)] VARIANT* pvDataValues; +} +OPCHDA_ITEM; + +//============================================================================== +// IOPCHDA_Browser + +[ + object, + uuid(1F1217B1-DEE0-11d2-A5E5-000086339399), + pointer_default(unique) +] +interface IOPCHDA_Browser : IUnknown +{ + HRESULT GetEnum( + [in] OPCHDA_BROWSETYPE dwBrowseType, + [out] LPENUMSTRING* ppIEnumString + ); + + HRESULT ChangeBrowsePosition( + [in] OPCHDA_BROWSEDIRECTION dwBrowseDirection, + [in, string] LPCWSTR szString + ); + + HRESULT GetItemID( + [in, string] LPCWSTR szNode, + [out, string] LPWSTR* pszItemID + ); + + + HRESULT GetBranchPosition( + [out, string] LPWSTR* pszBranchPos + ); +} + +//============================================================================== +// IOPCHDA_Server + +[ + object, + uuid(1F1217B0-DEE0-11d2-A5E5-000086339399), + pointer_default(unique) +] +interface IOPCHDA_Server : IUnknown +{ + HRESULT GetItemAttributes( + [out] DWORD* pdwCount, + [out, size_is(,*pdwCount)] DWORD** ppdwAttrID, + [out, size_is(,*pdwCount),string] LPWSTR** ppszAttrName, + [out, size_is(,*pdwCount),string] LPWSTR** ppszAttrDesc, + [out, size_is(,*pdwCount)] VARTYPE** ppvtAttrDataType + ); + + HRESULT GetAggregates( + [out] DWORD* pdwCount, + [out, size_is(,*pdwCount)] DWORD** ppdwAggrID, + [out, size_is(,*pdwCount), string] LPWSTR** ppszAggrName, + [out, size_is(,*pdwCount), string] LPWSTR** ppszAggrDesc + ); + + HRESULT GetHistorianStatus( + [out] OPCHDA_SERVERSTATUS* pwStatus, + [out] FILETIME** pftCurrentTime, + [out] FILETIME** pftStartTime, + [out] WORD* pwMajorVersion, + [out] WORD* pwMinorVersion, + [out] WORD* pwBuildNumber, + [out] DWORD* pdwMaxReturnValues, + [out, string] LPWSTR* ppszStatusString, + [out, string] LPWSTR* ppszVendorInfo + ); + + HRESULT GetItemHandles( + [in] DWORD dwCount, + [in, size_is(dwCount)] LPWSTR* pszItemID, + [in, size_is(dwCount)] OPCHANDLE* phClient, + [out, size_is(,dwCount)] OPCHANDLE** pphServer, + [out, size_is(,dwCount)] HRESULT** ppErrors + ); + + HRESULT ReleaseItemHandles( + [in] DWORD dwCount, + [in, size_is(dwCount)] OPCHANDLE* phServer, + [out, size_is(,dwCount)] HRESULT** ppErrors + ); + + HRESULT ValidateItemIDs( + [in] DWORD dwCount, + [in, size_is(dwCount)] LPWSTR* pszItemID, + [out, size_is(,dwCount)] HRESULT** ppErrors + ); + + HRESULT CreateBrowse( + [in] DWORD dwCount, + [in, size_is(dwCount)] DWORD* pdwAttrID, + [in, size_is(dwCount)] OPCHDA_OPERATORCODES* pOperator, + [in, size_is(dwCount)] VARIANT* vFilter, + [out] IOPCHDA_Browser** pphBrowser, + [out, size_is(,dwCount)] HRESULT** ppErrors + ); +} + +//============================================================================== +// IOPCHDA_SyncRead + +[ + object, + uuid(1F1217B2-DEE0-11d2-A5E5-000086339399), + pointer_default(unique) +] +interface IOPCHDA_SyncRead: IUnknown +{ + HRESULT ReadRaw( + [in, out] OPCHDA_TIME* htStartTime, + [in, out] OPCHDA_TIME* htEndTime, + [in] DWORD dwNumValues, + [in] BOOL bBounds, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [out, size_is(,dwNumItems)] OPCHDA_ITEM** ppItemValues, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT ReadProcessed( + [in, out] OPCHDA_TIME* htStartTime, + [in, out] OPCHDA_TIME* htEndTime, + [in] FILETIME ftResampleInterval, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [in, size_is(dwNumItems)] DWORD* haAggregate, + [out, size_is(,dwNumItems)] OPCHDA_ITEM** ppItemValues, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT ReadAtTime( + [in] DWORD dwNumTimeStamps, + [in, size_is(dwNumTimeStamps)] FILETIME* ftTimeStamps, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [out, size_is(,dwNumItems)] OPCHDA_ITEM** ppItemValues, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT ReadModified( + [in, out] OPCHDA_TIME* htStartTime, + [in, out] OPCHDA_TIME* htEndTime, + [in] DWORD dwNumValues, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [out, size_is(,dwNumItems)] OPCHDA_MODIFIEDITEM** ppItemValues, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT ReadAttribute( + [in, out] OPCHDA_TIME* htStartTime, + [in, out] OPCHDA_TIME* htEndTime, + [in] OPCHANDLE hServer, + [in] DWORD dwNumAttributes, + [in, size_is(dwNumAttributes)] DWORD* pdwAttributeIDs, + [out, size_is(,dwNumAttributes)] OPCHDA_ATTRIBUTE** ppAttributeValues, + [out, size_is(,dwNumAttributes)] HRESULT** ppErrors + ); +} + +//============================================================================== +// IOPCHDA_SyncUpdate + +[ + object, + uuid(1F1217B3-DEE0-11d2-A5E5-000086339399), + pointer_default(unique) +] +interface IOPCHDA_SyncUpdate : IUnknown +{ + HRESULT QueryCapabilities( + [out] OPCHDA_UPDATECAPABILITIES* pCapabilities + ); + + HRESULT Insert( + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [in, size_is(dwNumItems)] FILETIME* ftTimeStamps, + [in, size_is(dwNumItems)] VARIANT* vDataValues, + [in, size_is(dwNumItems)] DWORD* pdwQualities, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT Replace( + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [in, size_is(dwNumItems)] FILETIME* ftTimeStamps, + [in, size_is(dwNumItems)] VARIANT* vDataValues, + [in, size_is(dwNumItems)] DWORD* pdwQualities, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT InsertReplace( + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [in, size_is(dwNumItems)] FILETIME* ftTimeStamps, + [in, size_is(dwNumItems)] VARIANT* vDataValues, + [in, size_is(dwNumItems)] DWORD* pdwQualities, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT DeleteRaw( + [in, out] OPCHDA_TIME* htStartTime, + [in, out] OPCHDA_TIME* htEndTime, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT DeleteAtTime( + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [in, size_is(dwNumItems)] FILETIME* ftTimeStamps, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); +} + +//============================================================================== +// IOPCHDA_SyncAnnotations + +[ + object, + uuid(1F1217B4-DEE0-11d2-A5E5-000086339399), + pointer_default(unique) +] +interface IOPCHDA_SyncAnnotations : IUnknown +{ + HRESULT QueryCapabilities( + [out] OPCHDA_ANNOTATIONCAPABILITIES* pCapabilities + ); + + HRESULT Read( + [in, out] OPCHDA_TIME* htStartTime, + [in, out] OPCHDA_TIME* htEndTime, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [out, size_is(,dwNumItems)] OPCHDA_ANNOTATION** ppAnnotationValues, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT Insert( + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [in, size_is(dwNumItems)] FILETIME* ftTimeStamps, + [in, size_is(dwNumItems)] OPCHDA_ANNOTATION* pAnnotationValues, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); +} + +//============================================================================== +// IOPCHDA_AsyncRead + +[ + object, + uuid(1F1217B5-DEE0-11d2-A5E5-000086339399), + pointer_default(unique) +] +interface IOPCHDA_AsyncRead : IUnknown +{ + HRESULT ReadRaw( + [in] DWORD dwTransactionID, + [in, out] OPCHDA_TIME* htStartTime, + [in, out] OPCHDA_TIME* htEndTime, + [in] DWORD dwNumValues, + [in] BOOL bBounds, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [out] DWORD* pdwCancelID, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT AdviseRaw( + [in] DWORD dwTransactionID, + [in, out] OPCHDA_TIME* htStartTime, + [in] FILETIME ftUpdateInterval, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [out] DWORD* pdwCancelID, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT ReadProcessed( + [in] DWORD dwTransactionID, + [in, out] OPCHDA_TIME* htStartTime, + [in, out] OPCHDA_TIME* htEndTime, + [in] FILETIME ftResampleInterval, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [in, size_is(dwNumItems)] DWORD* haAggregate, + [out] DWORD* pdwCancelID, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT AdviseProcessed( + [in] DWORD dwTransactionID, + [in, out] OPCHDA_TIME* htStartTime, + [in] FILETIME ftResampleInterval, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [in, size_is(dwNumItems)] DWORD* haAggregate, + [in] DWORD dwNumIntervals, + [out] DWORD* pdwCancelID, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT ReadAtTime( + [in] DWORD dwTransactionID, + [in] DWORD dwNumTimeStamps, + [in, size_is(dwNumTimeStamps)] FILETIME* ftTimeStamps, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [out] DWORD* pdwCancelID, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT ReadModified( + [in] DWORD dwTransactionID, + [in, out] OPCHDA_TIME* htStartTime, + [in, out] OPCHDA_TIME* htEndTime, + [in] DWORD dwNumValues, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [out] DWORD* pdwCancelID, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT ReadAttribute( + [in] DWORD dwTransactionID, + [in, out] OPCHDA_TIME* htStartTime, + [in, out] OPCHDA_TIME* htEndTime, + [in] OPCHANDLE hServer, + [in] DWORD dwNumAttributes, + [in, size_is(dwNumAttributes)] DWORD* dwAttributeIDs, + [out] DWORD* pdwCancelID, + [out, size_is(,dwNumAttributes)] HRESULT** ppErrors + ); + + HRESULT Cancel( + [in] DWORD dwCancelID + ); +} + +//============================================================================== +// IOPCHDA_AsyncUpdate + +[ + object, + uuid(1F1217B6-DEE0-11d2-A5E5-000086339399), + pointer_default(unique) +] +interface IOPCHDA_AsyncUpdate : IUnknown +{ + HRESULT QueryCapabilities( + [out] OPCHDA_UPDATECAPABILITIES* pCapabilities + ); + + HRESULT Insert( + [in] DWORD dwTransactionID, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [in, size_is(dwNumItems)] FILETIME* ftTimeStamps, + [in, size_is(dwNumItems)] VARIANT* vDataValues, + [in, size_is(dwNumItems)] DWORD* pdwQualities, + [out] DWORD* pdwCancelID, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT Replace( + [in] DWORD dwTransactionID, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [in, size_is(dwNumItems)] FILETIME* ftTimeStamps, + [in, size_is(dwNumItems)] VARIANT* vDataValues, + [in, size_is(dwNumItems)] DWORD* pdwQualities, + [out] DWORD* pdwCancelID, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT InsertReplace( + [in] DWORD dwTransactionID, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [in, size_is(dwNumItems)] FILETIME* ftTimeStamps, + [in, size_is(dwNumItems)] VARIANT* vDataValues, + [in, size_is(dwNumItems)] DWORD* pdwQualities, + [out] DWORD* pdwCancelID, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT DeleteRaw( + [in] DWORD dwTransactionID, + [in,out] OPCHDA_TIME* htStartTime, + [in, out] OPCHDA_TIME* htEndTime, + [in] DWORD dwNumItems, + [in, size_is (dwNumItems)] OPCHANDLE* phServer, + [out] DWORD* pdwCancelID, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT DeleteAtTime( + [in] DWORD dwTransactionID, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [in, size_is(dwNumItems)] FILETIME* ftTimeStamps, + [out] DWORD* pdwCancelID, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT Cancel( + [in] DWORD dwCancelID + ); +} + +//============================================================================== +// IOPCHDA_AsyncAnnotations + +[ + object, + uuid(1F1217B7-DEE0-11d2-A5E5-000086339399), + pointer_default(unique) +] +interface IOPCHDA_AsyncAnnotations: IUnknown +{ + HRESULT QueryCapabilities( + [out] OPCHDA_ANNOTATIONCAPABILITIES* pCapabilities + ); + + HRESULT Read( + [in] DWORD dwTransactionID, + [in, out] OPCHDA_TIME* htStartTime, + [in, out] OPCHDA_TIME* htEndTime, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [out] DWORD* pdwCancelID, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT Insert( + [in] DWORD dwTransactionID, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [in, size_is(dwNumItems)] FILETIME* ftTimeStamps, + [in, size_is(dwNumItems)] OPCHDA_ANNOTATION* pAnnotationValues, + [out] DWORD* pdwCancelID, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT Cancel( + [in] DWORD dwCancelID + ); +} + +//============================================================================== +// IOPCHDA_Playback + +[ + object, + uuid(1F1217B8-DEE0-11d2-A5E5-000086339399), + pointer_default(unique) +] +interface IOPCHDA_Playback : IUnknown +{ + HRESULT ReadRawWithUpdate( + [in] DWORD dwTransactionID, + [in, out] OPCHDA_TIME* htStartTime, + [in, out] OPCHDA_TIME* htEndTime, + [in] DWORD dwNumValues, + [in] FILETIME ftUpdateDuration, + [in] FILETIME ftUpdateInterval, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [out] DWORD* pdwCancelID, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT ReadProcessedWithUpdate( + [in] DWORD dwTransactionID, + [in, out] OPCHDA_TIME* htStartTime, + [in, out] OPCHDA_TIME* htEndTime, + [in] FILETIME ftResampleInterval, + [in] DWORD dwNumIntervals, + [in] FILETIME ftUpdateInterval, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHANDLE* phServer, + [in, size_is(dwNumItems)] DWORD* haAggregate, + [out] DWORD* pdwCancelID, + [out, size_is(,dwNumItems)] HRESULT** ppErrors + ); + + HRESULT Cancel( + [in] DWORD dwCancelID + ); +} + +//============================================================================== +// IOPCHDA_DataCallback + +[ + object, + uuid(1F1217B9-DEE0-11d2-A5E5-000086339399), + pointer_default(unique) +] +interface IOPCHDA_DataCallback : IUnknown +{ + HRESULT OnDataChange( + [in] DWORD dwTransactionID, + [in] HRESULT hrStatus, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHDA_ITEM* pItemValues, + [in, size_is(dwNumItems)] HRESULT* phrErrors + ); + + HRESULT OnReadComplete( + [in] DWORD dwTransactionID, + [in] HRESULT hrStatus, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHDA_ITEM* pItemValues, + [in, size_is(dwNumItems)] HRESULT* phrErrors + ); + + HRESULT OnReadModifiedComplete( + [in] DWORD dwTransactionID, + [in] HRESULT hrStatus, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHDA_MODIFIEDITEM* pItemValues, + [in, size_is(dwNumItems)] HRESULT* phrErrors + ); + + HRESULT OnReadAttributeComplete( + [in] DWORD dwTransactionID, + [in] HRESULT hrStatus, + [in] OPCHANDLE hClient, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHDA_ATTRIBUTE* pAttributeValues, + [in, size_is(dwNumItems)] HRESULT* phrErrors + ); + + HRESULT OnReadAnnotations( + [in] DWORD dwTransactionID, + [in] HRESULT hrStatus, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHDA_ANNOTATION* pAnnotationValues, + [in, size_is(dwNumItems)] HRESULT* phrErrors + ); + + HRESULT OnInsertAnnotations ( + [in] DWORD dwTransactionID, + [in] HRESULT hrStatus, + [in] DWORD dwCount, + [in, size_is(dwCount)] OPCHANDLE* phClients, + [in, size_is(dwCount)] HRESULT* phrErrors + ); + + HRESULT OnPlayback ( + [in] DWORD dwTransactionID, + [in] HRESULT hrStatus, + [in] DWORD dwNumItems, + [in, size_is(dwNumItems)] OPCHDA_ITEM** ppItemValues, + [in, size_is(dwNumItems)] HRESULT* phrErrors + ); + + HRESULT OnUpdateComplete ( + [in] DWORD dwTransactionID, + [in] HRESULT hrStatus, + [in] DWORD dwCount, + [in, size_is(dwCount)] OPCHANDLE* phClients, + [in, size_is(dwCount)] HRESULT* phrErrors + ); + + HRESULT OnCancelComplete( + [in] DWORD dwCancelID + ); +} + +//============================================================================== +// Type Library + +[ + uuid(1F1217BA-DEE0-11d2-A5E5-000086339399), + version(1.10), + helpstring("OPC Historial Data Access 1.10 Type Library") +] +library OPCHDA +{ + importlib("stdole32.tlb"); + importlib("stdole2.tlb"); + + //========================================================================== + // Category IDs + + interface CATID_OPCHDAServer10; + + //========================================================================== + // Constants + + module OPCHDA_Constants + { + // category description. + const LPCWSTR OPC_CATEGORY_DESCRIPTION_HDA10 = L"OPC History Data Access Servers Version 1.0"; + + // attribute ids. + const DWORD OPCHDA_DATA_TYPE = 0x01; + const DWORD OPCHDA_DESCRIPTION = 0x02; + const DWORD OPCHDA_ENG_UNITS = 0x03; + const DWORD OPCHDA_STEPPED = 0x04; + const DWORD OPCHDA_ARCHIVING = 0x05; + const DWORD OPCHDA_DERIVE_EQUATION = 0x06; + const DWORD OPCHDA_NODE_NAME = 0x07; + const DWORD OPCHDA_PROCESS_NAME = 0x08; + const DWORD OPCHDA_SOURCE_NAME = 0x09; + const DWORD OPCHDA_SOURCE_TYPE = 0x0a; + const DWORD OPCHDA_NORMAL_MAXIMUM = 0x0b; + const DWORD OPCHDA_NORMAL_MINIMUM = 0x0c; + const DWORD OPCHDA_ITEMID = 0x0d; + const DWORD OPCHDA_MAX_TIME_INT = 0x0e; + const DWORD OPCHDA_MIN_TIME_INT = 0x0f; + const DWORD OPCHDA_EXCEPTION_DEV = 0x10; + const DWORD OPCHDA_EXCEPTION_DEV_TYPE = 0x11; + const DWORD OPCHDA_HIGH_ENTRY_LIMIT = 0x12; + const DWORD OPCHDA_LOW_ENTRY_LIMIT = 0x13; + + // attribute names. + const LPCWSTR OPCHDA_ATTRNAME_DATA_TYPE = L"Data Type"; + const LPCWSTR OPCHDA_ATTRNAME_DESCRIPTION = L"Description"; + const LPCWSTR OPCHDA_ATTRNAME_ENG_UNITS = L"Eng Units"; + const LPCWSTR OPCHDA_ATTRNAME_STEPPED = L"Stepped"; + const LPCWSTR OPCHDA_ATTRNAME_ARCHIVING = L"Archiving"; + const LPCWSTR OPCHDA_ATTRNAME_DERIVE_EQUATION = L"Derive Equation"; + const LPCWSTR OPCHDA_ATTRNAME_NODE_NAME = L"Node Name"; + const LPCWSTR OPCHDA_ATTRNAME_PROCESS_NAME = L"Process Name"; + const LPCWSTR OPCHDA_ATTRNAME_SOURCE_NAME = L"Source Name"; + const LPCWSTR OPCHDA_ATTRNAME_SOURCE_TYPE = L"Source Type"; + const LPCWSTR OPCHDA_ATTRNAME_NORMAL_MAXIMUM = L"Normal Maximum"; + const LPCWSTR OPCHDA_ATTRNAME_NORMAL_MINIMUM = L"Normal Minimum"; + const LPCWSTR OPCHDA_ATTRNAME_ITEMID = L"ItemID"; + const LPCWSTR OPCHDA_ATTRNAME_MAX_TIME_INT = L"Max Time Interval"; + const LPCWSTR OPCHDA_ATTRNAME_MIN_TIME_INT = L"Min Time Interval"; + const LPCWSTR OPCHDA_ATTRNAME_EXCEPTION_DEV = L"Exception Deviation"; + const LPCWSTR OPCHDA_ATTRNAME_EXCEPTION_DEV_TYPE = L"Exception Dev Type"; + const LPCWSTR OPCHDA_ATTRNAME_HIGH_ENTRY_LIMIT = L"High Entry Limit"; + const LPCWSTR OPCHDA_ATTRNAME_LOW_ENTRY_LIMIT = L"Low Entry Limit"; + + // aggregate names. + const LPCWSTR OPCHDA_AGGRNAME_INTERPOLATIVE = L"Interpolative"; + const LPCWSTR OPCHDA_AGGRNAME_TOTAL = L"Total"; + const LPCWSTR OPCHDA_AGGRNAME_AVERAGE = L"Average"; + const LPCWSTR OPCHDA_AGGRNAME_TIMEAVERAGE = L"Time Average"; + const LPCWSTR OPCHDA_AGGRNAME_COUNT = L"Count"; + const LPCWSTR OPCHDA_AGGRNAME_STDEV = L"Standard Deviation"; + const LPCWSTR OPCHDA_AGGRNAME_MINIMUMACTUALTIME = L"Minimum Actual Time"; + const LPCWSTR OPCHDA_AGGRNAME_MINIMUM = L"Minimum"; + const LPCWSTR OPCHDA_AGGRNAME_MAXIMUMACTUALTIME = L"Maximum Actual Time"; + const LPCWSTR OPCHDA_AGGRNAME_MAXIMUM = L"Maximum"; + const LPCWSTR OPCHDA_AGGRNAME_START = L"Start"; + const LPCWSTR OPCHDA_AGGRNAME_END = L"End"; + const LPCWSTR OPCHDA_AGGRNAME_DELTA = L"Delta"; + const LPCWSTR OPCHDA_AGGRNAME_REGSLOPE = L"Regression Line Slope"; + const LPCWSTR OPCHDA_AGGRNAME_REGCONST = L"Regression Line Constant"; + const LPCWSTR OPCHDA_AGGRNAME_REGDEV = L"Regression Line Error"; + const LPCWSTR OPCHDA_AGGRNAME_VARIANCE = L"Variance"; + const LPCWSTR OPCHDA_AGGRNAME_RANGE = L"Range"; + const LPCWSTR OPCHDA_AGGRNAME_DURATIONGOOD = L"Duration Good"; + const LPCWSTR OPCHDA_AGGRNAME_DURATIONBAD = L"Duration Bad"; + const LPCWSTR OPCHDA_AGGRNAME_PERCENTGOOD = L"Percent Good"; + const LPCWSTR OPCHDA_AGGRNAME_PERCENTBAD = L"Percent Bad"; + const LPCWSTR OPCHDA_AGGRNAME_WORSTQUALITY = L"Worst Quality"; + const LPCWSTR OPCHDA_AGGRNAME_ANNOTATIONS = L"Annotations"; + + // OPCHDA_QUALITY -- these are the high-order 16 bits, OPC DA Quality occupies low-order 16 bits. + const DWORD OPCHDA_EXTRADATA = 0x00010000; + const DWORD OPCHDA_INTERPOLATED = 0x00020000; + const DWORD OPCHDA_RAW = 0x00040000; + const DWORD OPCHDA_CALCULATED = 0x00080000; + const DWORD OPCHDA_NOBOUND = 0x00100000; + const DWORD OPCHDA_NODATA = 0x00200000; + const DWORD OPCHDA_DATALOST = 0x00400000; + const DWORD OPCHDA_CONVERSION = 0x00800000; + const DWORD OPCHDA_PARTIAL = 0x01000000; + } + + //========================================================================== + // Synchronous Interfaces + + interface IOPCHDA_Server; + interface IOPCHDA_Browser; + interface IOPCHDA_SyncRead; + interface IOPCHDA_SyncUpdate; + interface IOPCHDA_SyncAnnotations; + interface IOPCHDA_AsyncRead; + interface IOPCHDA_AsyncUpdate; + interface IOPCHDA_AsyncAnnotations; + interface IOPCHDA_Playback; + interface IOPCHDA_DataCallback; +}; + diff --git a/opc_hda_bindings/.windows/winmd/OPCHDA.winmd b/opc_hda_bindings/.windows/winmd/OPCHDA.winmd new file mode 100644 index 0000000000000000000000000000000000000000..7400e2340e4e119aee59f75e16674578a908a4cf GIT binary patch literal 15360 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 MB7YeFrKrGv0LYtFrvLx| literal 0 HcmV?d00001 diff --git a/opc_hda_bindings/Cargo.toml b/opc_hda_bindings/Cargo.toml new file mode 100644 index 0000000..03330bf --- /dev/null +++ b/opc_hda_bindings/Cargo.toml @@ -0,0 +1,22 @@ +[package] +name = "opc_hda_bindings" +version = "0.3.0" +edition = "2024" +description = "OPC Historical Data Access bindings" +readme = "README.md" +repository = "https://github.com/Ronbb/rust_opc" +license = "MIT" +keywords = ["bindings", "hda", "opc", "opchda"] +exclude = [".metadata/*", ".windows/*", "build.rs"] + +[package.metadata.docs.rs] +default-target = "x86_64-pc-windows-msvc" +targets = [] + +[dependencies] +windows = { workspace = true } +windows-core = { workspace = true } +windows-targets = { workspace = true } + +[build-dependencies] +windows-bindgen = { workspace = true } diff --git a/opc_hda_bindings/README.md b/opc_hda_bindings/README.md new file mode 100644 index 0000000..b120e29 --- /dev/null +++ b/opc_hda_bindings/README.md @@ -0,0 +1,18 @@ +# OPC HDA Bindings + +Please see docs on [docs.rs](https://docs.rs/opc_hda_bindings/). + +## Example + +```rust +// TODO +``` + +## Rebuild metadata + +Open **Developer Powershell for VS2022**. + +```batch +cd .metadata +dotnet build +``` diff --git a/opc_hda_bindings/build.rs b/opc_hda_bindings/build.rs new file mode 100644 index 0000000..edfbc7d --- /dev/null +++ b/opc_hda_bindings/build.rs @@ -0,0 +1,19 @@ +fn main() { + println!("cargo:rerun-if-changed=build.rs"); + println!("cargo:rerun-if-changed=.windows/winmd/OPCHDA.winmd"); + + windows_bindgen::bindgen([ + "--in", + ".windows/winmd/OPCHDA.winmd", + "default", + "--out", + "src/bindings.rs", + "--reference", + "windows,skip-root,Windows", + "--filter", + "OPCHDA", + "--flat", + "--implement", + ]) + .unwrap(); +} diff --git a/opc_hda_bindings/src/bindings.rs b/opc_hda_bindings/src/bindings.rs new file mode 100644 index 0000000..738befe --- /dev/null +++ b/opc_hda_bindings/src/bindings.rs @@ -0,0 +1,3997 @@ +// Bindings generated by `windows-bindgen` 0.62.1 + +#![allow( + non_snake_case, + non_upper_case_globals, + non_camel_case_types, + dead_code, + clippy::all +)] + +windows_core::imp::define_interface!( + CATID_OPCHDAServer10, + CATID_OPCHDAServer10_Vtbl, + 0x7de5b060_e089_11d2_a5e6_000086339399 +); +windows_core::imp::interface_hierarchy!(CATID_OPCHDAServer10, windows_core::IUnknown); +#[repr(C)] +#[doc(hidden)] +pub struct CATID_OPCHDAServer10_Vtbl { + pub base__: windows_core::IUnknown_Vtbl, +} +pub trait CATID_OPCHDAServer10_Impl: windows_core::IUnknownImpl {} +impl CATID_OPCHDAServer10_Vtbl { + pub const fn new() -> Self { + Self { + base__: windows_core::IUnknown_Vtbl::new::(), + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +impl windows_core::RuntimeName for CATID_OPCHDAServer10 {} +windows_core::imp::define_interface!( + IOPCHDA_AsyncAnnotations, + IOPCHDA_AsyncAnnotations_Vtbl, + 0x1f1217b7_dee0_11d2_a5e5_000086339399 +); +windows_core::imp::interface_hierarchy!(IOPCHDA_AsyncAnnotations, windows_core::IUnknown); +impl IOPCHDA_AsyncAnnotations { + pub unsafe fn QueryCapabilities( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).QueryCapabilities)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn Read( + &self, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumitems: u32, + phserver: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).Read)( + windows_core::Interface::as_raw(self), + dwtransactionid, + htstarttime as _, + htendtime as _, + dwnumitems, + phserver, + pdwcancelid as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn Insert( + &self, + dwtransactionid: u32, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + pannotationvalues: *const tagOPCHDA_ANNOTATION, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).Insert)( + windows_core::Interface::as_raw(self), + dwtransactionid, + dwnumitems, + phserver, + fttimestamps, + pannotationvalues, + pdwcancelid as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn Cancel(&self, dwcancelid: u32) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).Cancel)( + windows_core::Interface::as_raw(self), + dwcancelid, + ) + .ok() + } + } +} +#[repr(C)] +#[doc(hidden)] +pub struct IOPCHDA_AsyncAnnotations_Vtbl { + pub base__: windows_core::IUnknown_Vtbl, + pub QueryCapabilities: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut tagOPCHDA_ANNOTATIONCAPABILITIES, + ) -> windows_core::HRESULT, + pub Read: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *mut tagOPCHDA_TIME, + *mut tagOPCHDA_TIME, + u32, + *const u32, + *mut u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub Insert: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + u32, + *const u32, + *const windows::Win32::Foundation::FILETIME, + *const tagOPCHDA_ANNOTATION, + *mut u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub Cancel: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT, +} +pub trait IOPCHDA_AsyncAnnotations_Impl: windows_core::IUnknownImpl { + fn QueryCapabilities(&self) -> windows_core::Result; + fn Read( + &self, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumitems: u32, + phserver: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn Insert( + &self, + dwtransactionid: u32, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + pannotationvalues: *const tagOPCHDA_ANNOTATION, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn Cancel(&self, dwcancelid: u32) -> windows_core::Result<()>; +} +impl IOPCHDA_AsyncAnnotations_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn QueryCapabilities< + Identity: IOPCHDA_AsyncAnnotations_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pcapabilities: *mut tagOPCHDA_ANNOTATIONCAPABILITIES, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCHDA_AsyncAnnotations_Impl::QueryCapabilities(this) { + Ok(ok__) => { + pcapabilities.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn Read< + Identity: IOPCHDA_AsyncAnnotations_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumitems: u32, + phserver: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_AsyncAnnotations_Impl::Read( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&htstarttime), + core::mem::transmute_copy(&htendtime), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&pdwcancelid), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn Insert< + Identity: IOPCHDA_AsyncAnnotations_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + pannotationvalues: *const tagOPCHDA_ANNOTATION, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_AsyncAnnotations_Impl::Insert( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&fttimestamps), + core::mem::transmute_copy(&pannotationvalues), + core::mem::transmute_copy(&pdwcancelid), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn Cancel< + Identity: IOPCHDA_AsyncAnnotations_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwcancelid: u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_AsyncAnnotations_Impl::Cancel(this, core::mem::transmute_copy(&dwcancelid)) + .into() + } + } + Self { + base__: windows_core::IUnknown_Vtbl::new::(), + QueryCapabilities: QueryCapabilities::, + Read: Read::, + Insert: Insert::, + Cancel: Cancel::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +impl windows_core::RuntimeName for IOPCHDA_AsyncAnnotations {} +windows_core::imp::define_interface!( + IOPCHDA_AsyncRead, + IOPCHDA_AsyncRead_Vtbl, + 0x1f1217b5_dee0_11d2_a5e5_000086339399 +); +windows_core::imp::interface_hierarchy!(IOPCHDA_AsyncRead, windows_core::IUnknown); +impl IOPCHDA_AsyncRead { + pub unsafe fn ReadRaw( + &self, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumvalues: u32, + bbounds: bool, + dwnumitems: u32, + phserver: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).ReadRaw)( + windows_core::Interface::as_raw(self), + dwtransactionid, + htstarttime as _, + htendtime as _, + dwnumvalues, + bbounds.into(), + dwnumitems, + phserver, + pdwcancelid as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn AdviseRaw( + &self, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + ftupdateinterval: windows::Win32::Foundation::FILETIME, + dwnumitems: u32, + phserver: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).AdviseRaw)( + windows_core::Interface::as_raw(self), + dwtransactionid, + htstarttime as _, + core::mem::transmute(ftupdateinterval), + dwnumitems, + phserver, + pdwcancelid as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn ReadProcessed( + &self, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + ftresampleinterval: windows::Win32::Foundation::FILETIME, + dwnumitems: u32, + phserver: *const u32, + haaggregate: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).ReadProcessed)( + windows_core::Interface::as_raw(self), + dwtransactionid, + htstarttime as _, + htendtime as _, + core::mem::transmute(ftresampleinterval), + dwnumitems, + phserver, + haaggregate, + pdwcancelid as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn AdviseProcessed( + &self, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + ftresampleinterval: windows::Win32::Foundation::FILETIME, + dwnumitems: u32, + phserver: *const u32, + haaggregate: *const u32, + dwnumintervals: u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).AdviseProcessed)( + windows_core::Interface::as_raw(self), + dwtransactionid, + htstarttime as _, + core::mem::transmute(ftresampleinterval), + dwnumitems, + phserver, + haaggregate, + dwnumintervals, + pdwcancelid as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn ReadAtTime( + &self, + dwtransactionid: u32, + fttimestamps: &[windows::Win32::Foundation::FILETIME], + dwnumitems: u32, + phserver: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).ReadAtTime)( + windows_core::Interface::as_raw(self), + dwtransactionid, + fttimestamps.len().try_into().unwrap(), + core::mem::transmute(fttimestamps.as_ptr()), + dwnumitems, + phserver, + pdwcancelid as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn ReadModified( + &self, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumvalues: u32, + dwnumitems: u32, + phserver: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).ReadModified)( + windows_core::Interface::as_raw(self), + dwtransactionid, + htstarttime as _, + htendtime as _, + dwnumvalues, + dwnumitems, + phserver, + pdwcancelid as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn ReadAttribute( + &self, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + hserver: u32, + dwnumattributes: u32, + dwattributeids: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).ReadAttribute)( + windows_core::Interface::as_raw(self), + dwtransactionid, + htstarttime as _, + htendtime as _, + hserver, + dwnumattributes, + dwattributeids, + pdwcancelid as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn Cancel(&self, dwcancelid: u32) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).Cancel)( + windows_core::Interface::as_raw(self), + dwcancelid, + ) + .ok() + } + } +} +#[repr(C)] +#[doc(hidden)] +pub struct IOPCHDA_AsyncRead_Vtbl { + pub base__: windows_core::IUnknown_Vtbl, + pub ReadRaw: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *mut tagOPCHDA_TIME, + *mut tagOPCHDA_TIME, + u32, + windows_core::BOOL, + u32, + *const u32, + *mut u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub AdviseRaw: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *mut tagOPCHDA_TIME, + windows::Win32::Foundation::FILETIME, + u32, + *const u32, + *mut u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub ReadProcessed: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *mut tagOPCHDA_TIME, + *mut tagOPCHDA_TIME, + windows::Win32::Foundation::FILETIME, + u32, + *const u32, + *const u32, + *mut u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub AdviseProcessed: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *mut tagOPCHDA_TIME, + windows::Win32::Foundation::FILETIME, + u32, + *const u32, + *const u32, + u32, + *mut u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub ReadAtTime: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + u32, + *const windows::Win32::Foundation::FILETIME, + u32, + *const u32, + *mut u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub ReadModified: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *mut tagOPCHDA_TIME, + *mut tagOPCHDA_TIME, + u32, + u32, + *const u32, + *mut u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub ReadAttribute: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *mut tagOPCHDA_TIME, + *mut tagOPCHDA_TIME, + u32, + u32, + *const u32, + *mut u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub Cancel: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT, +} +pub trait IOPCHDA_AsyncRead_Impl: windows_core::IUnknownImpl { + fn ReadRaw( + &self, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumvalues: u32, + bbounds: windows_core::BOOL, + dwnumitems: u32, + phserver: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn AdviseRaw( + &self, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + ftupdateinterval: &windows::Win32::Foundation::FILETIME, + dwnumitems: u32, + phserver: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn ReadProcessed( + &self, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + ftresampleinterval: &windows::Win32::Foundation::FILETIME, + dwnumitems: u32, + phserver: *const u32, + haaggregate: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn AdviseProcessed( + &self, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + ftresampleinterval: &windows::Win32::Foundation::FILETIME, + dwnumitems: u32, + phserver: *const u32, + haaggregate: *const u32, + dwnumintervals: u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn ReadAtTime( + &self, + dwtransactionid: u32, + dwnumtimestamps: u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + dwnumitems: u32, + phserver: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn ReadModified( + &self, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumvalues: u32, + dwnumitems: u32, + phserver: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn ReadAttribute( + &self, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + hserver: u32, + dwnumattributes: u32, + dwattributeids: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn Cancel(&self, dwcancelid: u32) -> windows_core::Result<()>; +} +impl IOPCHDA_AsyncRead_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn ReadRaw( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumvalues: u32, + bbounds: windows_core::BOOL, + dwnumitems: u32, + phserver: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_AsyncRead_Impl::ReadRaw( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&htstarttime), + core::mem::transmute_copy(&htendtime), + core::mem::transmute_copy(&dwnumvalues), + core::mem::transmute_copy(&bbounds), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&pdwcancelid), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn AdviseRaw< + Identity: IOPCHDA_AsyncRead_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + ftupdateinterval: windows::Win32::Foundation::FILETIME, + dwnumitems: u32, + phserver: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_AsyncRead_Impl::AdviseRaw( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&htstarttime), + core::mem::transmute(&ftupdateinterval), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&pdwcancelid), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn ReadProcessed< + Identity: IOPCHDA_AsyncRead_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + ftresampleinterval: windows::Win32::Foundation::FILETIME, + dwnumitems: u32, + phserver: *const u32, + haaggregate: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_AsyncRead_Impl::ReadProcessed( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&htstarttime), + core::mem::transmute_copy(&htendtime), + core::mem::transmute(&ftresampleinterval), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&haaggregate), + core::mem::transmute_copy(&pdwcancelid), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn AdviseProcessed< + Identity: IOPCHDA_AsyncRead_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + ftresampleinterval: windows::Win32::Foundation::FILETIME, + dwnumitems: u32, + phserver: *const u32, + haaggregate: *const u32, + dwnumintervals: u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_AsyncRead_Impl::AdviseProcessed( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&htstarttime), + core::mem::transmute(&ftresampleinterval), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&haaggregate), + core::mem::transmute_copy(&dwnumintervals), + core::mem::transmute_copy(&pdwcancelid), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn ReadAtTime< + Identity: IOPCHDA_AsyncRead_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + dwnumtimestamps: u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + dwnumitems: u32, + phserver: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_AsyncRead_Impl::ReadAtTime( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&dwnumtimestamps), + core::mem::transmute_copy(&fttimestamps), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&pdwcancelid), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn ReadModified< + Identity: IOPCHDA_AsyncRead_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumvalues: u32, + dwnumitems: u32, + phserver: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_AsyncRead_Impl::ReadModified( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&htstarttime), + core::mem::transmute_copy(&htendtime), + core::mem::transmute_copy(&dwnumvalues), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&pdwcancelid), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn ReadAttribute< + Identity: IOPCHDA_AsyncRead_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + hserver: u32, + dwnumattributes: u32, + dwattributeids: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_AsyncRead_Impl::ReadAttribute( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&htstarttime), + core::mem::transmute_copy(&htendtime), + core::mem::transmute_copy(&hserver), + core::mem::transmute_copy(&dwnumattributes), + core::mem::transmute_copy(&dwattributeids), + core::mem::transmute_copy(&pdwcancelid), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn Cancel( + this: *mut core::ffi::c_void, + dwcancelid: u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_AsyncRead_Impl::Cancel(this, core::mem::transmute_copy(&dwcancelid)).into() + } + } + Self { + base__: windows_core::IUnknown_Vtbl::new::(), + ReadRaw: ReadRaw::, + AdviseRaw: AdviseRaw::, + ReadProcessed: ReadProcessed::, + AdviseProcessed: AdviseProcessed::, + ReadAtTime: ReadAtTime::, + ReadModified: ReadModified::, + ReadAttribute: ReadAttribute::, + Cancel: Cancel::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +impl windows_core::RuntimeName for IOPCHDA_AsyncRead {} +windows_core::imp::define_interface!( + IOPCHDA_AsyncUpdate, + IOPCHDA_AsyncUpdate_Vtbl, + 0x1f1217b6_dee0_11d2_a5e5_000086339399 +); +windows_core::imp::interface_hierarchy!(IOPCHDA_AsyncUpdate, windows_core::IUnknown); +impl IOPCHDA_AsyncUpdate { + pub unsafe fn QueryCapabilities(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).QueryCapabilities)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn Insert( + &self, + dwtransactionid: u32, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + vdatavalues: *const windows::Win32::System::Variant::VARIANT, + pdwqualities: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).Insert)( + windows_core::Interface::as_raw(self), + dwtransactionid, + dwnumitems, + phserver, + fttimestamps, + core::mem::transmute(vdatavalues), + pdwqualities, + pdwcancelid as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn Replace( + &self, + dwtransactionid: u32, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + vdatavalues: *const windows::Win32::System::Variant::VARIANT, + pdwqualities: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).Replace)( + windows_core::Interface::as_raw(self), + dwtransactionid, + dwnumitems, + phserver, + fttimestamps, + core::mem::transmute(vdatavalues), + pdwqualities, + pdwcancelid as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn InsertReplace( + &self, + dwtransactionid: u32, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + vdatavalues: *const windows::Win32::System::Variant::VARIANT, + pdwqualities: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).InsertReplace)( + windows_core::Interface::as_raw(self), + dwtransactionid, + dwnumitems, + phserver, + fttimestamps, + core::mem::transmute(vdatavalues), + pdwqualities, + pdwcancelid as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn DeleteRaw( + &self, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumitems: u32, + phserver: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).DeleteRaw)( + windows_core::Interface::as_raw(self), + dwtransactionid, + htstarttime as _, + htendtime as _, + dwnumitems, + phserver, + pdwcancelid as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn DeleteAtTime( + &self, + dwtransactionid: u32, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).DeleteAtTime)( + windows_core::Interface::as_raw(self), + dwtransactionid, + dwnumitems, + phserver, + fttimestamps, + pdwcancelid as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn Cancel(&self, dwcancelid: u32) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).Cancel)( + windows_core::Interface::as_raw(self), + dwcancelid, + ) + .ok() + } + } +} +#[repr(C)] +#[doc(hidden)] +pub struct IOPCHDA_AsyncUpdate_Vtbl { + pub base__: windows_core::IUnknown_Vtbl, + pub QueryCapabilities: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut tagOPCHDA_UPDATECAPABILITIES, + ) -> windows_core::HRESULT, + pub Insert: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + u32, + *const u32, + *const windows::Win32::Foundation::FILETIME, + *const windows::Win32::System::Variant::VARIANT, + *const u32, + *mut u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub Replace: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + u32, + *const u32, + *const windows::Win32::Foundation::FILETIME, + *const windows::Win32::System::Variant::VARIANT, + *const u32, + *mut u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub InsertReplace: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + u32, + *const u32, + *const windows::Win32::Foundation::FILETIME, + *const windows::Win32::System::Variant::VARIANT, + *const u32, + *mut u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub DeleteRaw: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *mut tagOPCHDA_TIME, + *mut tagOPCHDA_TIME, + u32, + *const u32, + *mut u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub DeleteAtTime: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + u32, + *const u32, + *const windows::Win32::Foundation::FILETIME, + *mut u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub Cancel: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT, +} +pub trait IOPCHDA_AsyncUpdate_Impl: windows_core::IUnknownImpl { + fn QueryCapabilities(&self) -> windows_core::Result; + fn Insert( + &self, + dwtransactionid: u32, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + vdatavalues: *const windows::Win32::System::Variant::VARIANT, + pdwqualities: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn Replace( + &self, + dwtransactionid: u32, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + vdatavalues: *const windows::Win32::System::Variant::VARIANT, + pdwqualities: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn InsertReplace( + &self, + dwtransactionid: u32, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + vdatavalues: *const windows::Win32::System::Variant::VARIANT, + pdwqualities: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn DeleteRaw( + &self, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumitems: u32, + phserver: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn DeleteAtTime( + &self, + dwtransactionid: u32, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn Cancel(&self, dwcancelid: u32) -> windows_core::Result<()>; +} +impl IOPCHDA_AsyncUpdate_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn QueryCapabilities< + Identity: IOPCHDA_AsyncUpdate_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pcapabilities: *mut tagOPCHDA_UPDATECAPABILITIES, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCHDA_AsyncUpdate_Impl::QueryCapabilities(this) { + Ok(ok__) => { + pcapabilities.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn Insert< + Identity: IOPCHDA_AsyncUpdate_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + vdatavalues: *const windows::Win32::System::Variant::VARIANT, + pdwqualities: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_AsyncUpdate_Impl::Insert( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&fttimestamps), + core::mem::transmute_copy(&vdatavalues), + core::mem::transmute_copy(&pdwqualities), + core::mem::transmute_copy(&pdwcancelid), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn Replace< + Identity: IOPCHDA_AsyncUpdate_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + vdatavalues: *const windows::Win32::System::Variant::VARIANT, + pdwqualities: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_AsyncUpdate_Impl::Replace( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&fttimestamps), + core::mem::transmute_copy(&vdatavalues), + core::mem::transmute_copy(&pdwqualities), + core::mem::transmute_copy(&pdwcancelid), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn InsertReplace< + Identity: IOPCHDA_AsyncUpdate_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + vdatavalues: *const windows::Win32::System::Variant::VARIANT, + pdwqualities: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_AsyncUpdate_Impl::InsertReplace( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&fttimestamps), + core::mem::transmute_copy(&vdatavalues), + core::mem::transmute_copy(&pdwqualities), + core::mem::transmute_copy(&pdwcancelid), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn DeleteRaw< + Identity: IOPCHDA_AsyncUpdate_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumitems: u32, + phserver: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_AsyncUpdate_Impl::DeleteRaw( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&htstarttime), + core::mem::transmute_copy(&htendtime), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&pdwcancelid), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn DeleteAtTime< + Identity: IOPCHDA_AsyncUpdate_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_AsyncUpdate_Impl::DeleteAtTime( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&fttimestamps), + core::mem::transmute_copy(&pdwcancelid), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn Cancel< + Identity: IOPCHDA_AsyncUpdate_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwcancelid: u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_AsyncUpdate_Impl::Cancel(this, core::mem::transmute_copy(&dwcancelid)) + .into() + } + } + Self { + base__: windows_core::IUnknown_Vtbl::new::(), + QueryCapabilities: QueryCapabilities::, + Insert: Insert::, + Replace: Replace::, + InsertReplace: InsertReplace::, + DeleteRaw: DeleteRaw::, + DeleteAtTime: DeleteAtTime::, + Cancel: Cancel::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +impl windows_core::RuntimeName for IOPCHDA_AsyncUpdate {} +windows_core::imp::define_interface!( + IOPCHDA_Browser, + IOPCHDA_Browser_Vtbl, + 0x1f1217b1_dee0_11d2_a5e5_000086339399 +); +windows_core::imp::interface_hierarchy!(IOPCHDA_Browser, windows_core::IUnknown); +impl IOPCHDA_Browser { + pub unsafe fn GetEnum( + &self, + dwbrowsetype: tagOPCHDA_BROWSETYPE, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).GetEnum)( + windows_core::Interface::as_raw(self), + dwbrowsetype, + &mut result__, + ) + .and_then(|| windows_core::Type::from_abi(result__)) + } + } + pub unsafe fn ChangeBrowsePosition( + &self, + dwbrowsedirection: tagOPCHDA_BROWSEDIRECTION, + szstring: P1, + ) -> windows_core::Result<()> + where + P1: windows_core::Param, + { + unsafe { + (windows_core::Interface::vtable(self).ChangeBrowsePosition)( + windows_core::Interface::as_raw(self), + dwbrowsedirection, + szstring.param().abi(), + ) + .ok() + } + } + pub unsafe fn GetItemID(&self, sznode: P0) -> windows_core::Result + where + P0: windows_core::Param, + { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).GetItemID)( + windows_core::Interface::as_raw(self), + sznode.param().abi(), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn GetBranchPosition(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).GetBranchPosition)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } +} +#[repr(C)] +#[doc(hidden)] +pub struct IOPCHDA_Browser_Vtbl { + pub base__: windows_core::IUnknown_Vtbl, + pub GetEnum: unsafe extern "system" fn( + *mut core::ffi::c_void, + tagOPCHDA_BROWSETYPE, + *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT, + pub ChangeBrowsePosition: unsafe extern "system" fn( + *mut core::ffi::c_void, + tagOPCHDA_BROWSEDIRECTION, + windows_core::PCWSTR, + ) -> windows_core::HRESULT, + pub GetItemID: unsafe extern "system" fn( + *mut core::ffi::c_void, + windows_core::PCWSTR, + *mut windows_core::PWSTR, + ) -> windows_core::HRESULT, + pub GetBranchPosition: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut windows_core::PWSTR, + ) -> windows_core::HRESULT, +} +pub trait IOPCHDA_Browser_Impl: windows_core::IUnknownImpl { + fn GetEnum( + &self, + dwbrowsetype: tagOPCHDA_BROWSETYPE, + ) -> windows_core::Result; + fn ChangeBrowsePosition( + &self, + dwbrowsedirection: tagOPCHDA_BROWSEDIRECTION, + szstring: &windows_core::PCWSTR, + ) -> windows_core::Result<()>; + fn GetItemID(&self, sznode: &windows_core::PCWSTR) + -> windows_core::Result; + fn GetBranchPosition(&self) -> windows_core::Result; +} +impl IOPCHDA_Browser_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn GetEnum( + this: *mut core::ffi::c_void, + dwbrowsetype: tagOPCHDA_BROWSETYPE, + ppienumstring: *mut *mut core::ffi::c_void, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCHDA_Browser_Impl::GetEnum(this, core::mem::transmute_copy(&dwbrowsetype)) + { + Ok(ok__) => { + ppienumstring.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn ChangeBrowsePosition< + Identity: IOPCHDA_Browser_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwbrowsedirection: tagOPCHDA_BROWSEDIRECTION, + szstring: windows_core::PCWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_Browser_Impl::ChangeBrowsePosition( + this, + core::mem::transmute_copy(&dwbrowsedirection), + core::mem::transmute(&szstring), + ) + .into() + } + } + unsafe extern "system" fn GetItemID( + this: *mut core::ffi::c_void, + sznode: windows_core::PCWSTR, + pszitemid: *mut windows_core::PWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCHDA_Browser_Impl::GetItemID(this, core::mem::transmute(&sznode)) { + Ok(ok__) => { + pszitemid.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn GetBranchPosition< + Identity: IOPCHDA_Browser_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pszbranchpos: *mut windows_core::PWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCHDA_Browser_Impl::GetBranchPosition(this) { + Ok(ok__) => { + pszbranchpos.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + Self { + base__: windows_core::IUnknown_Vtbl::new::(), + GetEnum: GetEnum::, + ChangeBrowsePosition: ChangeBrowsePosition::, + GetItemID: GetItemID::, + GetBranchPosition: GetBranchPosition::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +impl windows_core::RuntimeName for IOPCHDA_Browser {} +windows_core::imp::define_interface!( + IOPCHDA_DataCallback, + IOPCHDA_DataCallback_Vtbl, + 0x1f1217b9_dee0_11d2_a5e5_000086339399 +); +windows_core::imp::interface_hierarchy!(IOPCHDA_DataCallback, windows_core::IUnknown); +impl IOPCHDA_DataCallback { + pub unsafe fn OnDataChange( + &self, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + dwnumitems: u32, + pitemvalues: *const tagOPCHDA_ITEM, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).OnDataChange)( + windows_core::Interface::as_raw(self), + dwtransactionid, + hrstatus, + dwnumitems, + pitemvalues, + phrerrors, + ) + .ok() + } + } + pub unsafe fn OnReadComplete( + &self, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + dwnumitems: u32, + pitemvalues: *const tagOPCHDA_ITEM, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).OnReadComplete)( + windows_core::Interface::as_raw(self), + dwtransactionid, + hrstatus, + dwnumitems, + pitemvalues, + phrerrors, + ) + .ok() + } + } + pub unsafe fn OnReadModifiedComplete( + &self, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + dwnumitems: u32, + pitemvalues: *const tagOPCHDA_MODIFIEDITEM, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).OnReadModifiedComplete)( + windows_core::Interface::as_raw(self), + dwtransactionid, + hrstatus, + dwnumitems, + pitemvalues, + phrerrors, + ) + .ok() + } + } + pub unsafe fn OnReadAttributeComplete( + &self, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + hclient: u32, + dwnumitems: u32, + pattributevalues: *const tagOPCHDA_ATTRIBUTE, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).OnReadAttributeComplete)( + windows_core::Interface::as_raw(self), + dwtransactionid, + hrstatus, + hclient, + dwnumitems, + pattributevalues, + phrerrors, + ) + .ok() + } + } + pub unsafe fn OnReadAnnotations( + &self, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + dwnumitems: u32, + pannotationvalues: *const tagOPCHDA_ANNOTATION, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).OnReadAnnotations)( + windows_core::Interface::as_raw(self), + dwtransactionid, + hrstatus, + dwnumitems, + pannotationvalues, + phrerrors, + ) + .ok() + } + } + pub unsafe fn OnInsertAnnotations( + &self, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + dwcount: u32, + phclients: *const u32, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).OnInsertAnnotations)( + windows_core::Interface::as_raw(self), + dwtransactionid, + hrstatus, + dwcount, + phclients, + phrerrors, + ) + .ok() + } + } + pub unsafe fn OnPlayback( + &self, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + dwnumitems: u32, + ppitemvalues: *const *const tagOPCHDA_ITEM, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).OnPlayback)( + windows_core::Interface::as_raw(self), + dwtransactionid, + hrstatus, + dwnumitems, + ppitemvalues, + phrerrors, + ) + .ok() + } + } + pub unsafe fn OnUpdateComplete( + &self, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + dwcount: u32, + phclients: *const u32, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).OnUpdateComplete)( + windows_core::Interface::as_raw(self), + dwtransactionid, + hrstatus, + dwcount, + phclients, + phrerrors, + ) + .ok() + } + } + pub unsafe fn OnCancelComplete(&self, dwcancelid: u32) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).OnCancelComplete)( + windows_core::Interface::as_raw(self), + dwcancelid, + ) + .ok() + } + } +} +#[repr(C)] +#[doc(hidden)] +pub struct IOPCHDA_DataCallback_Vtbl { + pub base__: windows_core::IUnknown_Vtbl, + pub OnDataChange: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + windows_core::HRESULT, + u32, + *const tagOPCHDA_ITEM, + *const windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub OnReadComplete: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + windows_core::HRESULT, + u32, + *const tagOPCHDA_ITEM, + *const windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub OnReadModifiedComplete: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + windows_core::HRESULT, + u32, + *const tagOPCHDA_MODIFIEDITEM, + *const windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub OnReadAttributeComplete: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + windows_core::HRESULT, + u32, + u32, + *const tagOPCHDA_ATTRIBUTE, + *const windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub OnReadAnnotations: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + windows_core::HRESULT, + u32, + *const tagOPCHDA_ANNOTATION, + *const windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub OnInsertAnnotations: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + windows_core::HRESULT, + u32, + *const u32, + *const windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub OnPlayback: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + windows_core::HRESULT, + u32, + *const *const tagOPCHDA_ITEM, + *const windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub OnUpdateComplete: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + windows_core::HRESULT, + u32, + *const u32, + *const windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub OnCancelComplete: + unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT, +} +pub trait IOPCHDA_DataCallback_Impl: windows_core::IUnknownImpl { + fn OnDataChange( + &self, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + dwnumitems: u32, + pitemvalues: *const tagOPCHDA_ITEM, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn OnReadComplete( + &self, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + dwnumitems: u32, + pitemvalues: *const tagOPCHDA_ITEM, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn OnReadModifiedComplete( + &self, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + dwnumitems: u32, + pitemvalues: *const tagOPCHDA_MODIFIEDITEM, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn OnReadAttributeComplete( + &self, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + hclient: u32, + dwnumitems: u32, + pattributevalues: *const tagOPCHDA_ATTRIBUTE, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn OnReadAnnotations( + &self, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + dwnumitems: u32, + pannotationvalues: *const tagOPCHDA_ANNOTATION, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn OnInsertAnnotations( + &self, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + dwcount: u32, + phclients: *const u32, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn OnPlayback( + &self, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + dwnumitems: u32, + ppitemvalues: *const *const tagOPCHDA_ITEM, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn OnUpdateComplete( + &self, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + dwcount: u32, + phclients: *const u32, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn OnCancelComplete(&self, dwcancelid: u32) -> windows_core::Result<()>; +} +impl IOPCHDA_DataCallback_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn OnDataChange< + Identity: IOPCHDA_DataCallback_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + dwnumitems: u32, + pitemvalues: *const tagOPCHDA_ITEM, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_DataCallback_Impl::OnDataChange( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&hrstatus), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&pitemvalues), + core::mem::transmute_copy(&phrerrors), + ) + .into() + } + } + unsafe extern "system" fn OnReadComplete< + Identity: IOPCHDA_DataCallback_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + dwnumitems: u32, + pitemvalues: *const tagOPCHDA_ITEM, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_DataCallback_Impl::OnReadComplete( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&hrstatus), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&pitemvalues), + core::mem::transmute_copy(&phrerrors), + ) + .into() + } + } + unsafe extern "system" fn OnReadModifiedComplete< + Identity: IOPCHDA_DataCallback_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + dwnumitems: u32, + pitemvalues: *const tagOPCHDA_MODIFIEDITEM, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_DataCallback_Impl::OnReadModifiedComplete( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&hrstatus), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&pitemvalues), + core::mem::transmute_copy(&phrerrors), + ) + .into() + } + } + unsafe extern "system" fn OnReadAttributeComplete< + Identity: IOPCHDA_DataCallback_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + hclient: u32, + dwnumitems: u32, + pattributevalues: *const tagOPCHDA_ATTRIBUTE, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_DataCallback_Impl::OnReadAttributeComplete( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&hrstatus), + core::mem::transmute_copy(&hclient), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&pattributevalues), + core::mem::transmute_copy(&phrerrors), + ) + .into() + } + } + unsafe extern "system" fn OnReadAnnotations< + Identity: IOPCHDA_DataCallback_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + dwnumitems: u32, + pannotationvalues: *const tagOPCHDA_ANNOTATION, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_DataCallback_Impl::OnReadAnnotations( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&hrstatus), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&pannotationvalues), + core::mem::transmute_copy(&phrerrors), + ) + .into() + } + } + unsafe extern "system" fn OnInsertAnnotations< + Identity: IOPCHDA_DataCallback_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + dwcount: u32, + phclients: *const u32, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_DataCallback_Impl::OnInsertAnnotations( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&hrstatus), + core::mem::transmute_copy(&dwcount), + core::mem::transmute_copy(&phclients), + core::mem::transmute_copy(&phrerrors), + ) + .into() + } + } + unsafe extern "system" fn OnPlayback< + Identity: IOPCHDA_DataCallback_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + dwnumitems: u32, + ppitemvalues: *const *const tagOPCHDA_ITEM, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_DataCallback_Impl::OnPlayback( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&hrstatus), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&ppitemvalues), + core::mem::transmute_copy(&phrerrors), + ) + .into() + } + } + unsafe extern "system" fn OnUpdateComplete< + Identity: IOPCHDA_DataCallback_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + hrstatus: windows_core::HRESULT, + dwcount: u32, + phclients: *const u32, + phrerrors: *const windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_DataCallback_Impl::OnUpdateComplete( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&hrstatus), + core::mem::transmute_copy(&dwcount), + core::mem::transmute_copy(&phclients), + core::mem::transmute_copy(&phrerrors), + ) + .into() + } + } + unsafe extern "system" fn OnCancelComplete< + Identity: IOPCHDA_DataCallback_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwcancelid: u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_DataCallback_Impl::OnCancelComplete( + this, + core::mem::transmute_copy(&dwcancelid), + ) + .into() + } + } + Self { + base__: windows_core::IUnknown_Vtbl::new::(), + OnDataChange: OnDataChange::, + OnReadComplete: OnReadComplete::, + OnReadModifiedComplete: OnReadModifiedComplete::, + OnReadAttributeComplete: OnReadAttributeComplete::, + OnReadAnnotations: OnReadAnnotations::, + OnInsertAnnotations: OnInsertAnnotations::, + OnPlayback: OnPlayback::, + OnUpdateComplete: OnUpdateComplete::, + OnCancelComplete: OnCancelComplete::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +impl windows_core::RuntimeName for IOPCHDA_DataCallback {} +windows_core::imp::define_interface!( + IOPCHDA_Playback, + IOPCHDA_Playback_Vtbl, + 0x1f1217b8_dee0_11d2_a5e5_000086339399 +); +windows_core::imp::interface_hierarchy!(IOPCHDA_Playback, windows_core::IUnknown); +impl IOPCHDA_Playback { + pub unsafe fn ReadRawWithUpdate( + &self, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumvalues: u32, + ftupdateduration: windows::Win32::Foundation::FILETIME, + ftupdateinterval: windows::Win32::Foundation::FILETIME, + dwnumitems: u32, + phserver: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).ReadRawWithUpdate)( + windows_core::Interface::as_raw(self), + dwtransactionid, + htstarttime as _, + htendtime as _, + dwnumvalues, + core::mem::transmute(ftupdateduration), + core::mem::transmute(ftupdateinterval), + dwnumitems, + phserver, + pdwcancelid as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn ReadProcessedWithUpdate( + &self, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + ftresampleinterval: windows::Win32::Foundation::FILETIME, + dwnumintervals: u32, + ftupdateinterval: windows::Win32::Foundation::FILETIME, + dwnumitems: u32, + phserver: *const u32, + haaggregate: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).ReadProcessedWithUpdate)( + windows_core::Interface::as_raw(self), + dwtransactionid, + htstarttime as _, + htendtime as _, + core::mem::transmute(ftresampleinterval), + dwnumintervals, + core::mem::transmute(ftupdateinterval), + dwnumitems, + phserver, + haaggregate, + pdwcancelid as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn Cancel(&self, dwcancelid: u32) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).Cancel)( + windows_core::Interface::as_raw(self), + dwcancelid, + ) + .ok() + } + } +} +#[repr(C)] +#[doc(hidden)] +pub struct IOPCHDA_Playback_Vtbl { + pub base__: windows_core::IUnknown_Vtbl, + pub ReadRawWithUpdate: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *mut tagOPCHDA_TIME, + *mut tagOPCHDA_TIME, + u32, + windows::Win32::Foundation::FILETIME, + windows::Win32::Foundation::FILETIME, + u32, + *const u32, + *mut u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub ReadProcessedWithUpdate: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *mut tagOPCHDA_TIME, + *mut tagOPCHDA_TIME, + windows::Win32::Foundation::FILETIME, + u32, + windows::Win32::Foundation::FILETIME, + u32, + *const u32, + *const u32, + *mut u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub Cancel: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT, +} +pub trait IOPCHDA_Playback_Impl: windows_core::IUnknownImpl { + fn ReadRawWithUpdate( + &self, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumvalues: u32, + ftupdateduration: &windows::Win32::Foundation::FILETIME, + ftupdateinterval: &windows::Win32::Foundation::FILETIME, + dwnumitems: u32, + phserver: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn ReadProcessedWithUpdate( + &self, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + ftresampleinterval: &windows::Win32::Foundation::FILETIME, + dwnumintervals: u32, + ftupdateinterval: &windows::Win32::Foundation::FILETIME, + dwnumitems: u32, + phserver: *const u32, + haaggregate: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn Cancel(&self, dwcancelid: u32) -> windows_core::Result<()>; +} +impl IOPCHDA_Playback_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn ReadRawWithUpdate< + Identity: IOPCHDA_Playback_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumvalues: u32, + ftupdateduration: windows::Win32::Foundation::FILETIME, + ftupdateinterval: windows::Win32::Foundation::FILETIME, + dwnumitems: u32, + phserver: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_Playback_Impl::ReadRawWithUpdate( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&htstarttime), + core::mem::transmute_copy(&htendtime), + core::mem::transmute_copy(&dwnumvalues), + core::mem::transmute(&ftupdateduration), + core::mem::transmute(&ftupdateinterval), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&pdwcancelid), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn ReadProcessedWithUpdate< + Identity: IOPCHDA_Playback_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwtransactionid: u32, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + ftresampleinterval: windows::Win32::Foundation::FILETIME, + dwnumintervals: u32, + ftupdateinterval: windows::Win32::Foundation::FILETIME, + dwnumitems: u32, + phserver: *const u32, + haaggregate: *const u32, + pdwcancelid: *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_Playback_Impl::ReadProcessedWithUpdate( + this, + core::mem::transmute_copy(&dwtransactionid), + core::mem::transmute_copy(&htstarttime), + core::mem::transmute_copy(&htendtime), + core::mem::transmute(&ftresampleinterval), + core::mem::transmute_copy(&dwnumintervals), + core::mem::transmute(&ftupdateinterval), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&haaggregate), + core::mem::transmute_copy(&pdwcancelid), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn Cancel( + this: *mut core::ffi::c_void, + dwcancelid: u32, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_Playback_Impl::Cancel(this, core::mem::transmute_copy(&dwcancelid)).into() + } + } + Self { + base__: windows_core::IUnknown_Vtbl::new::(), + ReadRawWithUpdate: ReadRawWithUpdate::, + ReadProcessedWithUpdate: ReadProcessedWithUpdate::, + Cancel: Cancel::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +impl windows_core::RuntimeName for IOPCHDA_Playback {} +windows_core::imp::define_interface!( + IOPCHDA_Server, + IOPCHDA_Server_Vtbl, + 0x1f1217b0_dee0_11d2_a5e5_000086339399 +); +windows_core::imp::interface_hierarchy!(IOPCHDA_Server, windows_core::IUnknown); +impl IOPCHDA_Server { + pub unsafe fn GetItemAttributes( + &self, + pdwcount: *mut u32, + ppdwattrid: *mut *mut u32, + ppszattrname: *mut *mut windows_core::PWSTR, + ppszattrdesc: *mut *mut windows_core::PWSTR, + ppvtattrdatatype: *mut *mut u16, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).GetItemAttributes)( + windows_core::Interface::as_raw(self), + pdwcount as _, + ppdwattrid as _, + ppszattrname as _, + ppszattrdesc as _, + ppvtattrdatatype as _, + ) + .ok() + } + } + pub unsafe fn GetAggregates( + &self, + pdwcount: *mut u32, + ppdwaggrid: *mut *mut u32, + ppszaggrname: *mut *mut windows_core::PWSTR, + ppszaggrdesc: *mut *mut windows_core::PWSTR, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).GetAggregates)( + windows_core::Interface::as_raw(self), + pdwcount as _, + ppdwaggrid as _, + ppszaggrname as _, + ppszaggrdesc as _, + ) + .ok() + } + } + pub unsafe fn GetHistorianStatus( + &self, + pwstatus: *mut tagOPCHDA_SERVERSTATUS, + pftcurrenttime: *mut *mut windows::Win32::Foundation::FILETIME, + pftstarttime: *mut *mut windows::Win32::Foundation::FILETIME, + pwmajorversion: *mut u16, + pwminorversion: *mut u16, + pwbuildnumber: *mut u16, + pdwmaxreturnvalues: *mut u32, + ppszstatusstring: *mut windows_core::PWSTR, + ppszvendorinfo: *mut windows_core::PWSTR, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).GetHistorianStatus)( + windows_core::Interface::as_raw(self), + pwstatus as _, + pftcurrenttime as _, + pftstarttime as _, + pwmajorversion as _, + pwminorversion as _, + pwbuildnumber as _, + pdwmaxreturnvalues as _, + ppszstatusstring as _, + ppszvendorinfo as _, + ) + .ok() + } + } + pub unsafe fn GetItemHandles( + &self, + dwcount: u32, + pszitemid: *const windows_core::PCWSTR, + phclient: *const u32, + pphserver: *mut *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).GetItemHandles)( + windows_core::Interface::as_raw(self), + dwcount, + pszitemid, + phclient, + pphserver as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn ReleaseItemHandles( + &self, + dwcount: u32, + phserver: *const u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).ReleaseItemHandles)( + windows_core::Interface::as_raw(self), + dwcount, + phserver, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn ValidateItemIDs( + &self, + dwcount: u32, + pszitemid: *const windows_core::PCWSTR, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).ValidateItemIDs)( + windows_core::Interface::as_raw(self), + dwcount, + pszitemid, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn CreateBrowse( + &self, + dwcount: u32, + pdwattrid: *const u32, + poperator: *const tagOPCHDA_OPERATORCODES, + vfilter: *const windows::Win32::System::Variant::VARIANT, + pphbrowser: *mut Option, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).CreateBrowse)( + windows_core::Interface::as_raw(self), + dwcount, + pdwattrid, + poperator, + core::mem::transmute(vfilter), + core::mem::transmute(pphbrowser), + pperrors as _, + ) + .ok() + } + } +} +#[repr(C)] +#[doc(hidden)] +pub struct IOPCHDA_Server_Vtbl { + pub base__: windows_core::IUnknown_Vtbl, + pub GetItemAttributes: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut u32, + *mut *mut u32, + *mut *mut windows_core::PWSTR, + *mut *mut windows_core::PWSTR, + *mut *mut u16, + ) -> windows_core::HRESULT, + pub GetAggregates: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut u32, + *mut *mut u32, + *mut *mut windows_core::PWSTR, + *mut *mut windows_core::PWSTR, + ) -> windows_core::HRESULT, + pub GetHistorianStatus: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut tagOPCHDA_SERVERSTATUS, + *mut *mut windows::Win32::Foundation::FILETIME, + *mut *mut windows::Win32::Foundation::FILETIME, + *mut u16, + *mut u16, + *mut u16, + *mut u32, + *mut windows_core::PWSTR, + *mut windows_core::PWSTR, + ) -> windows_core::HRESULT, + pub GetItemHandles: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const windows_core::PCWSTR, + *const u32, + *mut *mut u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub ReleaseItemHandles: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub ValidateItemIDs: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const windows_core::PCWSTR, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub CreateBrowse: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const u32, + *const tagOPCHDA_OPERATORCODES, + *const windows::Win32::System::Variant::VARIANT, + *mut *mut core::ffi::c_void, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, +} +pub trait IOPCHDA_Server_Impl: windows_core::IUnknownImpl { + fn GetItemAttributes( + &self, + pdwcount: *mut u32, + ppdwattrid: *mut *mut u32, + ppszattrname: *mut *mut windows_core::PWSTR, + ppszattrdesc: *mut *mut windows_core::PWSTR, + ppvtattrdatatype: *mut *mut u16, + ) -> windows_core::Result<()>; + fn GetAggregates( + &self, + pdwcount: *mut u32, + ppdwaggrid: *mut *mut u32, + ppszaggrname: *mut *mut windows_core::PWSTR, + ppszaggrdesc: *mut *mut windows_core::PWSTR, + ) -> windows_core::Result<()>; + fn GetHistorianStatus( + &self, + pwstatus: *mut tagOPCHDA_SERVERSTATUS, + pftcurrenttime: *mut *mut windows::Win32::Foundation::FILETIME, + pftstarttime: *mut *mut windows::Win32::Foundation::FILETIME, + pwmajorversion: *mut u16, + pwminorversion: *mut u16, + pwbuildnumber: *mut u16, + pdwmaxreturnvalues: *mut u32, + ppszstatusstring: *mut windows_core::PWSTR, + ppszvendorinfo: *mut windows_core::PWSTR, + ) -> windows_core::Result<()>; + fn GetItemHandles( + &self, + dwcount: u32, + pszitemid: *const windows_core::PCWSTR, + phclient: *const u32, + pphserver: *mut *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn ReleaseItemHandles( + &self, + dwcount: u32, + phserver: *const u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn ValidateItemIDs( + &self, + dwcount: u32, + pszitemid: *const windows_core::PCWSTR, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn CreateBrowse( + &self, + dwcount: u32, + pdwattrid: *const u32, + poperator: *const tagOPCHDA_OPERATORCODES, + vfilter: *const windows::Win32::System::Variant::VARIANT, + pphbrowser: windows_core::OutRef<'_, IOPCHDA_Browser>, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; +} +impl IOPCHDA_Server_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn GetItemAttributes< + Identity: IOPCHDA_Server_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pdwcount: *mut u32, + ppdwattrid: *mut *mut u32, + ppszattrname: *mut *mut windows_core::PWSTR, + ppszattrdesc: *mut *mut windows_core::PWSTR, + ppvtattrdatatype: *mut *mut u16, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_Server_Impl::GetItemAttributes( + this, + core::mem::transmute_copy(&pdwcount), + core::mem::transmute_copy(&ppdwattrid), + core::mem::transmute_copy(&ppszattrname), + core::mem::transmute_copy(&ppszattrdesc), + core::mem::transmute_copy(&ppvtattrdatatype), + ) + .into() + } + } + unsafe extern "system" fn GetAggregates< + Identity: IOPCHDA_Server_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pdwcount: *mut u32, + ppdwaggrid: *mut *mut u32, + ppszaggrname: *mut *mut windows_core::PWSTR, + ppszaggrdesc: *mut *mut windows_core::PWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_Server_Impl::GetAggregates( + this, + core::mem::transmute_copy(&pdwcount), + core::mem::transmute_copy(&ppdwaggrid), + core::mem::transmute_copy(&ppszaggrname), + core::mem::transmute_copy(&ppszaggrdesc), + ) + .into() + } + } + unsafe extern "system" fn GetHistorianStatus< + Identity: IOPCHDA_Server_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pwstatus: *mut tagOPCHDA_SERVERSTATUS, + pftcurrenttime: *mut *mut windows::Win32::Foundation::FILETIME, + pftstarttime: *mut *mut windows::Win32::Foundation::FILETIME, + pwmajorversion: *mut u16, + pwminorversion: *mut u16, + pwbuildnumber: *mut u16, + pdwmaxreturnvalues: *mut u32, + ppszstatusstring: *mut windows_core::PWSTR, + ppszvendorinfo: *mut windows_core::PWSTR, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_Server_Impl::GetHistorianStatus( + this, + core::mem::transmute_copy(&pwstatus), + core::mem::transmute_copy(&pftcurrenttime), + core::mem::transmute_copy(&pftstarttime), + core::mem::transmute_copy(&pwmajorversion), + core::mem::transmute_copy(&pwminorversion), + core::mem::transmute_copy(&pwbuildnumber), + core::mem::transmute_copy(&pdwmaxreturnvalues), + core::mem::transmute_copy(&ppszstatusstring), + core::mem::transmute_copy(&ppszvendorinfo), + ) + .into() + } + } + unsafe extern "system" fn GetItemHandles< + Identity: IOPCHDA_Server_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwcount: u32, + pszitemid: *const windows_core::PCWSTR, + phclient: *const u32, + pphserver: *mut *mut u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_Server_Impl::GetItemHandles( + this, + core::mem::transmute_copy(&dwcount), + core::mem::transmute_copy(&pszitemid), + core::mem::transmute_copy(&phclient), + core::mem::transmute_copy(&pphserver), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn ReleaseItemHandles< + Identity: IOPCHDA_Server_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwcount: u32, + phserver: *const u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_Server_Impl::ReleaseItemHandles( + this, + core::mem::transmute_copy(&dwcount), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn ValidateItemIDs< + Identity: IOPCHDA_Server_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwcount: u32, + pszitemid: *const windows_core::PCWSTR, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_Server_Impl::ValidateItemIDs( + this, + core::mem::transmute_copy(&dwcount), + core::mem::transmute_copy(&pszitemid), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn CreateBrowse< + Identity: IOPCHDA_Server_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwcount: u32, + pdwattrid: *const u32, + poperator: *const tagOPCHDA_OPERATORCODES, + vfilter: *const windows::Win32::System::Variant::VARIANT, + pphbrowser: *mut *mut core::ffi::c_void, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_Server_Impl::CreateBrowse( + this, + core::mem::transmute_copy(&dwcount), + core::mem::transmute_copy(&pdwattrid), + core::mem::transmute_copy(&poperator), + core::mem::transmute_copy(&vfilter), + core::mem::transmute_copy(&pphbrowser), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + Self { + base__: windows_core::IUnknown_Vtbl::new::(), + GetItemAttributes: GetItemAttributes::, + GetAggregates: GetAggregates::, + GetHistorianStatus: GetHistorianStatus::, + GetItemHandles: GetItemHandles::, + ReleaseItemHandles: ReleaseItemHandles::, + ValidateItemIDs: ValidateItemIDs::, + CreateBrowse: CreateBrowse::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +impl windows_core::RuntimeName for IOPCHDA_Server {} +windows_core::imp::define_interface!( + IOPCHDA_SyncAnnotations, + IOPCHDA_SyncAnnotations_Vtbl, + 0x1f1217b4_dee0_11d2_a5e5_000086339399 +); +windows_core::imp::interface_hierarchy!(IOPCHDA_SyncAnnotations, windows_core::IUnknown); +impl IOPCHDA_SyncAnnotations { + pub unsafe fn QueryCapabilities( + &self, + ) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).QueryCapabilities)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn Read( + &self, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumitems: u32, + phserver: *const u32, + ppannotationvalues: *mut *mut tagOPCHDA_ANNOTATION, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).Read)( + windows_core::Interface::as_raw(self), + htstarttime as _, + htendtime as _, + dwnumitems, + phserver, + ppannotationvalues as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn Insert( + &self, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + pannotationvalues: *const tagOPCHDA_ANNOTATION, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).Insert)( + windows_core::Interface::as_raw(self), + dwnumitems, + phserver, + fttimestamps, + pannotationvalues, + pperrors as _, + ) + .ok() + } + } +} +#[repr(C)] +#[doc(hidden)] +pub struct IOPCHDA_SyncAnnotations_Vtbl { + pub base__: windows_core::IUnknown_Vtbl, + pub QueryCapabilities: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut tagOPCHDA_ANNOTATIONCAPABILITIES, + ) -> windows_core::HRESULT, + pub Read: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut tagOPCHDA_TIME, + *mut tagOPCHDA_TIME, + u32, + *const u32, + *mut *mut tagOPCHDA_ANNOTATION, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub Insert: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const u32, + *const windows::Win32::Foundation::FILETIME, + *const tagOPCHDA_ANNOTATION, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, +} +pub trait IOPCHDA_SyncAnnotations_Impl: windows_core::IUnknownImpl { + fn QueryCapabilities(&self) -> windows_core::Result; + fn Read( + &self, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumitems: u32, + phserver: *const u32, + ppannotationvalues: *mut *mut tagOPCHDA_ANNOTATION, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn Insert( + &self, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + pannotationvalues: *const tagOPCHDA_ANNOTATION, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; +} +impl IOPCHDA_SyncAnnotations_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn QueryCapabilities< + Identity: IOPCHDA_SyncAnnotations_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pcapabilities: *mut tagOPCHDA_ANNOTATIONCAPABILITIES, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCHDA_SyncAnnotations_Impl::QueryCapabilities(this) { + Ok(ok__) => { + pcapabilities.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn Read< + Identity: IOPCHDA_SyncAnnotations_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumitems: u32, + phserver: *const u32, + ppannotationvalues: *mut *mut tagOPCHDA_ANNOTATION, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_SyncAnnotations_Impl::Read( + this, + core::mem::transmute_copy(&htstarttime), + core::mem::transmute_copy(&htendtime), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&ppannotationvalues), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn Insert< + Identity: IOPCHDA_SyncAnnotations_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + pannotationvalues: *const tagOPCHDA_ANNOTATION, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_SyncAnnotations_Impl::Insert( + this, + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&fttimestamps), + core::mem::transmute_copy(&pannotationvalues), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + Self { + base__: windows_core::IUnknown_Vtbl::new::(), + QueryCapabilities: QueryCapabilities::, + Read: Read::, + Insert: Insert::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +impl windows_core::RuntimeName for IOPCHDA_SyncAnnotations {} +windows_core::imp::define_interface!( + IOPCHDA_SyncRead, + IOPCHDA_SyncRead_Vtbl, + 0x1f1217b2_dee0_11d2_a5e5_000086339399 +); +windows_core::imp::interface_hierarchy!(IOPCHDA_SyncRead, windows_core::IUnknown); +impl IOPCHDA_SyncRead { + pub unsafe fn ReadRaw( + &self, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumvalues: u32, + bbounds: bool, + dwnumitems: u32, + phserver: *const u32, + ppitemvalues: *mut *mut tagOPCHDA_ITEM, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).ReadRaw)( + windows_core::Interface::as_raw(self), + htstarttime as _, + htendtime as _, + dwnumvalues, + bbounds.into(), + dwnumitems, + phserver, + ppitemvalues as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn ReadProcessed( + &self, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + ftresampleinterval: windows::Win32::Foundation::FILETIME, + dwnumitems: u32, + phserver: *const u32, + haaggregate: *const u32, + ppitemvalues: *mut *mut tagOPCHDA_ITEM, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).ReadProcessed)( + windows_core::Interface::as_raw(self), + htstarttime as _, + htendtime as _, + core::mem::transmute(ftresampleinterval), + dwnumitems, + phserver, + haaggregate, + ppitemvalues as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn ReadAtTime( + &self, + fttimestamps: &[windows::Win32::Foundation::FILETIME], + dwnumitems: u32, + phserver: *const u32, + ppitemvalues: *mut *mut tagOPCHDA_ITEM, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).ReadAtTime)( + windows_core::Interface::as_raw(self), + fttimestamps.len().try_into().unwrap(), + core::mem::transmute(fttimestamps.as_ptr()), + dwnumitems, + phserver, + ppitemvalues as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn ReadModified( + &self, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumvalues: u32, + dwnumitems: u32, + phserver: *const u32, + ppitemvalues: *mut *mut tagOPCHDA_MODIFIEDITEM, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).ReadModified)( + windows_core::Interface::as_raw(self), + htstarttime as _, + htendtime as _, + dwnumvalues, + dwnumitems, + phserver, + ppitemvalues as _, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn ReadAttribute( + &self, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + hserver: u32, + dwnumattributes: u32, + pdwattributeids: *const u32, + ppattributevalues: *mut *mut tagOPCHDA_ATTRIBUTE, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).ReadAttribute)( + windows_core::Interface::as_raw(self), + htstarttime as _, + htendtime as _, + hserver, + dwnumattributes, + pdwattributeids, + ppattributevalues as _, + pperrors as _, + ) + .ok() + } + } +} +#[repr(C)] +#[doc(hidden)] +pub struct IOPCHDA_SyncRead_Vtbl { + pub base__: windows_core::IUnknown_Vtbl, + pub ReadRaw: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut tagOPCHDA_TIME, + *mut tagOPCHDA_TIME, + u32, + windows_core::BOOL, + u32, + *const u32, + *mut *mut tagOPCHDA_ITEM, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub ReadProcessed: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut tagOPCHDA_TIME, + *mut tagOPCHDA_TIME, + windows::Win32::Foundation::FILETIME, + u32, + *const u32, + *const u32, + *mut *mut tagOPCHDA_ITEM, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub ReadAtTime: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const windows::Win32::Foundation::FILETIME, + u32, + *const u32, + *mut *mut tagOPCHDA_ITEM, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub ReadModified: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut tagOPCHDA_TIME, + *mut tagOPCHDA_TIME, + u32, + u32, + *const u32, + *mut *mut tagOPCHDA_MODIFIEDITEM, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub ReadAttribute: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut tagOPCHDA_TIME, + *mut tagOPCHDA_TIME, + u32, + u32, + *const u32, + *mut *mut tagOPCHDA_ATTRIBUTE, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, +} +pub trait IOPCHDA_SyncRead_Impl: windows_core::IUnknownImpl { + fn ReadRaw( + &self, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumvalues: u32, + bbounds: windows_core::BOOL, + dwnumitems: u32, + phserver: *const u32, + ppitemvalues: *mut *mut tagOPCHDA_ITEM, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn ReadProcessed( + &self, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + ftresampleinterval: &windows::Win32::Foundation::FILETIME, + dwnumitems: u32, + phserver: *const u32, + haaggregate: *const u32, + ppitemvalues: *mut *mut tagOPCHDA_ITEM, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn ReadAtTime( + &self, + dwnumtimestamps: u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + dwnumitems: u32, + phserver: *const u32, + ppitemvalues: *mut *mut tagOPCHDA_ITEM, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn ReadModified( + &self, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumvalues: u32, + dwnumitems: u32, + phserver: *const u32, + ppitemvalues: *mut *mut tagOPCHDA_MODIFIEDITEM, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn ReadAttribute( + &self, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + hserver: u32, + dwnumattributes: u32, + pdwattributeids: *const u32, + ppattributevalues: *mut *mut tagOPCHDA_ATTRIBUTE, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; +} +impl IOPCHDA_SyncRead_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn ReadRaw( + this: *mut core::ffi::c_void, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumvalues: u32, + bbounds: windows_core::BOOL, + dwnumitems: u32, + phserver: *const u32, + ppitemvalues: *mut *mut tagOPCHDA_ITEM, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_SyncRead_Impl::ReadRaw( + this, + core::mem::transmute_copy(&htstarttime), + core::mem::transmute_copy(&htendtime), + core::mem::transmute_copy(&dwnumvalues), + core::mem::transmute_copy(&bbounds), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&ppitemvalues), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn ReadProcessed< + Identity: IOPCHDA_SyncRead_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + ftresampleinterval: windows::Win32::Foundation::FILETIME, + dwnumitems: u32, + phserver: *const u32, + haaggregate: *const u32, + ppitemvalues: *mut *mut tagOPCHDA_ITEM, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_SyncRead_Impl::ReadProcessed( + this, + core::mem::transmute_copy(&htstarttime), + core::mem::transmute_copy(&htendtime), + core::mem::transmute(&ftresampleinterval), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&haaggregate), + core::mem::transmute_copy(&ppitemvalues), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn ReadAtTime< + Identity: IOPCHDA_SyncRead_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwnumtimestamps: u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + dwnumitems: u32, + phserver: *const u32, + ppitemvalues: *mut *mut tagOPCHDA_ITEM, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_SyncRead_Impl::ReadAtTime( + this, + core::mem::transmute_copy(&dwnumtimestamps), + core::mem::transmute_copy(&fttimestamps), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&ppitemvalues), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn ReadModified< + Identity: IOPCHDA_SyncRead_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumvalues: u32, + dwnumitems: u32, + phserver: *const u32, + ppitemvalues: *mut *mut tagOPCHDA_MODIFIEDITEM, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_SyncRead_Impl::ReadModified( + this, + core::mem::transmute_copy(&htstarttime), + core::mem::transmute_copy(&htendtime), + core::mem::transmute_copy(&dwnumvalues), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&ppitemvalues), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn ReadAttribute< + Identity: IOPCHDA_SyncRead_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + hserver: u32, + dwnumattributes: u32, + pdwattributeids: *const u32, + ppattributevalues: *mut *mut tagOPCHDA_ATTRIBUTE, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_SyncRead_Impl::ReadAttribute( + this, + core::mem::transmute_copy(&htstarttime), + core::mem::transmute_copy(&htendtime), + core::mem::transmute_copy(&hserver), + core::mem::transmute_copy(&dwnumattributes), + core::mem::transmute_copy(&pdwattributeids), + core::mem::transmute_copy(&ppattributevalues), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + Self { + base__: windows_core::IUnknown_Vtbl::new::(), + ReadRaw: ReadRaw::, + ReadProcessed: ReadProcessed::, + ReadAtTime: ReadAtTime::, + ReadModified: ReadModified::, + ReadAttribute: ReadAttribute::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +impl windows_core::RuntimeName for IOPCHDA_SyncRead {} +windows_core::imp::define_interface!( + IOPCHDA_SyncUpdate, + IOPCHDA_SyncUpdate_Vtbl, + 0x1f1217b3_dee0_11d2_a5e5_000086339399 +); +windows_core::imp::interface_hierarchy!(IOPCHDA_SyncUpdate, windows_core::IUnknown); +impl IOPCHDA_SyncUpdate { + pub unsafe fn QueryCapabilities(&self) -> windows_core::Result { + unsafe { + let mut result__ = core::mem::zeroed(); + (windows_core::Interface::vtable(self).QueryCapabilities)( + windows_core::Interface::as_raw(self), + &mut result__, + ) + .map(|| result__) + } + } + pub unsafe fn Insert( + &self, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + vdatavalues: *const windows::Win32::System::Variant::VARIANT, + pdwqualities: *const u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).Insert)( + windows_core::Interface::as_raw(self), + dwnumitems, + phserver, + fttimestamps, + core::mem::transmute(vdatavalues), + pdwqualities, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn Replace( + &self, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + vdatavalues: *const windows::Win32::System::Variant::VARIANT, + pdwqualities: *const u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).Replace)( + windows_core::Interface::as_raw(self), + dwnumitems, + phserver, + fttimestamps, + core::mem::transmute(vdatavalues), + pdwqualities, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn InsertReplace( + &self, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + vdatavalues: *const windows::Win32::System::Variant::VARIANT, + pdwqualities: *const u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).InsertReplace)( + windows_core::Interface::as_raw(self), + dwnumitems, + phserver, + fttimestamps, + core::mem::transmute(vdatavalues), + pdwqualities, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn DeleteRaw( + &self, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumitems: u32, + phserver: *const u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).DeleteRaw)( + windows_core::Interface::as_raw(self), + htstarttime as _, + htendtime as _, + dwnumitems, + phserver, + pperrors as _, + ) + .ok() + } + } + pub unsafe fn DeleteAtTime( + &self, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()> { + unsafe { + (windows_core::Interface::vtable(self).DeleteAtTime)( + windows_core::Interface::as_raw(self), + dwnumitems, + phserver, + fttimestamps, + pperrors as _, + ) + .ok() + } + } +} +#[repr(C)] +#[doc(hidden)] +pub struct IOPCHDA_SyncUpdate_Vtbl { + pub base__: windows_core::IUnknown_Vtbl, + pub QueryCapabilities: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut tagOPCHDA_UPDATECAPABILITIES, + ) -> windows_core::HRESULT, + pub Insert: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const u32, + *const windows::Win32::Foundation::FILETIME, + *const windows::Win32::System::Variant::VARIANT, + *const u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub Replace: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const u32, + *const windows::Win32::Foundation::FILETIME, + *const windows::Win32::System::Variant::VARIANT, + *const u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub InsertReplace: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const u32, + *const windows::Win32::Foundation::FILETIME, + *const windows::Win32::System::Variant::VARIANT, + *const u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub DeleteRaw: unsafe extern "system" fn( + *mut core::ffi::c_void, + *mut tagOPCHDA_TIME, + *mut tagOPCHDA_TIME, + u32, + *const u32, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, + pub DeleteAtTime: unsafe extern "system" fn( + *mut core::ffi::c_void, + u32, + *const u32, + *const windows::Win32::Foundation::FILETIME, + *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT, +} +pub trait IOPCHDA_SyncUpdate_Impl: windows_core::IUnknownImpl { + fn QueryCapabilities(&self) -> windows_core::Result; + fn Insert( + &self, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + vdatavalues: *const windows::Win32::System::Variant::VARIANT, + pdwqualities: *const u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn Replace( + &self, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + vdatavalues: *const windows::Win32::System::Variant::VARIANT, + pdwqualities: *const u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn InsertReplace( + &self, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + vdatavalues: *const windows::Win32::System::Variant::VARIANT, + pdwqualities: *const u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn DeleteRaw( + &self, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumitems: u32, + phserver: *const u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; + fn DeleteAtTime( + &self, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::Result<()>; +} +impl IOPCHDA_SyncUpdate_Vtbl { + pub const fn new() -> Self { + unsafe extern "system" fn QueryCapabilities< + Identity: IOPCHDA_SyncUpdate_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + pcapabilities: *mut tagOPCHDA_UPDATECAPABILITIES, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + match IOPCHDA_SyncUpdate_Impl::QueryCapabilities(this) { + Ok(ok__) => { + pcapabilities.write(core::mem::transmute(ok__)); + windows_core::HRESULT(0) + } + Err(err) => err.into(), + } + } + } + unsafe extern "system" fn Insert( + this: *mut core::ffi::c_void, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + vdatavalues: *const windows::Win32::System::Variant::VARIANT, + pdwqualities: *const u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_SyncUpdate_Impl::Insert( + this, + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&fttimestamps), + core::mem::transmute_copy(&vdatavalues), + core::mem::transmute_copy(&pdwqualities), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn Replace< + Identity: IOPCHDA_SyncUpdate_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + vdatavalues: *const windows::Win32::System::Variant::VARIANT, + pdwqualities: *const u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_SyncUpdate_Impl::Replace( + this, + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&fttimestamps), + core::mem::transmute_copy(&vdatavalues), + core::mem::transmute_copy(&pdwqualities), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn InsertReplace< + Identity: IOPCHDA_SyncUpdate_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + vdatavalues: *const windows::Win32::System::Variant::VARIANT, + pdwqualities: *const u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_SyncUpdate_Impl::InsertReplace( + this, + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&fttimestamps), + core::mem::transmute_copy(&vdatavalues), + core::mem::transmute_copy(&pdwqualities), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn DeleteRaw< + Identity: IOPCHDA_SyncUpdate_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + htstarttime: *mut tagOPCHDA_TIME, + htendtime: *mut tagOPCHDA_TIME, + dwnumitems: u32, + phserver: *const u32, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_SyncUpdate_Impl::DeleteRaw( + this, + core::mem::transmute_copy(&htstarttime), + core::mem::transmute_copy(&htendtime), + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + unsafe extern "system" fn DeleteAtTime< + Identity: IOPCHDA_SyncUpdate_Impl, + const OFFSET: isize, + >( + this: *mut core::ffi::c_void, + dwnumitems: u32, + phserver: *const u32, + fttimestamps: *const windows::Win32::Foundation::FILETIME, + pperrors: *mut *mut windows_core::HRESULT, + ) -> windows_core::HRESULT { + unsafe { + let this: &Identity = + &*((this as *const *const ()).offset(OFFSET) as *const Identity); + IOPCHDA_SyncUpdate_Impl::DeleteAtTime( + this, + core::mem::transmute_copy(&dwnumitems), + core::mem::transmute_copy(&phserver), + core::mem::transmute_copy(&fttimestamps), + core::mem::transmute_copy(&pperrors), + ) + .into() + } + } + Self { + base__: windows_core::IUnknown_Vtbl::new::(), + QueryCapabilities: QueryCapabilities::, + Insert: Insert::, + Replace: Replace::, + InsertReplace: InsertReplace::, + DeleteRaw: DeleteRaw::, + DeleteAtTime: DeleteAtTime::, + } + } + pub fn matches(iid: &windows_core::GUID) -> bool { + iid == &::IID + } +} +impl windows_core::RuntimeName for IOPCHDA_SyncUpdate {} +pub const OPCHDA_AGGRNAME_ANNOTATIONS: windows_core::PCWSTR = windows_core::w!("Annotations"); +pub const OPCHDA_AGGRNAME_AVERAGE: windows_core::PCWSTR = windows_core::w!("Average"); +pub const OPCHDA_AGGRNAME_COUNT: windows_core::PCWSTR = windows_core::w!("Count"); +pub const OPCHDA_AGGRNAME_DELTA: windows_core::PCWSTR = windows_core::w!("Delta"); +pub const OPCHDA_AGGRNAME_DURATIONBAD: windows_core::PCWSTR = windows_core::w!("Duration Bad"); +pub const OPCHDA_AGGRNAME_DURATIONGOOD: windows_core::PCWSTR = windows_core::w!("Duration Good"); +pub const OPCHDA_AGGRNAME_END: windows_core::PCWSTR = windows_core::w!("End"); +pub const OPCHDA_AGGRNAME_INTERPOLATIVE: windows_core::PCWSTR = windows_core::w!("Interpolative"); +pub const OPCHDA_AGGRNAME_MAXIMUM: windows_core::PCWSTR = windows_core::w!("Maximum"); +pub const OPCHDA_AGGRNAME_MAXIMUMACTUALTIME: windows_core::PCWSTR = + windows_core::w!("Maximum Actual Time"); +pub const OPCHDA_AGGRNAME_MINIMUM: windows_core::PCWSTR = windows_core::w!("Minimum"); +pub const OPCHDA_AGGRNAME_MINIMUMACTUALTIME: windows_core::PCWSTR = + windows_core::w!("Minimum Actual Time"); +pub const OPCHDA_AGGRNAME_PERCENTBAD: windows_core::PCWSTR = windows_core::w!("Percent Bad"); +pub const OPCHDA_AGGRNAME_PERCENTGOOD: windows_core::PCWSTR = windows_core::w!("Percent Good"); +pub const OPCHDA_AGGRNAME_RANGE: windows_core::PCWSTR = windows_core::w!("Range"); +pub const OPCHDA_AGGRNAME_REGCONST: windows_core::PCWSTR = + windows_core::w!("Regression Line Constant"); +pub const OPCHDA_AGGRNAME_REGDEV: windows_core::PCWSTR = windows_core::w!("Regression Line Error"); +pub const OPCHDA_AGGRNAME_REGSLOPE: windows_core::PCWSTR = + windows_core::w!("Regression Line Slope"); +pub const OPCHDA_AGGRNAME_START: windows_core::PCWSTR = windows_core::w!("Start"); +pub const OPCHDA_AGGRNAME_STDEV: windows_core::PCWSTR = windows_core::w!("Standard Deviation"); +pub const OPCHDA_AGGRNAME_TIMEAVERAGE: windows_core::PCWSTR = windows_core::w!("Time Average"); +pub const OPCHDA_AGGRNAME_TOTAL: windows_core::PCWSTR = windows_core::w!("Total"); +pub const OPCHDA_AGGRNAME_VARIANCE: windows_core::PCWSTR = windows_core::w!("Variance"); +pub const OPCHDA_AGGRNAME_WORSTQUALITY: windows_core::PCWSTR = windows_core::w!("Worst Quality"); +pub const OPCHDA_ANNOTATIONS: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(24i32); +pub const OPCHDA_ARCHIVING: u32 = 5u32; +pub const OPCHDA_ATTRNAME_ARCHIVING: windows_core::PCWSTR = windows_core::w!("Archiving"); +pub const OPCHDA_ATTRNAME_DATA_TYPE: windows_core::PCWSTR = windows_core::w!("Data Type"); +pub const OPCHDA_ATTRNAME_DERIVE_EQUATION: windows_core::PCWSTR = + windows_core::w!("Derive Equation"); +pub const OPCHDA_ATTRNAME_DESCRIPTION: windows_core::PCWSTR = windows_core::w!("Description"); +pub const OPCHDA_ATTRNAME_ENG_UNITS: windows_core::PCWSTR = windows_core::w!("Eng Units"); +pub const OPCHDA_ATTRNAME_EXCEPTION_DEV: windows_core::PCWSTR = + windows_core::w!("Exception Deviation"); +pub const OPCHDA_ATTRNAME_EXCEPTION_DEV_TYPE: windows_core::PCWSTR = + windows_core::w!("Exception Dev Type"); +pub const OPCHDA_ATTRNAME_HIGH_ENTRY_LIMIT: windows_core::PCWSTR = + windows_core::w!("High Entry Limit"); +pub const OPCHDA_ATTRNAME_ITEMID: windows_core::PCWSTR = windows_core::w!("ItemID"); +pub const OPCHDA_ATTRNAME_LOW_ENTRY_LIMIT: windows_core::PCWSTR = + windows_core::w!("Low Entry Limit"); +pub const OPCHDA_ATTRNAME_MAX_TIME_INT: windows_core::PCWSTR = + windows_core::w!("Max Time Interval"); +pub const OPCHDA_ATTRNAME_MIN_TIME_INT: windows_core::PCWSTR = + windows_core::w!("Min Time Interval"); +pub const OPCHDA_ATTRNAME_NODE_NAME: windows_core::PCWSTR = windows_core::w!("Node Name"); +pub const OPCHDA_ATTRNAME_NORMAL_MAXIMUM: windows_core::PCWSTR = windows_core::w!("Normal Maximum"); +pub const OPCHDA_ATTRNAME_NORMAL_MINIMUM: windows_core::PCWSTR = windows_core::w!("Normal Minimum"); +pub const OPCHDA_ATTRNAME_PROCESS_NAME: windows_core::PCWSTR = windows_core::w!("Process Name"); +pub const OPCHDA_ATTRNAME_SOURCE_NAME: windows_core::PCWSTR = windows_core::w!("Source Name"); +pub const OPCHDA_ATTRNAME_SOURCE_TYPE: windows_core::PCWSTR = windows_core::w!("Source Type"); +pub const OPCHDA_ATTRNAME_STEPPED: windows_core::PCWSTR = windows_core::w!("Stepped"); +pub const OPCHDA_AVERAGE: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(3i32); +pub const OPCHDA_BRANCH: tagOPCHDA_BROWSETYPE = tagOPCHDA_BROWSETYPE(1i32); +pub const OPCHDA_BROWSE_DIRECT: tagOPCHDA_BROWSEDIRECTION = tagOPCHDA_BROWSEDIRECTION(3i32); +pub const OPCHDA_BROWSE_DOWN: tagOPCHDA_BROWSEDIRECTION = tagOPCHDA_BROWSEDIRECTION(2i32); +pub const OPCHDA_BROWSE_UP: tagOPCHDA_BROWSEDIRECTION = tagOPCHDA_BROWSEDIRECTION(1i32); +pub const OPCHDA_CALCULATED: u32 = 524288u32; +pub const OPCHDA_CONVERSION: u32 = 8388608u32; +pub const OPCHDA_COUNT: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(5i32); +pub const OPCHDA_DATALOST: u32 = 4194304u32; +pub const OPCHDA_DATA_TYPE: u32 = 1u32; +pub const OPCHDA_DELETE: tagOPCHDA_EDITTYPE = tagOPCHDA_EDITTYPE(4i32); +pub const OPCHDA_DELETEATTIMECAP: tagOPCHDA_UPDATECAPABILITIES = + tagOPCHDA_UPDATECAPABILITIES(16i32); +pub const OPCHDA_DELETERAWCAP: tagOPCHDA_UPDATECAPABILITIES = tagOPCHDA_UPDATECAPABILITIES(8i32); +pub const OPCHDA_DELTA: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(13i32); +pub const OPCHDA_DERIVE_EQUATION: u32 = 6u32; +pub const OPCHDA_DESCRIPTION: u32 = 2u32; +pub const OPCHDA_DOWN: tagOPCHDA_SERVERSTATUS = tagOPCHDA_SERVERSTATUS(2i32); +pub const OPCHDA_DURATIONBAD: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(20i32); +pub const OPCHDA_DURATIONGOOD: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(19i32); +pub const OPCHDA_END: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(12i32); +pub const OPCHDA_ENG_UNITS: u32 = 3u32; +pub const OPCHDA_EQUAL: tagOPCHDA_OPERATORCODES = tagOPCHDA_OPERATORCODES(1i32); +pub const OPCHDA_EXCEPTION_DEV: u32 = 16u32; +pub const OPCHDA_EXCEPTION_DEV_TYPE: u32 = 17u32; +pub const OPCHDA_EXTRADATA: u32 = 65536u32; +pub const OPCHDA_FLAT: tagOPCHDA_BROWSETYPE = tagOPCHDA_BROWSETYPE(3i32); +pub const OPCHDA_GREATER: tagOPCHDA_OPERATORCODES = tagOPCHDA_OPERATORCODES(4i32); +pub const OPCHDA_GREATEREQUAL: tagOPCHDA_OPERATORCODES = tagOPCHDA_OPERATORCODES(5i32); +pub const OPCHDA_HIGH_ENTRY_LIMIT: u32 = 18u32; +pub const OPCHDA_INDETERMINATE: tagOPCHDA_SERVERSTATUS = tagOPCHDA_SERVERSTATUS(3i32); +pub const OPCHDA_INSERT: tagOPCHDA_EDITTYPE = tagOPCHDA_EDITTYPE(1i32); +pub const OPCHDA_INSERTANNOTATIONCAP: tagOPCHDA_ANNOTATIONCAPABILITIES = + tagOPCHDA_ANNOTATIONCAPABILITIES(2i32); +pub const OPCHDA_INSERTCAP: tagOPCHDA_UPDATECAPABILITIES = tagOPCHDA_UPDATECAPABILITIES(1i32); +pub const OPCHDA_INSERTREPLACE: tagOPCHDA_EDITTYPE = tagOPCHDA_EDITTYPE(3i32); +pub const OPCHDA_INSERTREPLACECAP: tagOPCHDA_UPDATECAPABILITIES = + tagOPCHDA_UPDATECAPABILITIES(4i32); +pub const OPCHDA_INTERPOLATED: u32 = 131072u32; +pub const OPCHDA_INTERPOLATIVE: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(1i32); +pub const OPCHDA_ITEMID: u32 = 13u32; +pub const OPCHDA_ITEMS: tagOPCHDA_BROWSETYPE = tagOPCHDA_BROWSETYPE(4i32); +pub const OPCHDA_LEAF: tagOPCHDA_BROWSETYPE = tagOPCHDA_BROWSETYPE(2i32); +pub const OPCHDA_LESS: tagOPCHDA_OPERATORCODES = tagOPCHDA_OPERATORCODES(2i32); +pub const OPCHDA_LESSEQUAL: tagOPCHDA_OPERATORCODES = tagOPCHDA_OPERATORCODES(3i32); +pub const OPCHDA_LOW_ENTRY_LIMIT: u32 = 19u32; +pub const OPCHDA_MAXIMUM: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(10i32); +pub const OPCHDA_MAXIMUMACTUALTIME: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(9i32); +pub const OPCHDA_MAX_TIME_INT: u32 = 14u32; +pub const OPCHDA_MINIMUM: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(8i32); +pub const OPCHDA_MINIMUMACTUALTIME: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(7i32); +pub const OPCHDA_MIN_TIME_INT: u32 = 15u32; +pub const OPCHDA_NOAGGREGATE: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(0i32); +pub const OPCHDA_NOBOUND: u32 = 1048576u32; +pub const OPCHDA_NODATA: u32 = 2097152u32; +pub const OPCHDA_NODE_NAME: u32 = 7u32; +pub const OPCHDA_NORMAL_MAXIMUM: u32 = 11u32; +pub const OPCHDA_NORMAL_MINIMUM: u32 = 12u32; +pub const OPCHDA_NOTEQUAL: tagOPCHDA_OPERATORCODES = tagOPCHDA_OPERATORCODES(6i32); +pub const OPCHDA_PARTIAL: u32 = 16777216u32; +pub const OPCHDA_PERCENTBAD: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(22i32); +pub const OPCHDA_PERCENTGOOD: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(21i32); +pub const OPCHDA_PROCESS_NAME: u32 = 8u32; +pub const OPCHDA_RANGE: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(18i32); +pub const OPCHDA_RAW: u32 = 262144u32; +pub const OPCHDA_READANNOTATIONCAP: tagOPCHDA_ANNOTATIONCAPABILITIES = + tagOPCHDA_ANNOTATIONCAPABILITIES(1i32); +pub const OPCHDA_REGCONST: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(15i32); +pub const OPCHDA_REGDEV: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(16i32); +pub const OPCHDA_REGSLOPE: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(14i32); +pub const OPCHDA_REPLACE: tagOPCHDA_EDITTYPE = tagOPCHDA_EDITTYPE(2i32); +pub const OPCHDA_REPLACECAP: tagOPCHDA_UPDATECAPABILITIES = tagOPCHDA_UPDATECAPABILITIES(2i32); +pub const OPCHDA_SOURCE_NAME: u32 = 9u32; +pub const OPCHDA_SOURCE_TYPE: u32 = 10u32; +pub const OPCHDA_START: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(11i32); +pub const OPCHDA_STDEV: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(6i32); +pub const OPCHDA_STEPPED: u32 = 4u32; +pub const OPCHDA_TIMEAVERAGE: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(4i32); +pub const OPCHDA_TOTAL: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(2i32); +pub const OPCHDA_UP: tagOPCHDA_SERVERSTATUS = tagOPCHDA_SERVERSTATUS(1i32); +pub const OPCHDA_VARIANCE: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(17i32); +pub const OPCHDA_WORSTQUALITY: tagOPCHDA_AGGREGATE = tagOPCHDA_AGGREGATE(23i32); +pub const OPC_CATEGORY_DESCRIPTION_HDA10: windows_core::PCWSTR = + windows_core::w!("OPC History Data Access Servers Version 1.0"); +#[repr(transparent)] +#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] +pub struct tagOPCHDA_AGGREGATE(pub i32); +#[repr(C)] +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct tagOPCHDA_ANNOTATION { + pub hClient: u32, + pub dwNumValues: u32, + pub ftTimeStamps: *mut windows::Win32::Foundation::FILETIME, + pub szAnnotation: *mut windows_core::PWSTR, + pub ftAnnotationTime: *mut windows::Win32::Foundation::FILETIME, + pub szUser: *mut windows_core::PWSTR, +} +impl Default for tagOPCHDA_ANNOTATION { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } +} +#[repr(transparent)] +#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] +pub struct tagOPCHDA_ANNOTATIONCAPABILITIES(pub i32); +#[repr(C)] +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct tagOPCHDA_ATTRIBUTE { + pub hClient: u32, + pub dwNumValues: u32, + pub dwAttributeID: u32, + pub ftTimeStamps: *mut windows::Win32::Foundation::FILETIME, + pub vAttributeValues: *mut windows::Win32::System::Variant::VARIANT, +} +impl Default for tagOPCHDA_ATTRIBUTE { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } +} +#[repr(transparent)] +#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] +pub struct tagOPCHDA_BROWSEDIRECTION(pub i32); +#[repr(transparent)] +#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] +pub struct tagOPCHDA_BROWSETYPE(pub i32); +#[repr(transparent)] +#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] +pub struct tagOPCHDA_EDITTYPE(pub i32); +#[repr(C)] +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct tagOPCHDA_ITEM { + pub hClient: u32, + pub haAggregate: u32, + pub dwCount: u32, + pub pftTimeStamps: *mut windows::Win32::Foundation::FILETIME, + pub pdwQualities: *mut u32, + pub pvDataValues: *mut windows::Win32::System::Variant::VARIANT, +} +impl Default for tagOPCHDA_ITEM { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct tagOPCHDA_MODIFIEDITEM { + pub hClient: u32, + pub dwCount: u32, + pub pftTimeStamps: *mut windows::Win32::Foundation::FILETIME, + pub pdwQualities: *mut u32, + pub pvDataValues: *mut windows::Win32::System::Variant::VARIANT, + pub pftModificationTime: *mut windows::Win32::Foundation::FILETIME, + pub pEditType: *mut tagOPCHDA_EDITTYPE, + pub szUser: *mut windows_core::PWSTR, +} +impl Default for tagOPCHDA_MODIFIEDITEM { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } +} +#[repr(transparent)] +#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] +pub struct tagOPCHDA_OPERATORCODES(pub i32); +#[repr(transparent)] +#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] +pub struct tagOPCHDA_SERVERSTATUS(pub i32); +#[repr(C)] +#[derive(Clone, Copy, Debug, Default, PartialEq)] +pub struct tagOPCHDA_TIME { + pub bString: windows_core::BOOL, + pub szTime: windows_core::PWSTR, + pub ftTime: windows::Win32::Foundation::FILETIME, +} +#[repr(transparent)] +#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] +pub struct tagOPCHDA_UPDATECAPABILITIES(pub i32); diff --git a/opc_hda_bindings/src/lib.rs b/opc_hda_bindings/src/lib.rs new file mode 100644 index 0000000..892ac88 --- /dev/null +++ b/opc_hda_bindings/src/lib.rs @@ -0,0 +1,3 @@ +mod bindings; + +pub use bindings::*; From 82c46cf4d55eb769b56dcea2cc03bfd159b6d9e7 Mon Sep 17 00:00:00 2001 From: Ronbb Date: Sat, 12 Jul 2025 13:52:15 +0800 Subject: [PATCH 2/3] Update names --- opc_ae_bindings/Cargo.toml | 2 +- opc_ae_bindings/README.md | 2 +- opc_comn_bindings/Cargo.toml | 2 +- opc_hda_bindings/README.md | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/opc_ae_bindings/Cargo.toml b/opc_ae_bindings/Cargo.toml index fa473f9..c8dbda7 100644 --- a/opc_ae_bindings/Cargo.toml +++ b/opc_ae_bindings/Cargo.toml @@ -2,7 +2,7 @@ name = "opc_ae_bindings" version = "0.3.0" edition = "2024" -description = "OPC Historical Data Access bindings" +description = "OPC Alarms & Event bindings" readme = "README.md" repository = "https://github.com/Ronbb/rust_opc" license = "MIT" diff --git a/opc_ae_bindings/README.md b/opc_ae_bindings/README.md index f90a317..0eb2d41 100644 --- a/opc_ae_bindings/README.md +++ b/opc_ae_bindings/README.md @@ -1,4 +1,4 @@ -# OPC AE Bindings +# OPC Alarms & Event Bindings Please see docs on [docs.rs](https://docs.rs/opc_ae_bindings/). diff --git a/opc_comn_bindings/Cargo.toml b/opc_comn_bindings/Cargo.toml index 98a4172..966673e 100644 --- a/opc_comn_bindings/Cargo.toml +++ b/opc_comn_bindings/Cargo.toml @@ -2,7 +2,7 @@ name = "opc_comn_bindings" version = "0.3.0" edition = "2024" -description = "OPC Historical Data Access bindings" +description = "OPC Common bindings" readme = "README.md" repository = "https://github.com/Ronbb/rust_opc" license = "MIT" diff --git a/opc_hda_bindings/README.md b/opc_hda_bindings/README.md index b120e29..02f8f31 100644 --- a/opc_hda_bindings/README.md +++ b/opc_hda_bindings/README.md @@ -1,4 +1,4 @@ -# OPC HDA Bindings +# OPC Historial Data Access Bindings Please see docs on [docs.rs](https://docs.rs/opc_hda_bindings/). From fb45e85f66939dae6fec8f9704d69f03d99d2a0a Mon Sep 17 00:00:00 2001 From: Ronbb Date: Sat, 12 Jul 2025 14:03:23 +0800 Subject: [PATCH 3/3] Fix README exmaple --- opc_da_bindings/README.md | 7 ++++--- opc_hda_bindings/README.md | 2 +- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/opc_da_bindings/README.md b/opc_da_bindings/README.md index 5058913..ee7c298 100644 --- a/opc_da_bindings/README.md +++ b/opc_da_bindings/README.md @@ -1,4 +1,4 @@ -# OPC DA Bindings +# OPC Data Access (DA) Bindings Please see docs on [docs.rs](https://docs.rs/opc_da_bindings/). @@ -7,8 +7,9 @@ Please see docs on [docs.rs](https://docs.rs/opc_da_bindings/). ### Enumerate server list ```rust -use opc_da_bindings::{ - CATID_OPCDAServer10, CATID_OPCDAServer20, CATID_OPCDAServer30, IOPCServerList, +use opc_common_bindings::IOPCServerList; +use opc_da_bindings::{C + ATID_OPCDAServer10, CATID_OPCDAServer20, CATID_OPCDAServer30, }; use windows::Win32::System::Com::{ CLSIDFromProgID, CoCreateInstance, CoInitializeEx, ProgIDFromCLSID, CLSCTX_ALL, diff --git a/opc_hda_bindings/README.md b/opc_hda_bindings/README.md index 02f8f31..83ddcff 100644 --- a/opc_hda_bindings/README.md +++ b/opc_hda_bindings/README.md @@ -1,4 +1,4 @@ -# OPC Historial Data Access Bindings +# OPC Historical Data Access (HDA) Bindings Please see docs on [docs.rs](https://docs.rs/opc_hda_bindings/).