opcwrap.h

一个opc服务器

                  OPCITEMSTATE ** ppItemValues,
                  HRESULT      ** ppErrors )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->Read(dwSource, dwNumItems, phServer, ppItemValues, ppErrors );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IOPCSyncIO::Read"),hr);
        return hr; }

   HRESULT Write( DWORD        dwNumItems,
                  OPCHANDLE  * phServer,
                  VARIANT    * pItemValues,
                  HRESULT   ** ppErrors )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->Write(dwNumItems, phServer, pItemValues, ppErrors );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IOPCSyncIO::Write"),hr);
        return hr; }

};

//*******************************************************************
typedef OInterfaceWrap<IOPCAsyncIO, &IID_IOPCAsyncIO> IOPCAsyncIOWrap;

class OPCAsyncIO : public IOPCAsyncIOWrap
{
public:
    OPCAsyncIO() {}

   HRESULT Read(  DWORD           dwConnection,
                  OPCDATASOURCE   dwSource,
                  DWORD           dwNumItems,
                  OPCHANDLE     * phServer,
                  DWORD         * pTransactionID,
                  HRESULT      ** ppErrors )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->Read( dwConnection, dwSource, dwNumItems, phServer,
                                 pTransactionID, ppErrors );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IOPCAsyncIO::Read"),hr);
        return hr; }

   HRESULT Write( DWORD       dwConnection,
                  DWORD       dwNumItems,
                  OPCHANDLE * phServer,
                  VARIANT   * pItemValues,
                  DWORD     * pTransactionID,
                  HRESULT ** ppErrors )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->Write( dwConnection, dwNumItems, phServer, pItemValues,
                                 pTransactionID, ppErrors );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IOPCAsyncIO::Write"),hr);
        return hr; }

   HRESULT Refresh(DWORD           dwConnection,
                   OPCDATASOURCE   dwSource,
                   DWORD         * pTransactionID )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->Refresh(dwConnection, dwSource, pTransactionID );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IOPCAsyncIO::Refresh"),hr);
        return hr; }

   HRESULT Cancel( DWORD dwTransactionID )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->Cancel( dwTransactionID );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IOPCAsyncIO::Cancel"),hr);
        return hr; }

};

//*******************************************************************
typedef OInterfaceWrap<IOPCAsyncIO2, &IID_IOPCAsyncIO2> IOPCAsyncIO2Wrap;

class OPCAsyncIO2 : public IOPCAsyncIO2Wrap
{
public:
    OPCAsyncIO2() {}

   HRESULT Read(  DWORD           dwNumItems,
                  OPCHANDLE     * phServer,
                  DWORD           pTransactionID,
                  DWORD         * pCancelID,
                  HRESULT      ** ppErrors )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->Read( dwNumItems, phServer,
                                 pTransactionID, pCancelID, ppErrors );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IOPCAsyncIO2::Read"),hr);
        return hr; }

   HRESULT Write( DWORD       dwNumItems,
                  OPCHANDLE * phServer,
                  VARIANT   * pItemValues,
                  DWORD       pTransactionID,
                  DWORD     * pCancelID,
                  HRESULT  ** ppErrors )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->Write( dwNumItems, phServer, pItemValues,
                                 pTransactionID, pCancelID, ppErrors );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IOPCAsyncIO2::Write"),hr);
        return hr; }

   HRESULT Refresh2(OPCDATASOURCE   dwSource,
                   DWORD           pTransactionID,
                   DWORD         * pCancelID )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->Refresh2(dwSource, pTransactionID, pCancelID );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IOPCAsyncIO2::Refresh2"),hr);
        return hr; }

   HRESULT Cancel2( DWORD dwCancelID )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->Cancel2( dwCancelID );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IOPCAsyncIO2::Cancel2"),hr);
        return hr; }

   HRESULT SetEnable( BOOL bEnable )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->SetEnable( bEnable );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IOPCAsyncIO2::SetEnable"),hr);
        return hr; }

   HRESULT GetEnable( BOOL *pbEnable )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->GetEnable( pbEnable );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IOPCAsyncIO2::GetEnable"),hr);
        return hr; }

};

//*******************************************************************
typedef OInterfaceWrap<IOPCItemMgt, &IID_IOPCItemMgt> IOPCItemMgtWrap;

class OPCItemMgt : public IOPCItemMgtWrap
{
public:
    OPCItemMgt() {}

  HRESULT AddItems(
                  DWORD            dwNumItems,
                  OPCITEMDEF     * pItemArray,
                  OPCITEMRESULT ** ppAddResults,
                  HRESULT       ** ppErrors )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->AddItems(dwNumItems, pItemArray, ppAddResults, ppErrors);
        if( FAILED( hr ) )
            TRACE_MSG(_T("IOPCItemMgt::AddItems"),hr);
        return hr; }


  HRESULT ValidateItems(
                  DWORD             dwNumItems,
                  OPCITEMDEF      * pItemArray,
                  BOOL              bBlobUpdate,
                  OPCITEMRESULT  ** ppValidationResults,
                  HRESULT        ** ppErrors )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->ValidateItems(dwNumItems, pItemArray,
                                 bBlobUpdate, ppValidationResults, ppErrors);
        if( FAILED( hr ) )
            TRACE_MSG(_T("IOPCItemMgt::ValidateItems"),hr);
        return hr; }


  HRESULT RemoveItems(
                  DWORD        dwNumItems,
                  OPCHANDLE  * phServer,
                  HRESULT   ** ppErrors )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->RemoveItems(dwNumItems, phServer, ppErrors);
        if( FAILED( hr ) )
            TRACE_MSG(_T("IOPCItemMgt::RemoveItems"),hr);
        return hr; }


  HRESULT SetActiveState(
                  DWORD        dwNumItems,
                  OPCHANDLE  * phServer,
                  BOOL         bActive,
                  HRESULT   ** ppErrors )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->SetActiveState(dwNumItems, phServer, bActive, ppErrors);
        if( FAILED( hr ) )
            TRACE_MSG(_T("IOPCItemMgt::SetActiveState"),hr);
        return hr; }


  HRESULT SetClientHandles(
                  DWORD        dwNumItems,
                  OPCHANDLE  * phServer,
                  OPCHANDLE  * phClient,
                  HRESULT   ** ppErrors )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->SetClientHandles(dwNumItems, phServer, phClient, ppErrors );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IOPCItemMgt::SetClientHandles"),hr);
        return hr; }


  HRESULT SetDatatypes(
                  DWORD        dwNumItems,
                  OPCHANDLE  * phServer,
                  VARTYPE    * pRequestedDatatypes,
                  HRESULT   ** ppErrors )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->SetDatatypes(dwNumItems, phServer, pRequestedDatatypes, ppErrors);
        if( FAILED( hr ) )
            TRACE_MSG(_T("IOPCItemMgt::SetDatatypes"),hr);
        return hr; }


  HRESULT CreateEnumerator(REFIID riid, LPUNKNOWN * ppUnk )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->CreateEnumerator(riid, ppUnk);
        if( FAILED( hr ) )
            TRACE_MSG(_T("IOPCItemMgt::CreateEnumerator"),hr);
        return hr; }
};

//*******************************************************************
typedef OInterfaceWrap<IDataObject, &IID_IDataObject> IDataObjectWrap;

class DataObject : public IDataObjectWrap
{
public:
    DataObject() {}

  HRESULT DAdvise ( FORMATETC* pformatetc,
                    DWORD advf,
                    IAdviseSink* pAdvSink,
                    DWORD* pdwConnection)
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->DAdvise(pformatetc, advf, pAdvSink, pdwConnection );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IDataObject::DAdvise"),hr);
        return hr; }

  HRESULT DUnadvise ( DWORD dwConnection)
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->DUnadvise(dwConnection);
        if( FAILED( hr ) )
            TRACE_MSG(_T("IDataObject::DUnadvise"),hr);
        return hr; }

  HRESULT EnumDAdvise ( IEnumSTATDATA** ppenumAdvise)
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->EnumDAdvise(ppenumAdvise );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IDataObject::EnumDAdvise"),hr);
        return hr; }

  HRESULT GetData  ( FORMATETC* pformatetcIn, STGMEDIUM* pmedium)
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->GetData(pformatetcIn, pmedium );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IDataObject::GetData"),hr);
        return hr; }

  HRESULT QueryGetData ( FORMATETC* pformatetc)
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->QueryGetData(pformatetc );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IDataObject::QueryGetData"),hr);
        return hr; }

  HRESULT GetDataHere ( FORMATETC* pformatetc, STGMEDIUM* pmedium)
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->GetDataHere( pformatetc, pmedium );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IDataObject::GetDataHere"),hr);
        return hr; }

  HRESULT GetCanonicalFormatEtc ( FORMATETC* pformatectIn, FORMATETC* pformatetcOut)
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->GetCanonicalFormatEtc(pformatectIn, pformatetcOut );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IDataObject::GetCanonicalFormatEtc"),hr);
        return hr; }

  HRESULT SetData ( FORMATETC* pformatetc, STGMEDIUM* pmedium, BOOL fRelease)
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->SetData(pformatetc, pmedium, fRelease );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IDataObject::SetData"),hr);
        return hr; }

  HRESULT EnumFormatEtc ( DWORD dwDirection, IEnumFORMATETC** ppenumFormatEtc)
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->EnumFormatEtc(dwDirection, ppenumFormatEtc );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IDataObject::EnumFormatEtc"),hr);
        return hr; }
};

//*******************************************************************
typedef OInterfaceWrap<IEnumOPCItemAttributes, &IID_IEnumOPCItemAttributes> IEnumOPCItemAttributesWrap;

class EnumOPCItemAttributes : public IEnumOPCItemAttributesWrap
{
public:
    EnumOPCItemAttributes() {}

  HRESULT Next( ULONG celt,
                OPCITEMATTRIBUTES ** ppItemArray,
                ULONG * pceltFetched )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->Next(celt, ppItemArray, pceltFetched );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IEnumOPCItemAttributes::Next"),hr);
        return hr; }

  HRESULT Skip( ULONG celt )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->Skip( celt );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IEnumOPCItemAttributes::Skip"),hr);
        return hr; }

  HRESULT Reset( void )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->Reset( );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IEnumOPCItemAttributes::Reset"),hr);
        return hr; }

  HRESULT Clone( IEnumOPCItemAttributes ** ppEnumItemAttributes )
        { //ASSERT( IsOk() );
        if( !IsOk() )
           return E_FAIL;
        HRESULT hr = m_pI->Clone( ppEnumItemAttributes );
        if( FAILED( hr ) )
            TRACE_MSG(_T("IEnumOPCItemAttributes::Clone"),hr);
        return hr; }
};

#endif