able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/mmc/mprsnap/enum.cpp

1358 lines
25 KiB
C++
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/**********************************************************************/
/** Microsoft Windows/NT **/
/** Copyright(c) Microsoft Corporation, 1997 - 1997 **/
/**********************************************************************/
/*
info.cpp
FILE HISTORY:
*/
#include "stdafx.h"
#include "infoi.h"
/*---------------------------------------------------------------------------
Class: EnumRtrMgrCB
Definition and implementation
---------------------------------------------------------------------------*/
class EnumRtrMgrCB
: public IEnumRtrMgrCB
{
public:
DeclareIUnknownMembers(IMPL)
DeclareIEnumRtrMgrCBMembers(IMPL)
EnumRtrMgrCB() : m_cRef(1)
{
DEBUG_INCREMENT_INSTANCE_COUNTER(EnumRtrMgrCB);
}
#ifdef DEBUG
~EnumRtrMgrCB()
{
DEBUG_DECREMENT_INSTANCE_COUNTER(EnumRtrMgrCB);
}
#endif
HRESULT Init(SRtrMgrCBList *pRmCBList);
protected:
LONG m_cRef;
POSITION m_pos;
SRtrMgrCBList * m_pRmCBList;
};
IMPLEMENT_ADDREF_RELEASE(EnumRtrMgrCB);
IMPLEMENT_SIMPLE_QUERYINTERFACE(EnumRtrMgrCB, IEnumRtrMgrCB)
DEBUG_DECLARE_INSTANCE_COUNTER(EnumRtrMgrCB)
HRESULT EnumRtrMgrCB::Init(SRtrMgrCBList *pRmCBList)
{
m_pRmCBList = pRmCBList;
Reset();
return hrOK;
}
HRESULT EnumRtrMgrCB::Next(ULONG uNum, RtrMgrCB *pRmCB, ULONG *pNumReturned)
{
Assert(uNum == 1);
Assert(pRmCB);
HRESULT hr = hrOK;
SRtrMgrCB *pSRmCB;
COM_PROTECT_TRY
{
if (m_pos)
{
pSRmCB = m_pRmCBList->GetNext(m_pos);
Assert(pSRmCB);
pSRmCB->SaveTo(pRmCB);
if (pNumReturned)
*pNumReturned = 1;
hr = hrOK;
}
else
{
if (pNumReturned)
*pNumReturned = 0;
hr = hrFalse;
}
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrCB::Skip(ULONG uNum)
{
Assert(uNum == 1);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
if (m_pos)
{
m_pRmCBList->GetNext(m_pos);
}
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrCB::Reset()
{
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
m_pos = m_pRmCBList->GetHeadPosition();
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrCB::Clone(IEnumRtrMgrCB **ppBlockEnum)
{
return E_NOTIMPL;
}
/*---------------------------------------------------------------------------
Class: EnumRtrMgrProtocolCB
---------------------------------------------------------------------------*/
class EnumRtrMgrProtocolCB
: public IEnumRtrMgrProtocolCB
{
public:
DeclareIUnknownMembers(IMPL)
DeclareIEnumRtrMgrProtocolCBMembers(IMPL)
EnumRtrMgrProtocolCB() : m_cRef(1)
{
DEBUG_INCREMENT_INSTANCE_COUNTER(EnumRtrMgrProtocolCB);
}
#ifdef DEBUG
~EnumRtrMgrProtocolCB()
{
DEBUG_DECREMENT_INSTANCE_COUNTER(EnumRtrMgrProtocolCB);
}
#endif
HRESULT Init(SRtrMgrProtocolCBList *pRmProtCBList);
protected:
LONG m_cRef;
POSITION m_pos;
SRtrMgrProtocolCBList * m_pRmProtCBList;
};
IMPLEMENT_ADDREF_RELEASE(EnumRtrMgrProtocolCB);
IMPLEMENT_SIMPLE_QUERYINTERFACE(EnumRtrMgrProtocolCB, IEnumRtrMgrProtocolCB)
DEBUG_DECLARE_INSTANCE_COUNTER(EnumRtrMgrProtocolCB)
HRESULT EnumRtrMgrProtocolCB::Init(SRtrMgrProtocolCBList *pRmProtCBList)
{
m_pRmProtCBList = pRmProtCBList;
Reset();
return hrOK;
}
HRESULT EnumRtrMgrProtocolCB::Next(ULONG uNum, RtrMgrProtocolCB *pRmProtCB, ULONG *pNumReturned)
{
Assert(uNum == 1);
Assert(pRmProtCB);
HRESULT hr = hrOK;
SRtrMgrProtocolCB *pSRmProtCB;
COM_PROTECT_TRY
{
if (m_pos)
{
pSRmProtCB = m_pRmProtCBList->GetNext(m_pos);
Assert(pSRmProtCB);
pSRmProtCB->SaveTo(pRmProtCB);
if (pNumReturned)
*pNumReturned = 1;
hr = hrOK;
}
else
{
if (pNumReturned)
*pNumReturned = 0;
hr = hrFalse;
}
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrProtocolCB::Skip(ULONG uNum)
{
Assert(uNum == 1);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
if (m_pos)
{
m_pRmProtCBList->GetNext(m_pos);
}
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrProtocolCB::Reset()
{
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
m_pos = m_pRmProtCBList->GetHeadPosition();
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrProtocolCB::Clone(IEnumRtrMgrProtocolCB **ppBlockEnum)
{
return E_NOTIMPL;
}
/*---------------------------------------------------------------------------
Class: EnumInterfaceCB
---------------------------------------------------------------------------*/
class EnumInterfaceCB
: public IEnumInterfaceCB
{
public:
DeclareIUnknownMembers(IMPL)
DeclareIEnumInterfaceCBMembers(IMPL)
EnumInterfaceCB() : m_cRef(1)
{
DEBUG_INCREMENT_INSTANCE_COUNTER(EnumInterfaceCB);
}
#ifdef DEBUG
~EnumInterfaceCB()
{
DEBUG_DECREMENT_INSTANCE_COUNTER(EnumInterfaceCB);
}
#endif
HRESULT Init(SInterfaceCBList *pIfCBList);
protected:
LONG m_cRef;
POSITION m_pos;
SInterfaceCBList * m_pIfCBList;
};
IMPLEMENT_ADDREF_RELEASE(EnumInterfaceCB);
IMPLEMENT_SIMPLE_QUERYINTERFACE(EnumInterfaceCB, IEnumInterfaceCB)
DEBUG_DECLARE_INSTANCE_COUNTER(EnumInterfaceCB)
HRESULT EnumInterfaceCB::Init(SInterfaceCBList *pIfCBList)
{
m_pIfCBList = pIfCBList;
Reset();
return hrOK;
}
HRESULT EnumInterfaceCB::Next(ULONG uNum, InterfaceCB *pIfCB, ULONG *pNumReturned)
{
Assert(uNum == 1);
Assert(pIfCB);
HRESULT hr = hrOK;
SInterfaceCB *pSIfCB;
COM_PROTECT_TRY
{
if (m_pos)
{
pSIfCB = m_pIfCBList->GetNext(m_pos);
Assert(pSIfCB);
pSIfCB->SaveTo(pIfCB);
if (pNumReturned)
*pNumReturned = 1;
hr = hrOK;
}
else
{
if (pNumReturned)
*pNumReturned = 0;
hr = hrFalse;
}
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumInterfaceCB::Skip(ULONG uNum)
{
Assert(uNum == 1);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
if (m_pos)
{
m_pIfCBList->GetNext(m_pos);
}
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumInterfaceCB::Reset()
{
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
m_pos = m_pIfCBList->GetHeadPosition();
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumInterfaceCB::Clone(IEnumInterfaceCB **ppBlockEnum)
{
return E_NOTIMPL;
}
/*---------------------------------------------------------------------------
Class: EnumRtrMgrInterfaceCB
---------------------------------------------------------------------------*/
class EnumRtrMgrInterfaceCB
: public IEnumRtrMgrInterfaceCB
{
public:
DeclareIUnknownMembers(IMPL)
DeclareIEnumRtrMgrInterfaceCBMembers(IMPL)
EnumRtrMgrInterfaceCB() : m_cRef(1)
{
DEBUG_INCREMENT_INSTANCE_COUNTER(EnumRtrMgrInterfaceCB);
}
#ifdef DEBUG
~EnumRtrMgrInterfaceCB()
{
DEBUG_DECREMENT_INSTANCE_COUNTER(EnumRtrMgrInterfaceCB);
}
#endif
HRESULT Init(SRtrMgrInterfaceCBList *pRmIfCBList);
protected:
LONG m_cRef;
POSITION m_pos;
SRtrMgrInterfaceCBList * m_pRmIfCBList;
};
IMPLEMENT_ADDREF_RELEASE(EnumRtrMgrInterfaceCB);
IMPLEMENT_SIMPLE_QUERYINTERFACE(EnumRtrMgrInterfaceCB, IEnumRtrMgrInterfaceCB)
DEBUG_DECLARE_INSTANCE_COUNTER(EnumRtrMgrInterfaceCB)
HRESULT EnumRtrMgrInterfaceCB::Init(SRtrMgrInterfaceCBList *pRmIfCBList)
{
m_pRmIfCBList = pRmIfCBList;
Reset();
return hrOK;
}
HRESULT EnumRtrMgrInterfaceCB::Next(ULONG uNum, RtrMgrInterfaceCB *pRmIfCB, ULONG *pNumReturned)
{
Assert(uNum == 1);
Assert(pRmIfCB);
HRESULT hr = hrOK;
SRtrMgrInterfaceCB *pSRmIfCB;
COM_PROTECT_TRY
{
if (m_pos)
{
pSRmIfCB = m_pRmIfCBList->GetNext(m_pos);
Assert(pSRmIfCB);
pSRmIfCB->SaveTo(pRmIfCB);
if (pNumReturned)
*pNumReturned = 1;
hr = hrOK;
}
else
{
if (pNumReturned)
*pNumReturned = 0;
hr = hrFalse;
}
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrInterfaceCB::Skip(ULONG uNum)
{
Assert(uNum == 1);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
if (m_pos)
{
m_pRmIfCBList->GetNext(m_pos);
}
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrInterfaceCB::Reset()
{
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
m_pos = m_pRmIfCBList->GetHeadPosition();
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrInterfaceCB::Clone(IEnumRtrMgrInterfaceCB **ppBlockEnum)
{
return E_NOTIMPL;
}
/*---------------------------------------------------------------------------
Class: EnumRtrMgrInterfaceProtocolCB
---------------------------------------------------------------------------*/
class EnumRtrMgrProtocolInterfaceCB
: public IEnumRtrMgrProtocolInterfaceCB
{
public:
DeclareIUnknownMembers(IMPL)
DeclareIEnumRtrMgrProtocolInterfaceCBMembers(IMPL)
EnumRtrMgrProtocolInterfaceCB() : m_cRef(1)
{
DEBUG_INCREMENT_INSTANCE_COUNTER(EnumRtrMgrProtocolInterfaceCB);
}
#ifdef DEBUG
~EnumRtrMgrProtocolInterfaceCB()
{
DEBUG_DECREMENT_INSTANCE_COUNTER(EnumRtrMgrProtocolInterfaceCB);
}
#endif
HRESULT Init(SRtrMgrProtocolInterfaceCBList *pRmProtIfCBList);
protected:
LONG m_cRef;
POSITION m_pos;
SRtrMgrProtocolInterfaceCBList * m_pRmProtIfCBList;
};
IMPLEMENT_ADDREF_RELEASE(EnumRtrMgrProtocolInterfaceCB);
IMPLEMENT_SIMPLE_QUERYINTERFACE(EnumRtrMgrProtocolInterfaceCB, IEnumRtrMgrProtocolInterfaceCB)
DEBUG_DECLARE_INSTANCE_COUNTER(EnumRtrMgrProtocolInterfaceCB)
HRESULT EnumRtrMgrProtocolInterfaceCB::Init(SRtrMgrProtocolInterfaceCBList *pRmProtIfCBList)
{
m_pRmProtIfCBList = pRmProtIfCBList;
Reset();
return hrOK;
}
HRESULT EnumRtrMgrProtocolInterfaceCB::Next(ULONG uNum, RtrMgrProtocolInterfaceCB *pRmProtIfCB, ULONG *pNumReturned)
{
Assert(uNum == 1);
Assert(pRmProtIfCB);
HRESULT hr = hrOK;
SRtrMgrProtocolInterfaceCB *pSRmProtIfCB;
COM_PROTECT_TRY
{
if (m_pos)
{
pSRmProtIfCB = m_pRmProtIfCBList->GetNext(m_pos);
Assert(pSRmProtIfCB);
pSRmProtIfCB->SaveTo(pRmProtIfCB);
if (pNumReturned)
*pNumReturned = 1;
hr = hrOK;
}
else
{
if (pNumReturned)
*pNumReturned = 0;
hr = hrFalse;
}
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrProtocolInterfaceCB::Skip(ULONG uNum)
{
Assert(uNum == 1);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
if (m_pos)
{
m_pRmProtIfCBList->GetNext(m_pos);
}
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrProtocolInterfaceCB::Reset()
{
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
m_pos = m_pRmProtIfCBList->GetHeadPosition();
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrProtocolInterfaceCB::Clone(IEnumRtrMgrProtocolInterfaceCB **ppBlockEnum)
{
return E_NOTIMPL;
}
/*!--------------------------------------------------------------------------
CreateEnumFromSRmCBList
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT CreateEnumFromSRmCBList(SRtrMgrCBList *pRmCBList,
IEnumRtrMgrCB **ppEnum)
{
Assert(pRmCBList);
Assert(ppEnum);
HRESULT hr = hrOK;
EnumRtrMgrCB * pEnum;
pEnum = new EnumRtrMgrCB;
hr = pEnum->Init(pRmCBList);
if (!FHrSucceeded(hr))
{
pEnum->Release();
pEnum = NULL;
}
*ppEnum = pEnum;
return hr;
}
/*!--------------------------------------------------------------------------
CreateEnumFromSRmProtCBList
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT CreateEnumFromSRmProtCBList(SRtrMgrProtocolCBList *pRmProtCBList,
IEnumRtrMgrProtocolCB **ppEnum)
{
Assert(pRmProtCBList);
Assert(ppEnum);
HRESULT hr = hrOK;
EnumRtrMgrProtocolCB * pEnum;
pEnum = new EnumRtrMgrProtocolCB;
hr = pEnum->Init(pRmProtCBList);
if (!FHrSucceeded(hr))
{
pEnum->Release();
pEnum = NULL;
}
*ppEnum = pEnum;
return hr;
}
/*!--------------------------------------------------------------------------
CreateEnumFromSIfCBList
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT CreateEnumFromSIfCBList(SInterfaceCBList *pIfCBList,
IEnumInterfaceCB **ppEnum)
{
Assert(pIfCBList);
Assert(ppEnum);
HRESULT hr = hrOK;
EnumInterfaceCB * pEnum;
pEnum = new EnumInterfaceCB;
hr = pEnum->Init(pIfCBList);
if (!FHrSucceeded(hr))
{
pEnum->Release();
pEnum = NULL;
}
*ppEnum = pEnum;
return hr;
}
/*!--------------------------------------------------------------------------
CreateEnumFromSRmIfCBList
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT CreateEnumFromSRmIfCBList(SRtrMgrInterfaceCBList *pRmIfCBList,
IEnumRtrMgrInterfaceCB **ppEnum)
{
Assert(pRmIfCBList);
Assert(ppEnum);
HRESULT hr = hrOK;
EnumRtrMgrInterfaceCB * pEnum;
pEnum = new EnumRtrMgrInterfaceCB;
hr = pEnum->Init(pRmIfCBList);
if (!FHrSucceeded(hr))
{
pEnum->Release();
pEnum = NULL;
}
*ppEnum = pEnum;
return hr;
}
/*!--------------------------------------------------------------------------
CreateEnumFromSRmProtIfCBList
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT CreateEnumFromSRmProtIfCBList(SRtrMgrProtocolInterfaceCBList *pRmProtIfCBList,
IEnumRtrMgrProtocolInterfaceCB **ppEnum)
{
Assert(pRmProtIfCBList);
Assert(ppEnum);
HRESULT hr = hrOK;
EnumRtrMgrProtocolInterfaceCB * pEnum;
pEnum = new EnumRtrMgrProtocolInterfaceCB;
hr = pEnum->Init(pRmProtIfCBList);
if (!FHrSucceeded(hr))
{
pEnum->Release();
pEnum = NULL;
}
*ppEnum = pEnum;
return hr;
}
/*---------------------------------------------------------------------------
Class: EnumRtrMgrList
Definition and implementation
---------------------------------------------------------------------------*/
class EnumRtrMgrList
: public IEnumRtrMgrInfo
{
public:
DeclareIUnknownMembers(IMPL)
DeclareIEnumRtrMgrInfoMembers(IMPL)
EnumRtrMgrList() : m_cRef(1)
{
DEBUG_INCREMENT_INSTANCE_COUNTER(EnumRtrMgrList);
}
#ifdef DEBUG
~EnumRtrMgrList()
{
DEBUG_DECREMENT_INSTANCE_COUNTER(EnumRtrMgrList);
}
#endif
HRESULT Init(RmDataList *pRmList);
protected:
LONG m_cRef;
POSITION m_pos;
RmDataList * m_pRmList;
};
IMPLEMENT_ADDREF_RELEASE(EnumRtrMgrList);
IMPLEMENT_SIMPLE_QUERYINTERFACE(EnumRtrMgrList, IEnumRtrMgrInfo)
DEBUG_DECLARE_INSTANCE_COUNTER(EnumRtrMgrList)
HRESULT EnumRtrMgrList::Init(RmDataList *pRmList)
{
m_pRmList = pRmList;
Reset();
return hrOK;
}
HRESULT EnumRtrMgrList::Next(ULONG uNum, IRtrMgrInfo **ppRm, ULONG *pNumReturned)
{
Assert(uNum == 1);
Assert(ppRm);
HRESULT hr = hrOK;
SRmData rmData;
COM_PROTECT_TRY
{
if (m_pos)
{
rmData = m_pRmList->GetNext(m_pos);
*ppRm = rmData.m_pRmInfo;
(*ppRm)->AddRef();
if (pNumReturned)
*pNumReturned = 1;
hr = hrOK;
}
else
{
if (pNumReturned)
*pNumReturned = 0;
hr = hrFalse;
}
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrList::Skip(ULONG uNum)
{
Assert(uNum == 1);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
if (m_pos)
{
m_pRmList->GetNext(m_pos);
}
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrList::Reset()
{
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
m_pos = m_pRmList->GetHeadPosition();
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrList::Clone(IEnumRtrMgrInfo **ppBlockEnum)
{
return E_NOTIMPL;
}
/*---------------------------------------------------------------------------
Class: EnumRtrMgrProtocolList
Definition and implementation
---------------------------------------------------------------------------*/
class EnumRtrMgrProtocolList
: public IEnumRtrMgrProtocolInfo
{
public:
DeclareIUnknownMembers(IMPL)
DeclareIEnumRtrMgrProtocolInfoMembers(IMPL)
EnumRtrMgrProtocolList() : m_cRef(1)
{
DEBUG_INCREMENT_INSTANCE_COUNTER(EnumRtrMgrProtocolList);
}
#ifdef DEBUG
~EnumRtrMgrProtocolList()
{
DEBUG_DECREMENT_INSTANCE_COUNTER(EnumRtrMgrProtocolList);
}
#endif
HRESULT Init(PRtrMgrProtocolInfoList *pRmProtList);
protected:
LONG m_cRef;
POSITION m_pos;
PRtrMgrProtocolInfoList * m_pRmProtList;
};
IMPLEMENT_ADDREF_RELEASE(EnumRtrMgrProtocolList);
IMPLEMENT_SIMPLE_QUERYINTERFACE(EnumRtrMgrProtocolList, IEnumRtrMgrProtocolInfo)
DEBUG_DECLARE_INSTANCE_COUNTER(EnumRtrMgrProtocolList)
HRESULT EnumRtrMgrProtocolList::Init(PRtrMgrProtocolInfoList *pRmProtList)
{
m_pRmProtList = pRmProtList;
Reset();
return hrOK;
}
HRESULT EnumRtrMgrProtocolList::Next(ULONG uNum, IRtrMgrProtocolInfo **ppRm, ULONG *pNumReturned)
{
Assert(uNum == 1);
Assert(ppRm);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
if (m_pos)
{
*ppRm = m_pRmProtList->GetNext(m_pos);
(*ppRm)->AddRef();
if (pNumReturned)
*pNumReturned = 1;
hr = hrOK;
}
else
{
if (pNumReturned)
*pNumReturned = 0;
hr = hrFalse;
}
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrProtocolList::Skip(ULONG uNum)
{
Assert(uNum == 1);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
if (m_pos)
{
m_pRmProtList->GetNext(m_pos);
}
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrProtocolList::Reset()
{
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
m_pos = m_pRmProtList->GetHeadPosition();
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrProtocolList::Clone(IEnumRtrMgrProtocolInfo **ppBlockEnum)
{
return E_NOTIMPL;
}
/*---------------------------------------------------------------------------
Class: EnumInterfaceList
Definition and implementation
---------------------------------------------------------------------------*/
class EnumInterfaceList
: public IEnumInterfaceInfo
{
public:
DeclareIUnknownMembers(IMPL)
DeclareIEnumInterfaceInfoMembers(IMPL)
EnumInterfaceList() : m_cRef(1)
{
DEBUG_INCREMENT_INSTANCE_COUNTER(EnumInterfaceList);
}
#ifdef DEBUG
~EnumInterfaceList()
{
DEBUG_DECREMENT_INSTANCE_COUNTER(EnumInterfaceList);
}
#endif
HRESULT Init(PInterfaceInfoList *pIfList);
protected:
LONG m_cRef;
POSITION m_pos;
PInterfaceInfoList * m_pIfList;
};
IMPLEMENT_ADDREF_RELEASE(EnumInterfaceList);
IMPLEMENT_SIMPLE_QUERYINTERFACE(EnumInterfaceList, IEnumInterfaceInfo)
DEBUG_DECLARE_INSTANCE_COUNTER(EnumInterfaceList)
HRESULT EnumInterfaceList::Init(PInterfaceInfoList *pIfList)
{
m_pIfList = pIfList;
Reset();
return hrOK;
}
HRESULT EnumInterfaceList::Next(ULONG uNum, IInterfaceInfo **ppRm, ULONG *pNumReturned)
{
Assert(uNum == 1);
Assert(ppRm);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
if (m_pos)
{
*ppRm = m_pIfList->GetNext(m_pos);
(*ppRm)->AddRef();
if (pNumReturned)
*pNumReturned = 1;
hr = hrOK;
}
else
{
if (pNumReturned)
*pNumReturned = 0;
hr = hrFalse;
}
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumInterfaceList::Skip(ULONG uNum)
{
Assert(uNum == 1);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
if (m_pos)
{
m_pIfList->GetNext(m_pos);
}
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumInterfaceList::Reset()
{
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
m_pos = m_pIfList->GetHeadPosition();
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumInterfaceList::Clone(IEnumInterfaceInfo **ppBlockEnum)
{
return E_NOTIMPL;
}
/*---------------------------------------------------------------------------
Class: EnumRtrMgrInterfaceList
Definition and implementation
---------------------------------------------------------------------------*/
class EnumRtrMgrInterfaceList
: public IEnumRtrMgrInterfaceInfo
{
public:
DeclareIUnknownMembers(IMPL)
DeclareIEnumRtrMgrInterfaceInfoMembers(IMPL)
EnumRtrMgrInterfaceList() : m_cRef(1)
{
DEBUG_INCREMENT_INSTANCE_COUNTER(EnumRtrMgrInterfaceList);
}
#ifdef DEBUG
~EnumRtrMgrInterfaceList()
{
DEBUG_DECREMENT_INSTANCE_COUNTER(EnumRtrMgrInterfaceList);
}
#endif
HRESULT Init(PRtrMgrInterfaceInfoList *pRmIfList);
protected:
LONG m_cRef;
POSITION m_pos;
PRtrMgrInterfaceInfoList * m_pRmIfList;
};
IMPLEMENT_ADDREF_RELEASE(EnumRtrMgrInterfaceList);
IMPLEMENT_SIMPLE_QUERYINTERFACE(EnumRtrMgrInterfaceList, IEnumRtrMgrInterfaceInfo)
DEBUG_DECLARE_INSTANCE_COUNTER(EnumRtrMgrInterfaceList)
HRESULT EnumRtrMgrInterfaceList::Init(PRtrMgrInterfaceInfoList *pRmIfList)
{
m_pRmIfList = pRmIfList;
Reset();
return hrOK;
}
HRESULT EnumRtrMgrInterfaceList::Next(ULONG uNum, IRtrMgrInterfaceInfo **ppRm, ULONG *pNumReturned)
{
Assert(uNum == 1);
Assert(ppRm);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
if (m_pos)
{
*ppRm = m_pRmIfList->GetNext(m_pos);
(*ppRm)->AddRef();
if (pNumReturned)
*pNumReturned = 1;
hr = hrOK;
}
else
{
if (pNumReturned)
*pNumReturned = 0;
hr = hrFalse;
}
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrInterfaceList::Skip(ULONG uNum)
{
Assert(uNum == 1);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
if (m_pos)
{
m_pRmIfList->GetNext(m_pos);
}
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrInterfaceList::Reset()
{
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
m_pos = m_pRmIfList->GetHeadPosition();
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrInterfaceList::Clone(IEnumRtrMgrInterfaceInfo **ppBlockEnum)
{
return E_NOTIMPL;
}
/*---------------------------------------------------------------------------
Class: EnumRtrMgrProtocolInterfaceList
Definition and implementation
---------------------------------------------------------------------------*/
class EnumRtrMgrProtocolInterfaceList
: public IEnumRtrMgrProtocolInterfaceInfo
{
public:
DeclareIUnknownMembers(IMPL)
DeclareIEnumRtrMgrProtocolInterfaceInfoMembers(IMPL)
EnumRtrMgrProtocolInterfaceList() : m_cRef(1)
{
DEBUG_INCREMENT_INSTANCE_COUNTER(EnumRtrMgrProtocolInterfaceList);
}
#ifdef DEBUG
~EnumRtrMgrProtocolInterfaceList()
{
DEBUG_DECREMENT_INSTANCE_COUNTER(EnumRtrMgrProtocolInterfaceList);
}
#endif
HRESULT Init(PRtrMgrProtocolInterfaceInfoList *pRmProtIfList);
protected:
LONG m_cRef;
POSITION m_pos;
PRtrMgrProtocolInterfaceInfoList * m_pRmProtIfList;
};
IMPLEMENT_ADDREF_RELEASE(EnumRtrMgrProtocolInterfaceList);
IMPLEMENT_SIMPLE_QUERYINTERFACE(EnumRtrMgrProtocolInterfaceList, IEnumRtrMgrProtocolInterfaceInfo)
DEBUG_DECLARE_INSTANCE_COUNTER(EnumRtrMgrProtocolInterfaceList)
HRESULT EnumRtrMgrProtocolInterfaceList::Init(PRtrMgrProtocolInterfaceInfoList *pRmProtIfList)
{
m_pRmProtIfList = pRmProtIfList;
Reset();
return hrOK;
}
HRESULT EnumRtrMgrProtocolInterfaceList::Next(ULONG uNum, IRtrMgrProtocolInterfaceInfo **ppRm, ULONG *pNumReturned)
{
Assert(uNum == 1);
Assert(ppRm);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
if (m_pos)
{
*ppRm = m_pRmProtIfList->GetNext(m_pos);
(*ppRm)->AddRef();
if (pNumReturned)
*pNumReturned = 1;
hr = hrOK;
}
else
{
if (pNumReturned)
*pNumReturned = 0;
hr = hrFalse;
}
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrProtocolInterfaceList::Skip(ULONG uNum)
{
Assert(uNum == 1);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
if (m_pos)
{
m_pRmProtIfList->GetNext(m_pos);
}
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrProtocolInterfaceList::Reset()
{
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
m_pos = m_pRmProtIfList->GetHeadPosition();
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT EnumRtrMgrProtocolInterfaceList::Clone(IEnumRtrMgrProtocolInterfaceInfo **ppBlockEnum)
{
return E_NOTIMPL;
}
/*!--------------------------------------------------------------------------
CreateEnumFromRmList
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT CreateEnumFromRmList(RmDataList *pRmList, IEnumRtrMgrInfo **ppEnum)
{
Assert(pRmList);
Assert(ppEnum);
HRESULT hr = hrOK;
EnumRtrMgrList * pEnum;
pEnum = new EnumRtrMgrList;
hr = pEnum->Init(pRmList);
if (!FHrSucceeded(hr))
{
pEnum->Release();
pEnum = NULL;
}
*ppEnum = pEnum;
return hr;
}
/*!--------------------------------------------------------------------------
CreateEnumFromRtrMgrProtocolList
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT CreateEnumFromRtrMgrProtocolList(PRtrMgrProtocolInfoList *pList, IEnumRtrMgrProtocolInfo **ppEnum)
{
Assert(pList);
Assert(ppEnum);
HRESULT hr = hrOK;
EnumRtrMgrProtocolList * pEnum;
pEnum = new EnumRtrMgrProtocolList;
hr = pEnum->Init(pList);
if (!FHrSucceeded(hr))
{
pEnum->Release();
pEnum = NULL;
}
*ppEnum = pEnum;
return hr;
}
/*!--------------------------------------------------------------------------
CreateEnumFromInterfaceList
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT CreateEnumFromInterfaceList(PInterfaceInfoList *pList, IEnumInterfaceInfo **ppEnum)
{
Assert(pList);
Assert(ppEnum);
HRESULT hr = hrOK;
EnumInterfaceList * pEnum;
pEnum = new EnumInterfaceList;
hr = pEnum->Init(pList);
if (!FHrSucceeded(hr))
{
pEnum->Release();
pEnum = NULL;
}
*ppEnum = pEnum;
return hr;
}
/*!--------------------------------------------------------------------------
CreateEnumFromRtrMgrInterfaceList
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT CreateEnumFromRtrMgrInterfaceList(PRtrMgrInterfaceInfoList *pList, IEnumRtrMgrInterfaceInfo **ppEnum)
{
Assert(pList);
Assert(ppEnum);
HRESULT hr = hrOK;
EnumRtrMgrInterfaceList * pEnum;
pEnum = new EnumRtrMgrInterfaceList;
hr = pEnum->Init(pList);
if (!FHrSucceeded(hr))
{
pEnum->Release();
pEnum = NULL;
}
*ppEnum = pEnum;
return hr;
}
/*!--------------------------------------------------------------------------
CreateEnumFromRtrMgrProtocolInterfaceList
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT CreateEnumFromRtrMgrProtocolInterfaceList(PRtrMgrProtocolInterfaceInfoList *pList, IEnumRtrMgrProtocolInterfaceInfo **ppEnum)
{
Assert(pList);
Assert(ppEnum);
HRESULT hr = hrOK;
EnumRtrMgrProtocolInterfaceList * pEnum;
pEnum = new EnumRtrMgrProtocolInterfaceList;
hr = pEnum->Init(pList);
if (!FHrSucceeded(hr))
{
pEnum->Release();
pEnum = NULL;
}
*ppEnum = pEnum;
return hr;
}
Reference in a new issue Copy permalink