windows-xp/Source/XPSP1/NT/net/mmc/mprsnap/aggwrap.cpp

/**********************************************************************/
/**                       Microsoft Windows/NT                       **/
/**                Copyright(c) Microsoft Corporation, 1997 - 1999 **/
/**********************************************************************/

/*
	aggwrap.cpp

	Router aggregation wrappers.
		
    FILE HISTORY:
        
*/

#include "stdafx.h"
#include "infoi.h"


/*---------------------------------------------------------------------------
	RouterInfoAggregationWrapper
		This class is provided to use in an aggregation.
 ---------------------------------------------------------------------------*/
class RouterInfoAggregationWrapper :
   public IRouterInfo,
   public IRouterAdminAccess
{
public:
	RouterInfoAggregationWrapper(IRouterInfo *pInfo, IUnknown *punkOuter);
	virtual ~RouterInfoAggregationWrapper()
		{ DEBUG_DECREMENT_INSTANCE_COUNTER(RouterInfoAggregationWrapper); };

	// override the QI, we will use the AddRef/Release implementation
	// in the CDataObject
	DeclareIUnknownMembers(IMPL)
    DeclareIRouterRefreshAccessMembers(IMPL)
	DeclareIRouterInfoMembers(IMPL)
    DeclareIRouterAdminAccessMembers(IMPL)

	IUnknown * GetNonDelegatingIUnknown() { return &m_ENonDelegatingIUnknown; }

protected:
	LONG			m_cRef;
	SPIRouterInfo	m_spRouterInfo;

	DECLARE_AGGREGATION_NONDELEGATING_IUNKNOWN(RouterInfoAggregationWrapper)

};

IMPLEMENT_AGGREGATION_IUNKNOWN(RouterInfoAggregationWrapper)

IMPLEMENT_AGGREGATION_NONDELEGATING_ADDREFRELEASE(RouterInfoAggregationWrapper, IRouterInfo)

STDMETHODIMP RouterInfoAggregationWrapper::ENonDelegatingIUnknown::QueryInterface(REFIID riid, LPVOID *ppv)
{
	InitPThis(RouterInfoAggregationWrapper, ENonDelegatingIUnknown);
	if (ppv == NULL) 
		return E_INVALIDARG; 
	*ppv = NULL; 
	if (riid == IID_IUnknown) 
		*ppv = (IUnknown *) this; 
	else if (riid == IID_IRouterInfo) 
		*ppv = (IRouterInfo *) pThis;
    else if (riid == IID_IRouterRefreshAccess)
        *ppv = (IRouterRefreshAccess *) pThis;
    else if (riid == IID_IRouterAdminAccess)
        *ppv = (IRouterAdminAccess *) pThis;
	else 
		return E_NOINTERFACE; 
	((IUnknown *)*ppv)->AddRef(); 
	return hrOK; 
} 

DEBUG_DECLARE_INSTANCE_COUNTER(RouterInfoAggregationWrapper);

RouterInfoAggregationWrapper::RouterInfoAggregationWrapper(IRouterInfo *pInfo, IUnknown *punkOuter)
	: m_cRef(1)
{
	m_spRouterInfo.Set(pInfo);

	DEBUG_INCREMENT_INSTANCE_COUNTER(RouterInfoAggregationWrapper);
	
	if (punkOuter)
		m_pUnknownOuter = punkOuter;
	else
		m_pUnknownOuter = &m_ENonDelegatingIUnknown;
}


STDMETHODIMP_(DWORD) RouterInfoAggregationWrapper::GetFlags()
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->GetFlags();
}

STDMETHODIMP RouterInfoAggregationWrapper::SetFlags(DWORD dwFlags)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->SetFlags(dwFlags);
}

HRESULT	RouterInfoAggregationWrapper::Load(LPCOLESTR   pszMachine,
								   HANDLE      hMachine)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->Load(pszMachine, hMachine);
}
				 
HRESULT	RouterInfoAggregationWrapper::Save(LPCOLESTR     pszMachine,
								   HANDLE      hMachine )
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->Save(pszMachine, hMachine);
}
	
HRESULT	RouterInfoAggregationWrapper::Unload( )
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->Unload();
}
	
	
HRESULT RouterInfoAggregationWrapper::Merge(IRouterInfo *pNewRouterInfo)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->Merge(pNewRouterInfo);
}

HRESULT RouterInfoAggregationWrapper::GetRefreshObject(IRouterRefresh **ppRefresh)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->GetRefreshObject(ppRefresh);
}
	
HRESULT RouterInfoAggregationWrapper::SetExternalRefreshObject(IRouterRefresh *pRefresh)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->SetExternalRefreshObject(pRefresh);
}
	
	
HRESULT	RouterInfoAggregationWrapper::CopyCB(RouterCB *pRouterCB)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->CopyCB(pRouterCB);
}
	
LPCOLESTR RouterInfoAggregationWrapper::GetMachineName()
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->GetMachineName();
}

DWORD RouterInfoAggregationWrapper::GetRouterType()
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->GetRouterType();
}

HRESULT RouterInfoAggregationWrapper::GetRouterVersionInfo(RouterVersionInfo *pVerInfo)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->GetRouterVersionInfo(pVerInfo);
}

HRESULT	RouterInfoAggregationWrapper::EnumRtrMgrCB( IEnumRtrMgrCB **ppEnumRtrMgrCB)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->EnumRtrMgrCB(ppEnumRtrMgrCB);
}

HRESULT RouterInfoAggregationWrapper::EnumInterfaceCB( IEnumInterfaceCB **ppEnumInterfaceCB)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->EnumInterfaceCB(ppEnumInterfaceCB);
}

HRESULT RouterInfoAggregationWrapper::EnumRtrMgrProtocolCB( IEnumRtrMgrProtocolCB **ppEnumRmProtCB)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->EnumRtrMgrProtocolCB(ppEnumRmProtCB);
}

HRESULT RouterInfoAggregationWrapper::EnumRtrMgrInterfaceCB( IEnumRtrMgrInterfaceCB **ppEnumRmIfCB)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->EnumRtrMgrInterfaceCB(ppEnumRmIfCB);
}

HRESULT RouterInfoAggregationWrapper::EnumRtrMgrProtocolInterfaceCB( IEnumRtrMgrProtocolInterfaceCB **ppEnumRmProtIfCB)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->EnumRtrMgrProtocolInterfaceCB(ppEnumRmProtIfCB);
}
	
HRESULT	RouterInfoAggregationWrapper::EnumRtrMgr( IEnumRtrMgrInfo **ppEnumRtrMgr)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->EnumRtrMgr(ppEnumRtrMgr);
}

HRESULT RouterInfoAggregationWrapper::FindRtrMgr( DWORD dwTransportId,
					    IRtrMgrInfo **ppInfo)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->FindRtrMgr(dwTransportId, ppInfo);
}

HRESULT RouterInfoAggregationWrapper::AddRtrMgr( IRtrMgrInfo *pInfo,
					   IInfoBase *pGlobalInfo,
					   IInfoBase *pClientInfo)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->AddRtrMgr(pInfo, pGlobalInfo, pClientInfo);
}

HRESULT	RouterInfoAggregationWrapper::DeleteRtrMgr( DWORD dwTransportId, BOOL fRemove)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->DeleteRtrMgr(dwTransportId, fRemove);
}

HRESULT	RouterInfoAggregationWrapper::ReleaseRtrMgr( DWORD dwTransportId)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->ReleaseRtrMgr(dwTransportId);
}

HRESULT RouterInfoAggregationWrapper::EnumInterface( IEnumInterfaceInfo **ppEnumInterface)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->EnumInterface(ppEnumInterface);
}

HRESULT RouterInfoAggregationWrapper::FindInterface( LPCOLESTR pszInterface,
						   IInterfaceInfo **ppInfo)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->FindInterface(pszInterface, ppInfo);
}

HRESULT	RouterInfoAggregationWrapper::AddInterface( IInterfaceInfo *pInfo)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->AddInterface(pInfo);
}

HRESULT	RouterInfoAggregationWrapper::DeleteInterface( LPCOLESTR pszInterface, BOOL fRemove)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->DeleteInterface(pszInterface, fRemove);
}

HRESULT	RouterInfoAggregationWrapper::ReleaseInterface( LPCOLESTR pszInterface)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->ReleaseInterface(pszInterface);
}

HRESULT	RouterInfoAggregationWrapper::RtrAdvise( IRtrAdviseSink *pRtrAdviseSink,
 					   LONG_PTR *pulConnection, LPARAM lUserParam)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->RtrAdvise(pRtrAdviseSink, pulConnection, lUserParam);
}

HRESULT RouterInfoAggregationWrapper::RtrNotify(DWORD dwChangeType, DWORD dwObjectType, LPARAM lParam)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->RtrNotify(dwChangeType, dwObjectType, lParam);
}

HRESULT RouterInfoAggregationWrapper::RtrUnadvise( LONG_PTR ulConnection)
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->RtrUnadvise(ulConnection);
}


HRESULT	RouterInfoAggregationWrapper::DoDisconnect()
{
	Assert(m_spRouterInfo);
	return m_spRouterInfo->DoDisconnect();
}

HRESULT	RouterInfoAggregationWrapper::AddWeakRef()
{
	Panic0("Should not be calling AddWeakRef from the Data object!");
	return E_FAIL;
}

HRESULT	RouterInfoAggregationWrapper::ReleaseWeakRef()
{
	Panic0("Should not be calling ReleaseWeakRef from the Data object!");
	return E_FAIL;
}

HRESULT	RouterInfoAggregationWrapper::Destruct()
{
	Panic0("Should not be calling Destruct from the Data object!");
	return E_FAIL;
}

BOOL RouterInfoAggregationWrapper::IsAdminInfoSet()
{
	Assert(m_spRouterInfo);
    SPIRouterAdminAccess    spAdmin;

    spAdmin.HrQuery(m_spRouterInfo);
    Assert(spAdmin);
	return spAdmin->IsAdminInfoSet();
}

LPCOLESTR RouterInfoAggregationWrapper::GetUserName()
{
	Assert(m_spRouterInfo);
    SPIRouterAdminAccess    spAdmin;

    spAdmin.HrQuery(m_spRouterInfo);
    Assert(spAdmin);
	return spAdmin->GetUserName();
}

LPCOLESTR RouterInfoAggregationWrapper::GetDomainName()
{
	Assert(m_spRouterInfo);
    SPIRouterAdminAccess    spAdmin;

    spAdmin.HrQuery(m_spRouterInfo);
    Assert(spAdmin);
	return spAdmin->GetUserName();
}

HRESULT RouterInfoAggregationWrapper::GetUserPassword(BYTE *pByte,
    int *pcPassword)
{
	Assert(m_spRouterInfo);
    SPIRouterAdminAccess    spAdmin;

    spAdmin.HrQuery(m_spRouterInfo);
    Assert(spAdmin);
	return spAdmin->GetUserPassword(pByte, pcPassword);
}

HRESULT RouterInfoAggregationWrapper::SetInfo(LPCOLESTR pszName,
                                              LPCOLESTR pszDomain,
                                              BYTE *pPassword,
                                              int cPassword)
{
	Assert(m_spRouterInfo);
    SPIRouterAdminAccess    spAdmin;

    spAdmin.HrQuery(m_spRouterInfo);
    Assert(spAdmin);
	return spAdmin->SetInfo(pszName, pszDomain, pPassword,
                            cPassword);
}


/*!--------------------------------------------------------------------------
	CreateRouterInfoAggregation
		Takes an existing IRouterInfo and aggregates that with the
		passed-in object.  It returns a pointer to the non-delegating
		IUnknown on the IRouterInfo.  This pointer is held by the
		controlling IUnknown.
	Author: KennT
 ---------------------------------------------------------------------------*/
TFSCORE_API(HRESULT) CreateRouterInfoAggregation(IRouterInfo *pInfo,
	IUnknown *punk, IUnknown **ppNonDelegatingIUnknown)
{
	RouterInfoAggregationWrapper *	pAgg = NULL;
	HRESULT	hr = hrOK;

	COM_PROTECT_TRY
	{
		pAgg = new RouterInfoAggregationWrapper(pInfo, punk);
		*ppNonDelegatingIUnknown = pAgg->GetNonDelegatingIUnknown();
	}
	COM_PROTECT_CATCH;
	return hr;
}


/*---------------------------------------------------------------------------
	InterfaceInfoAggregationWrapper implementation
 ---------------------------------------------------------------------------*/
class InterfaceInfoAggregationWrapper :
   public IInterfaceInfo
{
public:
	InterfaceInfoAggregationWrapper(IInterfaceInfo *pInfo, IUnknown *punkOuter);
	virtual ~InterfaceInfoAggregationWrapper()
		{ DEBUG_DECREMENT_INSTANCE_COUNTER(InterfaceInfoAggregationWrapper); };

	// override the QI, we will use the AddRef/Release implementation
	// in the CDataObject
	DeclareIUnknownMembers(IMPL)
	DeclareIInterfaceInfoMembers(IMPL)

	IUnknown * GetNonDelegatingIUnknown() { return &m_ENonDelegatingIUnknown; }
	
protected:
	LONG			m_cRef;
	SPIInterfaceInfo	m_spInterfaceInfo;

	DECLARE_AGGREGATION_NONDELEGATING_IUNKNOWN(InterfaceInfoAggregationWrapper)
};

IMPLEMENT_AGGREGATION_IUNKNOWN(InterfaceInfoAggregationWrapper)

IMPLEMENT_AGGREGATION_NONDELEGATING_IUNKNOWN(InterfaceInfoAggregationWrapper, IInterfaceInfo)

DEBUG_DECLARE_INSTANCE_COUNTER(InterfaceInfoAggregationWrapper);

InterfaceInfoAggregationWrapper::InterfaceInfoAggregationWrapper(IInterfaceInfo *pInfo, IUnknown *punkOuter)
	: m_cRef(1)
{
	m_spInterfaceInfo.Set(pInfo);

	DEBUG_INCREMENT_INSTANCE_COUNTER(InterfaceInfoAggregationWrapper);
	
	if (punkOuter)
		m_pUnknownOuter = punkOuter;
	else
		m_pUnknownOuter = &m_ENonDelegatingIUnknown;
}


STDMETHODIMP_(DWORD) InterfaceInfoAggregationWrapper::GetFlags()
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->GetFlags();
}

STDMETHODIMP InterfaceInfoAggregationWrapper::SetFlags(DWORD dwFlags)
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->SetFlags(dwFlags);
}

STDMETHODIMP InterfaceInfoAggregationWrapper::Load(LPCOLESTR   pszMachine,
										   HANDLE      hMachine,
										   HANDLE hInterface)
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->Load(pszMachine, hMachine, hInterface);
}
				 
STDMETHODIMP InterfaceInfoAggregationWrapper::Save(LPCOLESTR     pszMachine,
										   HANDLE      hMachine,
										   HANDLE hInterface)
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->Save(pszMachine, hMachine, hInterface);
}

STDMETHODIMP InterfaceInfoAggregationWrapper::Delete(LPCOLESTR pszMachine,
											 HANDLE hMachine)
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->Delete(pszMachine, hMachine);
}
	
STDMETHODIMP InterfaceInfoAggregationWrapper::Unload( )
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->Unload();
}
	
STDMETHODIMP InterfaceInfoAggregationWrapper::Merge(IInterfaceInfo *pIf)
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->Merge(pIf);
}

STDMETHODIMP_(LPCOLESTR) InterfaceInfoAggregationWrapper::GetId()
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->GetId();
}

STDMETHODIMP_(DWORD) InterfaceInfoAggregationWrapper::GetInterfaceType()
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->GetInterfaceType();
}

STDMETHODIMP_(LPCOLESTR) InterfaceInfoAggregationWrapper::GetDeviceName()
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->GetDeviceName();
}

	
STDMETHODIMP_(LPCOLESTR) InterfaceInfoAggregationWrapper::GetTitle()
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->GetTitle();
}

STDMETHODIMP InterfaceInfoAggregationWrapper::SetTitle( LPCOLESTR pszTitle)
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->SetTitle(pszTitle);
}

	
STDMETHODIMP_(BOOL)	InterfaceInfoAggregationWrapper::IsInterfaceEnabled()
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->IsInterfaceEnabled();
}

STDMETHODIMP InterfaceInfoAggregationWrapper::SetInterfaceEnabledState( BOOL bEnabled)
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->SetInterfaceEnabledState(bEnabled);
}

	
STDMETHODIMP InterfaceInfoAggregationWrapper::CopyCB(InterfaceCB *pifcb)
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->CopyCB(pifcb);
}

	
STDMETHODIMP_(LPCOLESTR) InterfaceInfoAggregationWrapper::GetMachineName()
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->GetMachineName();
}

STDMETHODIMP InterfaceInfoAggregationWrapper::SetMachineName( LPCOLESTR pszMachine)
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->SetMachineName(pszMachine);
}


STDMETHODIMP InterfaceInfoAggregationWrapper::EnumRtrMgrInterface( IEnumRtrMgrInterfaceInfo **ppEnumRMIf)
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->EnumRtrMgrInterface(ppEnumRMIf);
}

STDMETHODIMP InterfaceInfoAggregationWrapper::AddRtrMgrInterface( IRtrMgrInterfaceInfo *pInfo,
								    IInfoBase *pInterfaceInfo)
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->AddRtrMgrInterface(pInfo, pInterfaceInfo);
}

STDMETHODIMP InterfaceInfoAggregationWrapper::DeleteRtrMgrInterface( DWORD dwTransportId, BOOL fRemove)
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->DeleteRtrMgrInterface(dwTransportId, fRemove);
}

STDMETHODIMP InterfaceInfoAggregationWrapper::ReleaseRtrMgrInterface( DWORD dwTransportId)
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->ReleaseRtrMgrInterface(dwTransportId);
}

STDMETHODIMP InterfaceInfoAggregationWrapper::FindRtrMgrInterface( DWORD dwTransportId,
								    IRtrMgrInterfaceInfo **ppInfo)
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->FindRtrMgrInterface(dwTransportId, ppInfo);
}

	
STDMETHODIMP InterfaceInfoAggregationWrapper::RtrAdvise( IRtrAdviseSink *pRtrAdviseSink,
					   LONG_PTR *pulConnection, LPARAM lUserParam)
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->RtrAdvise(pRtrAdviseSink, pulConnection, lUserParam);
}

STDMETHODIMP InterfaceInfoAggregationWrapper::RtrNotify(DWORD dwChangeType,
	DWORD dwObjectType, LPARAM lParam)
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->RtrNotify(dwChangeType, dwObjectType, lParam);
}

STDMETHODIMP InterfaceInfoAggregationWrapper::RtrUnadvise( LONG_PTR ulConnection)
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->RtrUnadvise(ulConnection);
}


STDMETHODIMP InterfaceInfoAggregationWrapper::GetParentRouterInfo( IRouterInfo **ppRouterInfo)
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->GetParentRouterInfo(ppRouterInfo);
}

STDMETHODIMP InterfaceInfoAggregationWrapper::SetParentRouterInfo( IRouterInfo *pRouterInfo)
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->SetParentRouterInfo(pRouterInfo);
}


HRESULT	InterfaceInfoAggregationWrapper::DoDisconnect()
{
	Assert(m_spInterfaceInfo);
	return m_spInterfaceInfo->DoDisconnect();
}

HRESULT	InterfaceInfoAggregationWrapper::AddWeakRef()
{
	Panic0("Should not be calling AddWeakRef from the Data object!");
	return E_FAIL;
}

HRESULT	InterfaceInfoAggregationWrapper::ReleaseWeakRef()
{
	Panic0("Should not be calling ReleaseWeakRef from the Data object!");
	return E_FAIL;
}

HRESULT	InterfaceInfoAggregationWrapper::Destruct()
{
	Panic0("Should not be calling Destruct from the Data object!");
	return E_FAIL;
}

/*!--------------------------------------------------------------------------
	CreateInterfaceInfoAggregation
		Takes an existing IInterfaceInfo and aggregates that with the
		passed-in object.  It returns a pointer to the non-delegating
		IUnknown on the IInterfaceInfo.  This pointer is held by the
		controlling IUnknown.
	Author: KennT
 ---------------------------------------------------------------------------*/
TFSCORE_API(HRESULT) CreateInterfaceInfoAggregation(IInterfaceInfo *pInfo,
	IUnknown *punk, IUnknown **ppNonDelegatingIUnknown)
{
	InterfaceInfoAggregationWrapper *	pAgg = NULL;
	HRESULT	hr = hrOK;

	COM_PROTECT_TRY
	{
		pAgg = new InterfaceInfoAggregationWrapper(pInfo, punk);
		*ppNonDelegatingIUnknown = pAgg->GetNonDelegatingIUnknown();
	}
	COM_PROTECT_CATCH;
	return hr;
}



/*---------------------------------------------------------------------------
	RtrMgrInfoAggregationWrapper
		This class is provided to use in an aggregation.
 ---------------------------------------------------------------------------*/
class RtrMgrInfoAggregationWrapper :
   public IRtrMgrInfo
{
public:
	RtrMgrInfoAggregationWrapper(IRtrMgrInfo *pInfo, IUnknown *punkOuter);
	virtual ~RtrMgrInfoAggregationWrapper()
		{ DEBUG_DECREMENT_INSTANCE_COUNTER(RtrMgrInfoAggregationWrapper); };

	// override the QI, we will use the AddRef/Release implementation
	// in the CDataObject
	DeclareIUnknownMembers(IMPL)
	DeclareIRtrMgrInfoMembers(IMPL)

	IUnknown * GetNonDelegatingIUnknown() { return &m_ENonDelegatingIUnknown; }

protected:
	LONG			m_cRef;
	SPIRtrMgrInfo	m_spRtrMgrInfo;

	DECLARE_AGGREGATION_NONDELEGATING_IUNKNOWN(RtrMgrInfoAggregationWrapper)

};

IMPLEMENT_AGGREGATION_IUNKNOWN(RtrMgrInfoAggregationWrapper)

IMPLEMENT_AGGREGATION_NONDELEGATING_IUNKNOWN(RtrMgrInfoAggregationWrapper, IRtrMgrInfo)

DEBUG_DECLARE_INSTANCE_COUNTER(RtrMgrInfoAggregationWrapper);

RtrMgrInfoAggregationWrapper::RtrMgrInfoAggregationWrapper(IRtrMgrInfo *pInfo, IUnknown *punkOuter)
	: m_cRef(1)
{
	m_spRtrMgrInfo.Set(pInfo);

	DEBUG_INCREMENT_INSTANCE_COUNTER(RtrMgrInfoAggregationWrapper);
	
	if (punkOuter)
		m_pUnknownOuter = punkOuter;
	else
		m_pUnknownOuter = &m_ENonDelegatingIUnknown;
}


STDMETHODIMP_(DWORD) RtrMgrInfoAggregationWrapper::GetFlags()
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->GetFlags();
}

STDMETHODIMP RtrMgrInfoAggregationWrapper::SetFlags(DWORD dwFlags)
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->SetFlags(dwFlags);
}

STDMETHODIMP RtrMgrInfoAggregationWrapper::Load(LPCOLESTR   pszMachine,
										   HANDLE      hMachine,
										   HANDLE hTransport)
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->Load(pszMachine, hMachine, hTransport);
}
				 
STDMETHODIMP	RtrMgrInfoAggregationWrapper::Save(LPCOLESTR     pszMachine,
										   HANDLE      hMachine,
										   HANDLE hTransport,
										   IInfoBase *pGlobal,
										   IInfoBase *pClient,
										   DWORD dwDeleteProtocolId)
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->Save(pszMachine, hMachine, hTransport,
							   pGlobal, pClient, dwDeleteProtocolId);
}
	
STDMETHODIMP	RtrMgrInfoAggregationWrapper::Unload( )
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->Unload();
}

STDMETHODIMP RtrMgrInfoAggregationWrapper::Delete(LPCOLESTR pszMachine,
	HANDLE hMachine)
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->Delete(pszMachine, hMachine);
}

STDMETHODIMP RtrMgrInfoAggregationWrapper::Merge(IRtrMgrInfo *pNewRm)
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->Merge(pNewRm);
}
	

STDMETHODIMP RtrMgrInfoAggregationWrapper::SetInfoBase(IInfoBase *pGlobal,
	IInfoBase *pClient)
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->SetInfoBase(pGlobal, pClient);
}

STDMETHODIMP RtrMgrInfoAggregationWrapper::GetInfoBase(HANDLE hMachine,
	HANDLE hTransport, IInfoBase **ppGlobal, IInfoBase **ppClient)
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->GetInfoBase(hMachine, hTransport, ppGlobal, ppClient);
}

STDMETHODIMP_(LPCOLESTR) RtrMgrInfoAggregationWrapper::GetId()
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->GetId();
}

STDMETHODIMP RtrMgrInfoAggregationWrapper::SetId(LPCOLESTR pszId)
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->SetId(pszId);
}

STDMETHODIMP_(DWORD) RtrMgrInfoAggregationWrapper::GetTransportId()
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->GetTransportId();
}

STDMETHODIMP_(LPCOLESTR) RtrMgrInfoAggregationWrapper::GetTitle()
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->GetTitle();
}
	
STDMETHODIMP RtrMgrInfoAggregationWrapper::CopyRtrMgrCB(RtrMgrCB *pRtrMgrCB)
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->CopyRtrMgrCB(pRtrMgrCB);
}
	
LPCOLESTR RtrMgrInfoAggregationWrapper::GetMachineName()
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->GetMachineName();
}

STDMETHODIMP RtrMgrInfoAggregationWrapper::EnumRtrMgrProtocol( IEnumRtrMgrProtocolInfo **ppEnumRtrMgrProtocol)
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->EnumRtrMgrProtocol(ppEnumRtrMgrProtocol);
}

STDMETHODIMP RtrMgrInfoAggregationWrapper::FindRtrMgrProtocol(DWORD dwProtocolId,
					    IRtrMgrProtocolInfo **ppInfo)
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->FindRtrMgrProtocol(dwProtocolId, ppInfo);
}

STDMETHODIMP RtrMgrInfoAggregationWrapper::AddRtrMgrProtocol(IRtrMgrProtocolInfo *pInfo,
					   IInfoBase *pGlobalInfo,
					   IInfoBase *pClientInfo)
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->AddRtrMgrProtocol(pInfo, pGlobalInfo, pClientInfo);
}

STDMETHODIMP RtrMgrInfoAggregationWrapper::SetParentRouterInfo(IRouterInfo *pRouterInfo)
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->SetParentRouterInfo(pRouterInfo);
}


STDMETHODIMP RtrMgrInfoAggregationWrapper::GetParentRouterInfo(IRouterInfo **ppRouterInfo)
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->GetParentRouterInfo(ppRouterInfo);
}

STDMETHODIMP	RtrMgrInfoAggregationWrapper::DeleteRtrMgrProtocol( DWORD dwProtocolId, BOOL fRemove)
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->DeleteRtrMgrProtocol(dwProtocolId, fRemove);
}

STDMETHODIMP	RtrMgrInfoAggregationWrapper::ReleaseRtrMgrProtocol( DWORD dwProtocolId)
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->ReleaseRtrMgrProtocol(dwProtocolId);
}

STDMETHODIMP	RtrMgrInfoAggregationWrapper::RtrAdvise( IRtrAdviseSink *pRtrAdviseSink,
					   LONG_PTR *pulConnection, LPARAM lUserParam)
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->RtrAdvise(pRtrAdviseSink, pulConnection, lUserParam);
}

STDMETHODIMP RtrMgrInfoAggregationWrapper::RtrNotify(DWORD dwChangeType, DWORD dwObjectType, LPARAM lParam)
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->RtrNotify(dwChangeType, dwObjectType, lParam);
}

STDMETHODIMP RtrMgrInfoAggregationWrapper::RtrUnadvise( LONG_PTR ulConnection)
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->RtrUnadvise(ulConnection);
}


HRESULT	RtrMgrInfoAggregationWrapper::DoDisconnect()
{
	Assert(m_spRtrMgrInfo);
	return m_spRtrMgrInfo->DoDisconnect();
}

STDMETHODIMP	RtrMgrInfoAggregationWrapper::AddWeakRef()
{
	Panic0("Should not be calling AddWeakRef from the Data object!");
	return E_FAIL;
}

STDMETHODIMP	RtrMgrInfoAggregationWrapper::ReleaseWeakRef()
{
	Panic0("Should not be calling ReleaseWeakRef from the Data object!");
	return E_FAIL;
}

STDMETHODIMP	RtrMgrInfoAggregationWrapper::Destruct()
{
	Panic0("Should not be calling Destruct from the Data object!");
	return E_FAIL;
}

/*!--------------------------------------------------------------------------
	CreateRtrMgrInfoAggregation
		Takes an existing IRtrMgrInfo and aggregates that with the
		passed-in object.  It returns a pointer to the non-delegating
		IUnknown on the IRtrMgrInfo.  This pointer is held by the
		controlling IUnknown.
	Author: KennT
 ---------------------------------------------------------------------------*/
TFSCORE_API(HRESULT) CreateRtrMgrInfoAggregation(IRtrMgrInfo *pInfo,
	IUnknown *punk, IUnknown **ppNonDelegatingIUnknown)
{
	RtrMgrInfoAggregationWrapper *	pAgg = NULL;
	HRESULT	hr = hrOK;

	COM_PROTECT_TRY
	{
		pAgg = new RtrMgrInfoAggregationWrapper(pInfo, punk);
		*ppNonDelegatingIUnknown = pAgg->GetNonDelegatingIUnknown();
	}
	COM_PROTECT_CATCH;
	return hr;
}



/*---------------------------------------------------------------------------
	RtrMgrProtocolInfoAggregationWrapper
		This class is provided to use in an aggregation.
 ---------------------------------------------------------------------------*/
class RtrMgrProtocolInfoAggregationWrapper :
   public IRtrMgrProtocolInfo
{
public:
	RtrMgrProtocolInfoAggregationWrapper(IRtrMgrProtocolInfo *pInfo, IUnknown *punkOuter);
	virtual ~RtrMgrProtocolInfoAggregationWrapper()
		{ DEBUG_DECREMENT_INSTANCE_COUNTER(RtrMgrProtocolInfoAggregationWrapper); };

	// override the QI, we will use the AddRef/Release implementation
	// in the CDataObject
	DeclareIUnknownMembers(IMPL)
	DeclareIRtrMgrProtocolInfoMembers(IMPL)

	IUnknown * GetNonDelegatingIUnknown() { return &m_ENonDelegatingIUnknown; }

protected:
	LONG			m_cRef;
	SPIRtrMgrProtocolInfo	m_spRtrMgrProtocolInfo;

	DECLARE_AGGREGATION_NONDELEGATING_IUNKNOWN(RtrMgrProtocolInfoAggregationWrapper)

};

IMPLEMENT_AGGREGATION_IUNKNOWN(RtrMgrProtocolInfoAggregationWrapper)

IMPLEMENT_AGGREGATION_NONDELEGATING_IUNKNOWN(RtrMgrProtocolInfoAggregationWrapper, IRtrMgrProtocolInfo)

DEBUG_DECLARE_INSTANCE_COUNTER(RtrMgrProtocolInfoAggregationWrapper);

RtrMgrProtocolInfoAggregationWrapper::RtrMgrProtocolInfoAggregationWrapper(IRtrMgrProtocolInfo *pInfo, IUnknown *punkOuter)
	: m_cRef(1)
{
	m_spRtrMgrProtocolInfo.Set(pInfo);

	DEBUG_INCREMENT_INSTANCE_COUNTER(RtrMgrProtocolInfoAggregationWrapper);
	
	if (punkOuter)
		m_pUnknownOuter = punkOuter;
	else
		m_pUnknownOuter = &m_ENonDelegatingIUnknown;
}


STDMETHODIMP_(DWORD) RtrMgrProtocolInfoAggregationWrapper::GetFlags()
{
	Assert(m_spRtrMgrProtocolInfo);
	return m_spRtrMgrProtocolInfo->GetFlags();
}

STDMETHODIMP RtrMgrProtocolInfoAggregationWrapper::SetFlags(DWORD dwFlags)
{
	Assert(m_spRtrMgrProtocolInfo);
	return m_spRtrMgrProtocolInfo->SetFlags(dwFlags);
}

STDMETHODIMP_(DWORD) RtrMgrProtocolInfoAggregationWrapper::GetProtocolId()
{
	Assert(m_spRtrMgrProtocolInfo);
	return m_spRtrMgrProtocolInfo->GetProtocolId();
}

STDMETHODIMP_(DWORD) RtrMgrProtocolInfoAggregationWrapper::GetTransportId()
{
	Assert(m_spRtrMgrProtocolInfo);
	return m_spRtrMgrProtocolInfo->GetTransportId();
}

STDMETHODIMP_(LPCOLESTR) RtrMgrProtocolInfoAggregationWrapper::GetTitle()
{
	Assert(m_spRtrMgrProtocolInfo);
	return m_spRtrMgrProtocolInfo->GetTitle();
}

STDMETHODIMP RtrMgrProtocolInfoAggregationWrapper::CopyCB(RtrMgrProtocolCB *pRtrMgrProtCB)
{
	Assert(m_spRtrMgrProtocolInfo);
	return m_spRtrMgrProtocolInfo->CopyCB(pRtrMgrProtCB);
}

	
STDMETHODIMP	RtrMgrProtocolInfoAggregationWrapper::RtrAdvise( IRtrAdviseSink *pRtrAdviseSink,
					   LONG_PTR *pulConnection, LPARAM lUserParam)
{
	Assert(m_spRtrMgrProtocolInfo);
	return m_spRtrMgrProtocolInfo->RtrAdvise(pRtrAdviseSink, pulConnection, lUserParam);
}

STDMETHODIMP RtrMgrProtocolInfoAggregationWrapper::RtrNotify(DWORD dwChangeType, DWORD dwObjectType, LPARAM lParam)
{
	Assert(m_spRtrMgrProtocolInfo);
	return m_spRtrMgrProtocolInfo->RtrNotify(dwChangeType, dwObjectType, lParam);
}

STDMETHODIMP RtrMgrProtocolInfoAggregationWrapper::RtrUnadvise( LONG_PTR ulConnection)
{
	Assert(m_spRtrMgrProtocolInfo);
	return m_spRtrMgrProtocolInfo->RtrUnadvise(ulConnection);
}

STDMETHODIMP RtrMgrProtocolInfoAggregationWrapper::GetParentRtrMgrInfo(IRtrMgrInfo **ppRm)
{
	Assert(m_spRtrMgrProtocolInfo);
	return m_spRtrMgrProtocolInfo->GetParentRtrMgrInfo(ppRm);
}

STDMETHODIMP RtrMgrProtocolInfoAggregationWrapper::SetParentRtrMgrInfo(IRtrMgrInfo *pRm)
{
	Assert(m_spRtrMgrProtocolInfo);
	return m_spRtrMgrProtocolInfo->SetParentRtrMgrInfo(pRm);
}


HRESULT	RtrMgrProtocolInfoAggregationWrapper::DoDisconnect()
{
	Assert(m_spRtrMgrProtocolInfo);
	return m_spRtrMgrProtocolInfo->DoDisconnect();
}

STDMETHODIMP	RtrMgrProtocolInfoAggregationWrapper::AddWeakRef()
{
	Panic0("Should not be calling AddWeakRef from the Data object!");
	return E_FAIL;
}

STDMETHODIMP	RtrMgrProtocolInfoAggregationWrapper::ReleaseWeakRef()
{
	Panic0("Should not be calling ReleaseWeakRef from the Data object!");
	return E_FAIL;
}

STDMETHODIMP	RtrMgrProtocolInfoAggregationWrapper::Destruct()
{
	Panic0("Should not be calling Destruct from the Data object!");
	return E_FAIL;
}

/*!--------------------------------------------------------------------------
	CreateRtrMgrProtocolInfoAggregation
		Takes an existing IRtrMgrProtocolInfo and aggregates that with the
		passed-in object.  It returns a pointer to the non-delegating
		IUnknown on the IRtrMgrProtocolInfo.  This pointer is held by the
		controlling IUnknown.
	Author: KennT
 ---------------------------------------------------------------------------*/
TFSCORE_API(HRESULT) CreateRtrMgrProtocolInfoAggregation(IRtrMgrProtocolInfo *pInfo,
	IUnknown *punk, IUnknown **ppNonDelegatingIUnknown)
{
	RtrMgrProtocolInfoAggregationWrapper *	pAgg = NULL;
	HRESULT	hr = hrOK;

	COM_PROTECT_TRY
	{
		pAgg = new RtrMgrProtocolInfoAggregationWrapper(pInfo, punk);
		*ppNonDelegatingIUnknown = pAgg->GetNonDelegatingIUnknown();
	}
	COM_PROTECT_CATCH;
	return hr;
}



/*---------------------------------------------------------------------------
	RtrMgrInterfaceInfoAggregationWrapper
		This class is provided to use in an aggregation.
 ---------------------------------------------------------------------------*/
class RtrMgrInterfaceInfoAggregationWrapper :
   public IRtrMgrInterfaceInfo
{
public:
	RtrMgrInterfaceInfoAggregationWrapper(IRtrMgrInterfaceInfo *pInfo, IUnknown *punkOuter);
	virtual ~RtrMgrInterfaceInfoAggregationWrapper()
		{ DEBUG_DECREMENT_INSTANCE_COUNTER(RtrMgrInterfaceInfoAggregationWrapper); };

	// override the QI, we will use the AddRef/Release implementation
	// in the CDataObject
	DeclareIUnknownMembers(IMPL)
	DeclareIRtrMgrInterfaceInfoMembers(IMPL)

	IUnknown * GetNonDelegatingIUnknown() { return &m_ENonDelegatingIUnknown; }

protected:
	LONG			m_cRef;
	SPIRtrMgrInterfaceInfo	m_spRtrMgrInterfaceInfo;

	DECLARE_AGGREGATION_NONDELEGATING_IUNKNOWN(RtrMgrInterfaceInfoAggregationWrapper)

};

IMPLEMENT_AGGREGATION_IUNKNOWN(RtrMgrInterfaceInfoAggregationWrapper)

IMPLEMENT_AGGREGATION_NONDELEGATING_IUNKNOWN(RtrMgrInterfaceInfoAggregationWrapper, IRtrMgrInterfaceInfo)

DEBUG_DECLARE_INSTANCE_COUNTER(RtrMgrInterfaceInfoAggregationWrapper);

RtrMgrInterfaceInfoAggregationWrapper::RtrMgrInterfaceInfoAggregationWrapper(IRtrMgrInterfaceInfo *pInfo, IUnknown *punkOuter)
	: m_cRef(1)
{
	m_spRtrMgrInterfaceInfo.Set(pInfo);

	DEBUG_INCREMENT_INSTANCE_COUNTER(RtrMgrInterfaceInfoAggregationWrapper);
	
	if (punkOuter)
		m_pUnknownOuter = punkOuter;
	else
		m_pUnknownOuter = &m_ENonDelegatingIUnknown;
}


STDMETHODIMP RtrMgrInterfaceInfoAggregationWrapper::Load(LPCOLESTR   pszMachine,
										   HANDLE      hMachine,
											HANDLE hInterface,
										   HANDLE hTransport)
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->Load(pszMachine, hMachine, hInterface, hTransport);
}
				 
STDMETHODIMP	RtrMgrInterfaceInfoAggregationWrapper::Save(LPCOLESTR pszMachine,
										   HANDLE      hMachine,
										   HANDLE hInterface,
										   HANDLE hTransport,
										   IInfoBase *pInterface,
										   DWORD dwDeleteProtocolId)
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->Save(pszMachine, hMachine, hInterface,
										 hTransport, pInterface,
										 dwDeleteProtocolId);
}
	
STDMETHODIMP	RtrMgrInterfaceInfoAggregationWrapper::Unload( )
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->Unload();
}

STDMETHODIMP RtrMgrInterfaceInfoAggregationWrapper::Delete(LPCOLESTR pszMachine,
	HANDLE hMachine,
	HANDLE hInterface)
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->Delete(pszMachine, hMachine, hInterface);
}
	

STDMETHODIMP RtrMgrInterfaceInfoAggregationWrapper::SetInfo(DWORD dwSize,
	PBYTE pbData)
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->SetInfo(dwSize, pbData);
}

STDMETHODIMP RtrMgrInterfaceInfoAggregationWrapper::GetInfoBase(HANDLE hMachine,
	HANDLE hInterface, HANDLE hTransport, IInfoBase **ppInterface)
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->GetInfoBase(hMachine, hInterface, hTransport, ppInterface);
}

STDMETHODIMP RtrMgrInterfaceInfoAggregationWrapper::SetInfoBase(HANDLE hMachine,
	HANDLE hInterface, HANDLE hTransport, IInfoBase *pInterface)
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->SetInfoBase(hMachine, hInterface, hTransport, pInterface);
}

STDMETHODIMP RtrMgrInterfaceInfoAggregationWrapper::Merge(IRtrMgrInterfaceInfo *pNewRmIf)
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->Merge(pNewRmIf);
}

STDMETHODIMP_(LPCOLESTR) RtrMgrInterfaceInfoAggregationWrapper::GetId()
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->GetId();
}

STDMETHODIMP RtrMgrInterfaceInfoAggregationWrapper::SetId(LPCOLESTR pszId)
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->SetId(pszId);
}

STDMETHODIMP_(DWORD) RtrMgrInterfaceInfoAggregationWrapper::GetTransportId()
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->GetTransportId();
}

STDMETHODIMP_(LPCOLESTR) RtrMgrInterfaceInfoAggregationWrapper::GetInterfaceId()
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->GetInterfaceId();
}

STDMETHODIMP_(DWORD) RtrMgrInterfaceInfoAggregationWrapper::GetInterfaceType()
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->GetInterfaceType();
}

STDMETHODIMP_(LPCOLESTR) RtrMgrInterfaceInfoAggregationWrapper::GetTitle()
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->GetTitle();
}

STDMETHODIMP RtrMgrInterfaceInfoAggregationWrapper::SetTitle(LPCOLESTR pszTitle)
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->SetTitle(pszTitle);
}
	
STDMETHODIMP RtrMgrInterfaceInfoAggregationWrapper::CopyCB(RtrMgrInterfaceCB *pRtrMgrIfCB)
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->CopyCB(pRtrMgrIfCB);
}
	
STDMETHODIMP_(LPCOLESTR) RtrMgrInterfaceInfoAggregationWrapper::GetMachineName()
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->GetMachineName();
}

STDMETHODIMP RtrMgrInterfaceInfoAggregationWrapper::SetMachineName(LPCOLESTR pszMachineName)
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->SetMachineName(pszMachineName);
}

STDMETHODIMP_(DWORD) RtrMgrInterfaceInfoAggregationWrapper::GetFlags()
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->GetFlags();
}

STDMETHODIMP RtrMgrInterfaceInfoAggregationWrapper::SetFlags(DWORD dwFlags)
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->SetFlags(dwFlags);
}

STDMETHODIMP RtrMgrInterfaceInfoAggregationWrapper::EnumRtrMgrProtocolInterface( IEnumRtrMgrProtocolInterfaceInfo **ppEnumRmProtIf)
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->EnumRtrMgrProtocolInterface(ppEnumRmProtIf);
}

STDMETHODIMP RtrMgrInterfaceInfoAggregationWrapper::FindRtrMgrProtocolInterface(DWORD dwProtocolId,
					    IRtrMgrProtocolInterfaceInfo **ppInfo)
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->FindRtrMgrProtocolInterface(dwProtocolId, ppInfo);
}

STDMETHODIMP RtrMgrInterfaceInfoAggregationWrapper::AddRtrMgrProtocolInterface(IRtrMgrProtocolInterfaceInfo *pInfo,
					   IInfoBase *pInterfaceInfo)
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->AddRtrMgrProtocolInterface(pInfo, pInterfaceInfo);
}

STDMETHODIMP	RtrMgrInterfaceInfoAggregationWrapper::DeleteRtrMgrProtocolInterface( DWORD dwProtocolId, BOOL fRemove)
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->DeleteRtrMgrProtocolInterface(dwProtocolId, fRemove);
}

STDMETHODIMP	RtrMgrInterfaceInfoAggregationWrapper::ReleaseRtrMgrProtocolInterface( DWORD dwProtocolId)
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->ReleaseRtrMgrProtocolInterface(dwProtocolId);
}


STDMETHODIMP RtrMgrInterfaceInfoAggregationWrapper::SetParentInterfaceInfo(IInterfaceInfo *pInterfaceInfo)
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->SetParentInterfaceInfo(pInterfaceInfo);
}


STDMETHODIMP RtrMgrInterfaceInfoAggregationWrapper::GetParentInterfaceInfo(IInterfaceInfo **ppInterfaceInfo)
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->GetParentInterfaceInfo(ppInterfaceInfo);
}

STDMETHODIMP	RtrMgrInterfaceInfoAggregationWrapper::RtrAdvise( IRtrAdviseSink *pRtrAdviseSink,
					   LONG_PTR *pulConnection, LPARAM lUserParam)
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->RtrAdvise(pRtrAdviseSink, pulConnection, lUserParam);
}

STDMETHODIMP RtrMgrInterfaceInfoAggregationWrapper::RtrNotify(DWORD dwChangeType, DWORD dwObjectType, LPARAM lParam)
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->RtrNotify(dwChangeType, dwObjectType, lParam);
}

STDMETHODIMP RtrMgrInterfaceInfoAggregationWrapper::RtrUnadvise( LONG_PTR ulConnection)
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->RtrUnadvise(ulConnection);
}


HRESULT	RtrMgrInterfaceInfoAggregationWrapper::DoDisconnect()
{
	Assert(m_spRtrMgrInterfaceInfo);
	return m_spRtrMgrInterfaceInfo->DoDisconnect();
}

STDMETHODIMP	RtrMgrInterfaceInfoAggregationWrapper::AddWeakRef()
{
	Panic0("Should not be calling AddWeakRef from the Data object!");
	return E_FAIL;
}

STDMETHODIMP	RtrMgrInterfaceInfoAggregationWrapper::ReleaseWeakRef()
{
	Panic0("Should not be calling ReleaseWeakRef from the Data object!");
	return E_FAIL;
}

STDMETHODIMP	RtrMgrInterfaceInfoAggregationWrapper::Destruct()
{
	Panic0("Should not be calling Destruct from the Data object!");
	return E_FAIL;
}

/*!--------------------------------------------------------------------------
	CreateRtrMgrInterfaceInfoAggregation
		Takes an existing IRtrMgrInterfaceInfo and aggregates that with the
		passed-in object.  It returns a pointer to the non-delegating
		IUnknown on the IRtrMgrInterfaceInfo.  This pointer is held by the
		controlling IUnknown.
	Author: KennT
 ---------------------------------------------------------------------------*/
TFSCORE_API(HRESULT) CreateRtrMgrInterfaceInfoAggregation(IRtrMgrInterfaceInfo *pInfo,
	IUnknown *punk, IUnknown **ppNonDelegatingIUnknown)
{
	RtrMgrInterfaceInfoAggregationWrapper *	pAgg = NULL;
	HRESULT	hr = hrOK;

	COM_PROTECT_TRY
	{
		pAgg = new RtrMgrInterfaceInfoAggregationWrapper(pInfo, punk);
		*ppNonDelegatingIUnknown = pAgg->GetNonDelegatingIUnknown();
	}
	COM_PROTECT_CATCH;
	return hr;
}


/*---------------------------------------------------------------------------
	RtrMgrProtocolInterfaceInfoAggregationWrapper
		This class is provided to use in an aggregation.
 ---------------------------------------------------------------------------*/
class RtrMgrProtocolInterfaceInfoAggregationWrapper :
   public IRtrMgrProtocolInterfaceInfo
{
public:
	RtrMgrProtocolInterfaceInfoAggregationWrapper(IRtrMgrProtocolInterfaceInfo *pInfo, IUnknown *punkOuter);
	virtual ~RtrMgrProtocolInterfaceInfoAggregationWrapper()
		{ DEBUG_DECREMENT_INSTANCE_COUNTER(RtrMgrProtocolInterfaceInfoAggregationWrapper); };

	// override the QI, we will use the AddRef/Release implementation
	// in the CDataObject
	DeclareIUnknownMembers(IMPL)
	DeclareIRtrMgrProtocolInterfaceInfoMembers(IMPL)

	IUnknown * GetNonDelegatingIUnknown() { return &m_ENonDelegatingIUnknown; }

protected:
	LONG			m_cRef;
	SPIRtrMgrProtocolInterfaceInfo	m_spRtrMgrProtocolInterfaceInfo;

	DECLARE_AGGREGATION_NONDELEGATING_IUNKNOWN(RtrMgrProtocolInterfaceInfoAggregationWrapper)

};

IMPLEMENT_AGGREGATION_IUNKNOWN(RtrMgrProtocolInterfaceInfoAggregationWrapper)

IMPLEMENT_AGGREGATION_NONDELEGATING_IUNKNOWN(RtrMgrProtocolInterfaceInfoAggregationWrapper, IRtrMgrProtocolInterfaceInfo)

DEBUG_DECLARE_INSTANCE_COUNTER(RtrMgrProtocolInterfaceInfoAggregationWrapper);

RtrMgrProtocolInterfaceInfoAggregationWrapper::RtrMgrProtocolInterfaceInfoAggregationWrapper(IRtrMgrProtocolInterfaceInfo *pInfo, IUnknown *punkOuter)
	: m_cRef(1)
{
	m_spRtrMgrProtocolInterfaceInfo.Set(pInfo);

	DEBUG_INCREMENT_INSTANCE_COUNTER(RtrMgrProtocolInterfaceInfoAggregationWrapper);
	
	if (punkOuter)
		m_pUnknownOuter = punkOuter;
	else
		m_pUnknownOuter = &m_ENonDelegatingIUnknown;
}


STDMETHODIMP_(DWORD) RtrMgrProtocolInterfaceInfoAggregationWrapper::GetFlags()
{
	Assert(m_spRtrMgrProtocolInterfaceInfo);
	return m_spRtrMgrProtocolInterfaceInfo->GetFlags();
}

STDMETHODIMP RtrMgrProtocolInterfaceInfoAggregationWrapper::SetFlags(DWORD dwFlags)
{
	Assert(m_spRtrMgrProtocolInterfaceInfo);
	return m_spRtrMgrProtocolInterfaceInfo->SetFlags(dwFlags);
}

STDMETHODIMP_(DWORD) RtrMgrProtocolInterfaceInfoAggregationWrapper::GetProtocolId()
{
	Assert(m_spRtrMgrProtocolInterfaceInfo);
	return m_spRtrMgrProtocolInterfaceInfo->GetProtocolId();
}

STDMETHODIMP_(DWORD) RtrMgrProtocolInterfaceInfoAggregationWrapper::GetTransportId()
{
	Assert(m_spRtrMgrProtocolInterfaceInfo);
	return m_spRtrMgrProtocolInterfaceInfo->GetTransportId();
}

STDMETHODIMP_(LPCOLESTR) RtrMgrProtocolInterfaceInfoAggregationWrapper::GetTitle()
{
	Assert(m_spRtrMgrProtocolInterfaceInfo);
	return m_spRtrMgrProtocolInterfaceInfo->GetTitle();
}
	
STDMETHODIMP RtrMgrProtocolInterfaceInfoAggregationWrapper::SetTitle(LPCOLESTR pszTitle)
{
	Assert(m_spRtrMgrProtocolInterfaceInfo);
	return m_spRtrMgrProtocolInterfaceInfo->SetTitle(pszTitle);
}
	
STDMETHODIMP_(LPCOLESTR) RtrMgrProtocolInterfaceInfoAggregationWrapper::GetInterfaceId()
{
	Assert(m_spRtrMgrProtocolInterfaceInfo);
	return m_spRtrMgrProtocolInterfaceInfo->GetInterfaceId();
}
	
STDMETHODIMP_(DWORD) RtrMgrProtocolInterfaceInfoAggregationWrapper::GetInterfaceType()
{
	Assert(m_spRtrMgrProtocolInterfaceInfo);
	return m_spRtrMgrProtocolInterfaceInfo->GetInterfaceType();
}
	
STDMETHODIMP RtrMgrProtocolInterfaceInfoAggregationWrapper::CopyCB(RtrMgrProtocolInterfaceCB *pRtrMgrProtIfCB)
{
	Assert(m_spRtrMgrProtocolInterfaceInfo);
	return m_spRtrMgrProtocolInterfaceInfo->CopyCB(pRtrMgrProtIfCB);
}

	
STDMETHODIMP	RtrMgrProtocolInterfaceInfoAggregationWrapper::RtrAdvise( IRtrAdviseSink *pRtrAdviseSink,
					   LONG_PTR *pulConnection, LPARAM lUserParam)
{
	Assert(m_spRtrMgrProtocolInterfaceInfo);
	return m_spRtrMgrProtocolInterfaceInfo->RtrAdvise(pRtrAdviseSink, pulConnection, lUserParam);
}

STDMETHODIMP RtrMgrProtocolInterfaceInfoAggregationWrapper::RtrNotify(DWORD dwChangeType, DWORD dwObjectType, LPARAM lParam)
{
	Assert(m_spRtrMgrProtocolInterfaceInfo);
	return m_spRtrMgrProtocolInterfaceInfo->RtrNotify(dwChangeType, dwObjectType, lParam);
}

STDMETHODIMP RtrMgrProtocolInterfaceInfoAggregationWrapper::RtrUnadvise( LONG_PTR ulConnection)
{
	Assert(m_spRtrMgrProtocolInterfaceInfo);
	return m_spRtrMgrProtocolInterfaceInfo->RtrUnadvise(ulConnection);
}

STDMETHODIMP RtrMgrProtocolInterfaceInfoAggregationWrapper::GetParentRtrMgrInterfaceInfo(IRtrMgrInterfaceInfo **ppRm)
{
	Assert(m_spRtrMgrProtocolInterfaceInfo);
	return m_spRtrMgrProtocolInterfaceInfo->GetParentRtrMgrInterfaceInfo(ppRm);
}

STDMETHODIMP RtrMgrProtocolInterfaceInfoAggregationWrapper::SetParentRtrMgrInterfaceInfo(IRtrMgrInterfaceInfo *pRm)
{
	Assert(m_spRtrMgrProtocolInterfaceInfo);
	return m_spRtrMgrProtocolInterfaceInfo->SetParentRtrMgrInterfaceInfo(pRm);
}


HRESULT	RtrMgrProtocolInterfaceInfoAggregationWrapper::DoDisconnect()
{
	Assert(m_spRtrMgrProtocolInterfaceInfo);
	return m_spRtrMgrProtocolInterfaceInfo->DoDisconnect();
}

STDMETHODIMP	RtrMgrProtocolInterfaceInfoAggregationWrapper::AddWeakRef()
{
	Panic0("Should not be calling AddWeakRef from the Data object!");
	return E_FAIL;
}

STDMETHODIMP	RtrMgrProtocolInterfaceInfoAggregationWrapper::ReleaseWeakRef()
{
	Panic0("Should not be calling ReleaseWeakRef from the Data object!");
	return E_FAIL;
}

STDMETHODIMP	RtrMgrProtocolInterfaceInfoAggregationWrapper::Destruct()
{
	Panic0("Should not be calling Destruct from the Data object!");
	return E_FAIL;
}

/*!--------------------------------------------------------------------------
	CreateRtrMgrProtocolInterfaceInfoAggregation
		Takes an existing IRtrMgrProtocolInterfaceInfo and aggregates that with the
		passed-in object.  It returns a pointer to the non-delegating
		IUnknown on the IRtrMgrProtocolInterfaceInfo.  This pointer is held by the
		controlling IUnknown.
	Author: KennT
 ---------------------------------------------------------------------------*/
TFSCORE_API(HRESULT) CreateRtrMgrProtocolInterfaceInfoAggregation(IRtrMgrProtocolInterfaceInfo *pInfo,
	IUnknown *punk, IUnknown **ppNonDelegatingIUnknown)
{
	RtrMgrProtocolInterfaceInfoAggregationWrapper *	pAgg = NULL;
	HRESULT	hr = hrOK;

	COM_PROTECT_TRY
	{
		pAgg = new RtrMgrProtocolInterfaceInfoAggregationWrapper(pInfo, punk);
		*ppNonDelegatingIUnknown = pAgg->GetNonDelegatingIUnknown();
	}
	COM_PROTECT_CATCH;
	return hr;
}