//**************************************************************************
//
//  Copyright (c) FactorySoft, INC. 1996-1998, All Rights Reserved
//
//**************************************************************************
//
//  Filename   :  OPCWrap.h
//  $Author    :  Jim Hansen
//
//  Subsystem  :  FactorySoft OPC Client
//
//  Description:  Template wrapper classes for the OPC COM interfaces
//                These classes automatically QueryInterface, AddRef, and
//                Release when they are done, reducing reference count errors.
//
//**************************************************************************

#ifndef __OPCWRAP_H__               // Only Include Once
#define __OPCWRAP_H__

#include "opcda.h"
#include "opccomn.h"

#ifdef _DEBUG
#define TRACE_MSG(call, hr)  { \
	TRACE(_T("hr=%lx\n"), (hr));  \
	TCHAR msg[MAX_PATH*5]; \
	FormatMessage( FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM, \
	NULL, \
	GetScode( hr ), \
	MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), \
	msg, MAX_PATH, NULL ); \
	TRACE(msg); \
	TRACE(_T("\n")); \
	::MessageBox( 0, msg, call, MB_OK ); \
      }
#else
#define TRACE_MSG(call,hr)  ;   // an empty statement
#endif


//*******************************************************************
template <class T, const IID* pIID>
class OInterfaceWrap
{
public:
	OInterfaceWrap() : m_pI(NULL) {}
	~OInterfaceWrap() { Detach(); }
	
	operator T*() {return m_pI;}
	operator IUnknown*() {return (IUnknown*)m_pI;}
	operator IUnknown**() {return (IUnknown**)&m_pI;}
	operator LPVOID *() {return (LPVOID *)&m_pI;}
	
	HRESULT Attach(IUnknown* pUnk)
	{
                ASSERT( pUnk != NULL );
                if( m_pI == pUnk)
			return S_OK;
                Detach();
                HRESULT hr = pUnk->QueryInterface( *pIID, (LPVOID*)&m_pI);
		//                if( FAILED(hr) )
		//                    TRACE_MSG(_T("QueryInterface"),hr);
                return hr;
	}
	
	HRESULT Attach(T* pI)
	{
                ASSERT( pI != NULL );
                if( m_pI == pI)
			return S_OK;
                Detach();
                m_pI = pI;
                m_pI->AddRef();
                return S_OK;
	}
	
	void Detach()
	{
                if( m_pI )
			m_pI->Release();
                m_pI = NULL;
	}
	
	HRESULT QueryInterface(REFIID iid, void ** ppvObject)
	{
                if( m_pI )
			return m_pI->QueryInterface(iid, ppvObject);
                return E_FAIL;
	}
	
	BOOL IsOk() const {return (m_pI != NULL); }
	
protected:
	T* m_pI;
};

//*******************************************************************
//  Server Interfaces
//*******************************************************************
typedef OInterfaceWrap<IOPCServer, &IID_IOPCServer> IOPCServerWrap;

class OPCServer : public IOPCServerWrap
{
public:
	OPCServer() {}
	
	HRESULT AddGroup(
                LPCWSTR     szName,
                BOOL        bActive,
                DWORD       dwRequestedUpdateRate,
                OPCHANDLE   hClientGroup,
                LONG      * pTimeBias,
                FLOAT     * pPercentDeadband,
                DWORD       dwLCID,
                OPCHANDLE * phServerGroup,
                DWORD     * pRevisedUpdateRate,
                REFIID      riid,
                LPUNKNOWN * ppUnk)
        { //ASSERT( IsOk() );
		if( !IsOk() )
			return E_FAIL;
		HRESULT hr = m_pI->AddGroup(szName, bActive, dwRequestedUpdateRate,
			hClientGroup, pTimeBias, pPercentDeadband,
			dwLCID, phServerGroup, pRevisedUpdateRate,
			riid, ppUnk );
		if( FAILED( hr ) )
			TRACE_MSG(_T("IOPCServer::AddGroup"),hr);
		return hr; }
	
	HRESULT GetErrorString(
		HRESULT     dwError,
		LCID     dwLocale,
		LPWSTR     *   ppString)
        { //ASSERT( IsOk() );
		HRESULT hr = m_pI->GetErrorString( dwError, dwLocale, ppString );
		if( FAILED( hr ) )
			TRACE_MSG(_T("IOPCServer::GetErrorString"),hr);
		return hr; }
	
	HRESULT GetGroupByName(
		LPCWSTR     szName,
		REFIID      riid,
		LPUNKNOWN * ppUnk)
        { //ASSERT( IsOk() );
		HRESULT hr = m_pI->GetGroupByName( szName, riid, ppUnk );
		if( FAILED( hr ) )
			TRACE_MSG(_T("IOPCServer::GetGroupByName"),hr);
		return hr; }
	
	HRESULT GetStatus(OPCSERVERSTATUS **ppServerStatus)
        { //ASSERT( IsOk() );
		HRESULT hr = m_pI->GetStatus( ppServerStatus );
		if( FAILED( hr ) )
			TRACE_MSG(_T("IOPCServer::GetStatus"),hr);
		return hr; }
	
	HRESULT RemoveGroup(
		OPCHANDLE   hServerGroup,
		BOOL     bForce)
        { //ASSERT( IsOk() );
		if( !IsOk() )
			return E_FAIL;
		HRESULT hr = m_pI->RemoveGroup( hServerGroup, bForce );
		if( FAILED( hr ) )
			TRACE_MSG(_T("IOPCServer::RemoveGroup"),hr);
		return hr; }
	
	HRESULT CreateGroupEnumerator(
		OPCENUMSCOPE dwScope,
		REFIID      riid,
		LPUNKNOWN * ppUnk)
        { //ASSERT( IsOk() );
		HRESULT hr = m_pI->CreateGroupEnumerator( dwScope, riid, ppUnk );
		if( FAILED( hr ) )
			TRACE_MSG(_T("IOPCServer::CreateGroupEnumerator"),hr);
		return hr; }
};

//*******************************************************************
typedef OInterfaceWrap<IOPCItemProperties,
&IID_IOPCItemProperties> IOPCItemPropertiesWrap;

class OPCItemProperties : public IOPCItemPropertiesWrap
{
public:
	OPCItemProperties() {}
	
	HRESULT QueryAvailableProperties(
		LPWSTR szItemID,
		DWORD *pdwCount,
		DWORD **ppPropertyIDs,
		LPWSTR **ppDescriptions,
		VARTYPE **ppvtDataTypes)
        { //ASSERT( IsOk() );
		HRESULT hr = m_pI->QueryAvailableProperties( szItemID,
                        pdwCount, ppPropertyIDs, ppDescriptions, ppvtDataTypes );
		if( FAILED( hr ) )
			TRACE_MSG(_T("OPCItemProperties::QueryAvailableProperties"),hr);
		return hr; }
	
	HRESULT GetItemProperties(
		LPWSTR szItemID,
		DWORD dwCount,
		DWORD *pdwPropertyIDs,
		VARIANT **ppvData,
		HRESULT **ppErrors)
        { //ASSERT( IsOk() );
		HRESULT hr = m_pI->GetItemProperties( szItemID,
                        dwCount, pdwPropertyIDs, ppvData, ppErrors );
		if( FAILED( hr ) )
			TRACE_MSG(_T("OPCItemProperties::QueryAvailableProperties"),hr);
		return hr; }
	
	HRESULT LookupItemIDs(
		LPWSTR szItemID,
		DWORD dwCount,
		DWORD *pdwPropertyIDs,
		LPWSTR **ppszNewItemIDs,
		HRESULT **ppErrors)
        { //ASSERT( IsOk() );
		HRESULT hr = m_pI->LookupItemIDs( szItemID,
                        dwCount, pdwPropertyIDs, ppszNewItemIDs, ppErrors );
		if( FAILED( hr ) )
			TRACE_MSG(_T("OPCItemProperties::QueryAvailableProperties"),hr);
		return hr; }
};

//*******************************************************************
typedef OInterfaceWrap<IOPCServerPublicGroups,
&IID_IOPCServerPublicGroups> IOPCServerPublicGroupsWrap;

class OPCServerPublicGroups : public IOPCServerPublicGroupsWrap
{
public:
	OPCServerPublicGroups() {}
	// not yet implemented
};

//*******************************************************************
typedef OInterfaceWrap<IOPCBrowseServerAddressSpace,
&IID_IOPCBrowseServerAddressSpace> IOPCBrowseServerAddressSpaceWrap;

class OPCBrowseServerAddressSpace : public IOPCBrowseServerAddressSpaceWrap
{
public:
	OPCBrowseServerAddressSpace() {}
	
	HRESULT QueryOrganization( OPCNAMESPACETYPE * pNameSpaceType)
        { //ASSERT( IsOk() );
		if( !IsOk() )
			return E_FAIL;
		HRESULT hr = m_pI->QueryOrganization( pNameSpaceType );
		if( FAILED( hr ) )
			TRACE_MSG(_T("Browse::QueryOrganization"),hr);
		return hr; }
	
	HRESULT ChangeBrowsePosition(
		OPCBROWSEDIRECTION dwBrowseDirection,
		LPCWSTR           szString)
        { //ASSERT( IsOk() );
		if( !IsOk() )
			return E_FAIL;
		HRESULT hr = m_pI->ChangeBrowsePosition( dwBrowseDirection, szString );
		//        if( FAILED( hr ) )  // error means can't go farther, etc.
		//            TRACE_MSG(_T("Browse::ChangeBrowsePosition"),hr);
		return hr; }
	
	HRESULT BrowseOPCItemIDs(
		OPCBROWSETYPE     dwBrowseFilterType,
		LPCWSTR           szFilterCriteria,
		VARTYPE           vtDataTypeFilter,
		DWORD             dwAccessRightsFilter,
		LPENUMSTRING *    ppIEnumString)
        { //ASSERT( IsOk() );
		if( !IsOk() )
			return E_FAIL;
		HRESULT hr = m_pI->BrowseOPCItemIDs( dwBrowseFilterType, szFilterCriteria,
			vtDataTypeFilter, dwAccessRightsFilter, ppIEnumString );
		if( FAILED( hr ) )
			TRACE_MSG(_T("Browse::BrowseOPCItemIDs"),hr);
		return hr; }
	
	HRESULT GetItemID(LPWSTR   szItemDataID,
		LPWSTR * szItemID)
        { //ASSERT( IsOk() );
		if( !IsOk() )
			return E_FAIL;
		HRESULT hr = m_pI->GetItemID( szItemDataID, szItemID );
		if( FAILED( hr ) )
			TRACE_MSG(_T("Browse::GetItemID"),hr);
		return hr; }
	
	HRESULT BrowseAccessPaths( LPCWSTR        szItemID,
		LPENUMSTRING * ppIEnumString)
        { //ASSERT( IsOk() );
		if( !IsOk() )
			return E_FAIL;
		HRESULT hr = m_pI->BrowseAccessPaths( szItemID, ppIEnumString );
		if( FAILED( hr ) )
			TRACE_MSG(_T("Browse::BrowseAccessPaths"),hr);
		return hr; }
};

//*******************************************************************
//    Group Interfaces
//*******************************************************************
typedef OInterfaceWrap<IOPCGroupStateMgt,
&IID_IOPCGroupStateMgt> IOPCGroupStateMgtWrap;

class OPCGroupStateMgt : public IOPCGroupStateMgtWrap
{
public:
	OPCGroupStateMgt() {}
	
	HRESULT GetState( DWORD     * pUpdateRate,
		BOOL      * pActive,
		LPWSTR    * ppName,
		LONG      * pTimeBias,
		FLOAT     * pPercentDeadband,
		DWORD     * pLCID,
		OPCHANDLE * phClientGroup,
		OPCHANDLE * phServerGroup )
        { //ASSERT( IsOk() );
		if( !IsOk() )
			return E_FAIL;
		HRESULT hr = m_pI->GetState( pUpdateRate, pActive, ppName, pTimeBias,
			pPercentDeadband, pLCID, phClientGroup, phServerGroup );
		if( FAILED( hr ) )
			TRACE_MSG(_T("OPCGroupStateMgt::GetState"),hr);
		return hr; }
	
	HRESULT SetState( DWORD     * pRequestedUpdateRate,
		DWORD     * pRevisedUpdateRate,
		BOOL      * pActive,
		LONG      * pTimeBias,
		FLOAT     * pPercentDeadband,
		DWORD     * pLCID,
		OPCHANDLE * phClientGroup )
        { //ASSERT( IsOk() );
		if( !IsOk() )
			return E_FAIL;
		HRESULT hr = m_pI->SetState( pRequestedUpdateRate, pRevisedUpdateRate, pActive,
			pTimeBias, pPercentDeadband, pLCID, phClientGroup );
		if( FAILED( hr ) )
			TRACE_MSG(_T("OPCGroupStateMgt::SetState"),hr);
		return hr; }
	
	HRESULT SetName( LPCWSTR szName )
        { //ASSERT( IsOk() );
		if( !IsOk() )
			return E_FAIL;
		HRESULT hr = m_pI->SetName( szName );
		if( FAILED( hr ) )
			TRACE_MSG(_T("OPCGroupStateMgt::SetName"),hr);
		return hr; }
	
	HRESULT CloneGroup(LPCWSTR     szName,
		REFIID      riid,
		LPUNKNOWN * ppUnk )
        { //ASSERT( IsOk() );
		if( !IsOk() )
			return E_FAIL;
		HRESULT hr = m_pI->CloneGroup( szName, riid, ppUnk );
		if( FAILED( hr ) )
			TRACE_MSG(_T("OPCGroupStateMgt::CloneGroup"),hr);
		return hr; }
};

//*******************************************************************
typedef OInterfaceWrap<IOPCPublicGroupStateMgt,
&IID_IOPCPublicGroupStateMgt> IOPCPublicGroupStateMgtWrap;

class OPCPublicGroupStateMgt : public IOPCPublicGroupStateMgtWrap
{
public:
	OPCPublicGroupStateMgt() {}
	
	HRESULT GetState( BOOL * pPublic )
        { //ASSERT( IsOk() );
		HRESULT hr = m_pI->GetState( pPublic );
		if( FAILED( hr ) )
			TRACE_MSG(_T("IOPCPublicGroupStateMgt::GetState"),hr);
		return hr; }
	
	HRESULT MoveToPublic( void )
        { //ASSERT( IsOk() );
		HRESULT hr = m_pI->MoveToPublic( );
		if( FAILED( hr ) )
			TRACE_MSG(_T("IOPCPublicGroupStateMgt::MoveToPublic"),hr);
		return hr; }
	
};

//*******************************************************************
typedef OInterfaceWrap<IOPCSyncIO, &IID_IOPCSyncIO> IOPCSyncIOWrap;

class OPCSyncIO : public IOPCSyncIOWrap
{
public:
	OPCSyncIO() {}
	
	HRESULT Read(  OPCDATASOURCE   dwSource,
		DWORD           dwNumItems,
		OPCHANDLE     * phServer,