OS_Develop/Windows-Server-2003
OS_Develop/Windows-Server-2003
1
0
Fork 0
Code Pull Requests Activity
master
Windows-Server-2003/net/mmc/tapi/harray.cpp

868 lines
24 KiB
C++
Raw Permalink Normal View History

Initiall commit
2024-08-04 01:28:15 +02:00
/**********************************************************************/
/** Microsoft Windows/NT **/
/** Copyright(c) Microsoft Corporation, 1997 - 1999 **/
/**********************************************************************/
/*
hArray.cpp
Index manager for TAPI devices db
FILE HISTORY:
Dec 16 1997 EricDav Created
*/
#include "stdafx.h"
#include "harray.h"
#include "mbstring.h"
LPBYTE g_pStart;
/*!--------------------------------------------------------------------------
Class CHDeviceIndex
---------------------------------------------------------------------------*/
CHDeviceIndex::CHDeviceIndex(INDEX_TYPE IndexType)
: m_dbType(IndexType), m_bAscending(TRUE)
{
}
CHDeviceIndex::~CHDeviceIndex()
{
}
/*!--------------------------------------------------------------------------
CHDeviceIndex::GetType
-
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CHDeviceIndex::GetType(INDEX_TYPE * pIndexType)
{
if (pIndexType)
*pIndexType = m_dbType;
return hrOK;
}
/*!--------------------------------------------------------------------------
CHDeviceIndex::SetArray
-
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CHDeviceIndex::SetArray(HDeviceArray & hdeviceArray)
{
m_hdeviceArray.Copy(hdeviceArray);
return hrOK;
}
/*!--------------------------------------------------------------------------
CHDeviceIndex::GetHDevice
-
Author: EricDav
---------------------------------------------------------------------------*/
HDEVICE
CHDeviceIndex::GetHDevice(int nIndex)
{
Assert(nIndex >= 0);
Assert(nIndex <= m_hdeviceArray.GetSize());
if (nIndex < 0 ||
nIndex >= m_hdeviceArray.GetSize())
{
return NULL;
}
return m_hdeviceArray.GetAt(nIndex);
}
/*!--------------------------------------------------------------------------
CHDeviceIndex::GetIndex
-
Author: EricDav
---------------------------------------------------------------------------*/
int
CHDeviceIndex::GetIndex(HDEVICE hdevice)
{
Assert(hdevice != 0);
LPHDEVICE phdevice = (LPHDEVICE) BSearch((const void *)&hdevice,
(const void *)m_hdeviceArray.GetData(),
(size_t)m_hdeviceArray.GetSize(),
sizeof(HDEVICE));
int nIndex = (int) (phdevice - (LPHDEVICE) m_hdeviceArray.GetData());
Assert(nIndex >= 0);
Assert(nIndex <= m_hdeviceArray.GetSize());
int nComp, nIndexTemp;
nComp = BCompare(&hdevice, phdevice);
if (nComp == 0)
{
// found the right one, check the previous one to return the first
// record in a list of duplicates
nIndexTemp = nIndex;
while (nIndexTemp && nComp == 0)
{
*phdevice = m_hdeviceArray.GetAt(--nIndexTemp);
nComp = BCompare(&hdevice, phdevice);
}
if (nIndexTemp == nIndex)
return nIndex; // nIndex should be zero here as well
else
if (nComp == 0)
return nIndexTemp; // nIndexTemp should be 0 in this case
else
return nIndexTemp++;
}
return -1;
}
/*!--------------------------------------------------------------------------
CHDeviceIndex::Add
-
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CHDeviceIndex::Add(HDEVICE hdevice, BOOL bEnd)
{
// if we are loading the array then just stick this on the end
if (bEnd)
{
m_hdeviceArray.Add(hdevice);
}
else
{
if (m_hdeviceArray.GetSize() == 0)
{
m_hdeviceArray.Add(hdevice);
}
else
{
LPHDEVICE phdevice = (LPHDEVICE) BSearch((const void *)&hdevice,
(const void *)m_hdeviceArray.GetData(),
(size_t)m_hdeviceArray.GetSize(),
sizeof(HDEVICE));
int nIndex = (int) (phdevice - (LPHDEVICE) m_hdeviceArray.GetData());
Assert(nIndex >= 0);
Assert(nIndex <= m_hdeviceArray.GetSize());
int nComp = BCompare(&hdevice, phdevice);
if (nComp < 0)
{
if(nIndex == 0)
m_hdeviceArray.InsertAt(nIndex , hdevice);
else // Insert before phdevice
m_hdeviceArray.InsertAt(nIndex - 1, hdevice);
}
else
{
// insert after phdevice
m_hdeviceArray.InsertAt(nIndex + 1, hdevice);
}
}
}
return hrOK;
}
/*!--------------------------------------------------------------------------
CHDeviceIndex::Remove
-
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CHDeviceIndex::Remove(HDEVICE hdevice)
{
// do a bsearch for the record and then remove
LPHDEVICE phdevice = (LPHDEVICE) BSearch(&hdevice,
m_hdeviceArray.GetData(),
(size_t)m_hdeviceArray.GetSize(),
sizeof(HDEVICE));
int nComp = BCompare(&hdevice, phdevice);
Assert(nComp == 0);
if (nComp != 0)
return E_FAIL;
// calculate the index
int nIndex = (int) (phdevice - (LPHDEVICE) m_hdeviceArray.GetData());
Assert(nIndex >= 0);
Assert(nIndex <= m_hdeviceArray.GetSize());
m_hdeviceArray.RemoveAt(nIndex);
return hrOK;
}
/*!--------------------------------------------------------------------------
CHDeviceIndex::BSearch
Modified bsearch which returns the closest or equal element in
an array
Author: EricDav
---------------------------------------------------------------------------*/
void *
CHDeviceIndex::BSearch (const void *key,
const void *base,
size_t num,
size_t width)
{
char *lo = (char *)base;
char *hi = (char *)base + (num - 1) * width;
char *mid;
unsigned int half;
int result;
while (lo <= hi)
if (half = num / 2)
{
mid = lo + (num & 1 ? half : (half - 1)) * width;
if (!(result = BCompare(key,mid)))
return(mid);
else if (result < 0)
{
hi = mid - width;
num = num & 1 ? half : half-1;
}
else {
lo = mid + width;
num = half;
}
}
else if (num)
return(lo);
else
break;
return(mid);
}
/*!--------------------------------------------------------------------------
Class CIndexMgr
---------------------------------------------------------------------------*/
CIndexMgr::CIndexMgr()
{
m_posCurrentProvider= NULL;
}
CIndexMgr::~CIndexMgr()
{
Reset();
}
/*!--------------------------------------------------------------------------
CIndexMgr::Initialize
-
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CIndexMgr::Initialize()
{
HRESULT hr = hrOK;
CSingleLock cl(&m_cs);
cl.Lock();
COM_PROTECT_TRY
{
// cleanup
Reset();
}
COM_PROTECT_CATCH
return hr;
}
/*!--------------------------------------------------------------------------
CIndexMgr::Reset
-
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CIndexMgr::Reset()
{
CSingleLock cl(&m_cs);
cl.Lock();
while (m_listProviderIndex.GetCount() > 0)
{
CProviderIndexInfo * pProviderIndexInfo = m_listProviderIndex.RemoveHead();
while (pProviderIndexInfo->m_listIndicies.GetCount() > 0)
delete pProviderIndexInfo->m_listIndicies.RemoveHead();
delete pProviderIndexInfo;
}
return hrOK;
}
/*!--------------------------------------------------------------------------
CIndexMgr::GetTotalCount
The index sorted by name contains the total database and should
always be available. Use this for the total count.
Author: EricDav
---------------------------------------------------------------------------*/
UINT
CIndexMgr::GetTotalCount()
{
CSingleLock cl(&m_cs);
cl.Lock();
UINT uTotalCount = 0;
POSITION pos;
pos = m_listProviderIndex.GetHeadPosition();
while (pos)
{
CProviderIndexInfo * pProviderIndexInfo = m_listProviderIndex.GetNext(pos);
if (pProviderIndexInfo->m_listIndicies.GetCount() > 0)
uTotalCount += (UINT)(pProviderIndexInfo->m_listIndicies.GetHead())->GetArray().GetSize();
}
return uTotalCount;
}
/*!--------------------------------------------------------------------------
CIndexMgr::GetCurrentCount
The current count may differ depending upon if the current Index
is a filtered index.
Author: EricDav
---------------------------------------------------------------------------*/
UINT
CIndexMgr::GetCurrentCount()
{
CSingleLock cl(&m_cs);
cl.Lock();
CProviderIndexInfo * pProviderIndexInfo = NULL;
CHDeviceIndex * pIndex = NULL;
pProviderIndexInfo = m_listProviderIndex.GetAt(m_posCurrentProvider);
pIndex = pProviderIndexInfo->m_listIndicies.GetAt(pProviderIndexInfo->m_posCurrentIndex);
if (pIndex == NULL)
return 0;
return (UINT)pIndex->GetArray().GetSize();
}
/*!--------------------------------------------------------------------------
CIndexMgr::AddHDevice
-
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CIndexMgr::AddHDevice(DWORD dwProviderID, HDEVICE hdevice, BOOL bEnd)
{
CSingleLock cl(&m_cs);
cl.Lock();
HRESULT hr = hrOK;
CProviderIndexInfo * pProviderIndexInfo = NULL;
CHDeviceIndex * pIndex = NULL;
COM_PROTECT_TRY
{
// set current provider set the current provider position and if
// the provider doesn't exist, it will create one
hr = SetCurrentProvider(dwProviderID);
if (FAILED(hr))
return hr;
pProviderIndexInfo = m_listProviderIndex.GetAt(m_posCurrentProvider);
pIndex = pProviderIndexInfo->m_listIndicies.GetAt(pProviderIndexInfo->m_posCurrentIndex);
if (pIndex)
pIndex->Add(hdevice, bEnd);
}
COM_PROTECT_CATCH
return hr;
}
/*!--------------------------------------------------------------------------
CIndexMgr::RemoveHDevice
-
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CIndexMgr::RemoveHDevice(DWORD dwProviderID, HDEVICE hdevice)
{
CSingleLock cl(&m_cs);
cl.Lock();
HRESULT hr = hrOK;
CProviderIndexInfo * pProviderIndexInfo = NULL;
CHDeviceIndex * pIndex = NULL;
COM_PROTECT_TRY
{
hr = SetCurrentProvider(dwProviderID);
if (FAILED(hr))
return hr;
pProviderIndexInfo = m_listProviderIndex.GetAt(m_posCurrentProvider);
pIndex = pProviderIndexInfo->m_listIndicies.GetAt(pProviderIndexInfo->m_posCurrentIndex);
if (pIndex)
pIndex->Remove(hdevice);
}
COM_PROTECT_CATCH
return hr;
}
/*!--------------------------------------------------------------------------
CIndexMgr::Sort
-
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CIndexMgr::Sort(DWORD dwProviderID, INDEX_TYPE SortType, DWORD dwSortOptions, LPBYTE pStart)
{
CSingleLock cl(&m_cs);
cl.Lock();
HRESULT hr = hrOK;
CHDeviceIndex * pNameIndex;
CHDeviceIndex * pNewIndex;
POSITION pos, posLast;
INDEX_TYPE indexType;
BOOL bAscending = (dwSortOptions & SORT_ASCENDING) ? TRUE : FALSE;
hr = SetCurrentProvider(dwProviderID);
if (FAILED(hr))
return hr;
// check to see if we have an index for this.
CProviderIndexInfo * pProviderIndexInfo = m_listProviderIndex.GetAt(m_posCurrentProvider);
pos = pProviderIndexInfo->m_listIndicies.GetHeadPosition();
while (pos)
{
posLast = pos;
CHDeviceIndex * pIndex = pProviderIndexInfo->m_listIndicies.GetNext(pos);
pIndex->GetType(&indexType);
// the index for this type already exists, just sort accordingly
if (indexType == SortType)
{
if (pIndex->IsAscending() != bAscending)
{
pIndex->SetAscending(bAscending);
pIndex->Sort(pStart);
}
pProviderIndexInfo->m_posCurrentIndex = posLast;
return hrOK;
}
}
// to save memory, remove all old indicies, except the name index
//CleanupIndicies();
// if not, create one
switch (SortType)
{
case INDEX_TYPE_NAME:
pNewIndex = new CIndexName();
break;
case INDEX_TYPE_USERS:
pNewIndex = new CIndexUsers();
break;
case INDEX_TYPE_STATUS:
pNewIndex = new CIndexStatus();
break;
default:
Panic1("Invalid sort type passed to IndexMgr::Sort %d\n", SortType);
break;
}
Assert(pNewIndex);
// name index is always the first in the list
pNameIndex = pProviderIndexInfo->m_listIndicies.GetHead();
Assert(pNameIndex);
// copy the array from the named index
pNewIndex->SetArray(pNameIndex->GetArray());
pNewIndex->SetAscending(bAscending);
pNewIndex->Sort(pStart);
pProviderIndexInfo->m_posCurrentIndex = pProviderIndexInfo->m_listIndicies.AddTail(pNewIndex);
return hr;
}
/*!--------------------------------------------------------------------------
CIndexMgr::CleanupIndicies
Removes all indicies except the name index, and a filtered view
Author: EricDav
---------------------------------------------------------------------------*/
void
CIndexMgr::CleanupIndicies()
{
CSingleLock cl(&m_cs);
cl.Lock();
INDEX_TYPE indexType;
CProviderIndexInfo * pProviderIndexInfo = m_listProviderIndex.GetAt(m_posCurrentProvider);
POSITION pos = pProviderIndexInfo->m_listIndicies.GetHeadPosition();
while (pos)
{
POSITION posLast = pos;
CHDeviceIndex * pIndex = pProviderIndexInfo->m_listIndicies.GetNext(pos);
pIndex->GetType(&indexType);
if (indexType == INDEX_TYPE_NAME)
continue;
pProviderIndexInfo->m_listIndicies.RemoveAt(posLast);
delete pIndex;
}
}
/*!--------------------------------------------------------------------------
CIndexMgr::GetHDevice
Returns an hdevice based on an index into the current sorted list
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CIndexMgr::GetHDevice(DWORD dwProviderID, int nIndex, LPHDEVICE phdevice)
{
CSingleLock cl(&m_cs);
cl.Lock();
SetCurrentProvider(dwProviderID);
CProviderIndexInfo * pProviderIndexInfo = m_listProviderIndex.GetAt(m_posCurrentProvider);
CHDeviceIndex * pIndex = pProviderIndexInfo->m_listIndicies.GetAt(pProviderIndexInfo->m_posCurrentIndex);
Assert(pIndex);
if (phdevice)
*phdevice = pIndex->GetHDevice(nIndex);
return hrOK;
}
/*!--------------------------------------------------------------------------
CIndexMgr::GetIndex
Returns the index of an hlien from the current sorted list
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CIndexMgr::GetIndex(DWORD dwProviderID, HDEVICE hdevice, int * pnIndex)
{
CSingleLock cl(&m_cs);
cl.Lock();
SetCurrentProvider(dwProviderID);
CProviderIndexInfo * pProviderIndexInfo = m_listProviderIndex.GetAt(m_posCurrentProvider);
CHDeviceIndex * pIndex = pProviderIndexInfo->m_listIndicies.GetAt(pProviderIndexInfo->m_posCurrentIndex);
Assert(pIndex);
if (pIndex)
*pnIndex = pIndex->GetIndex(hdevice);
return hrOK;
}
/*!--------------------------------------------------------------------------
CIndexMgr::SetCurrentProvider
Sets the current provider for the index mgr, if it doesn't exist,
it is created
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CIndexMgr::SetCurrentProvider(DWORD dwProviderID)
{
HRESULT hr = hrOK;
BOOL bExists = FALSE;
POSITION posLast;
COM_PROTECT_TRY
{
POSITION pos = m_listProviderIndex.GetHeadPosition();
while (pos)
{
posLast = pos;
CProviderIndexInfo * pProviderIndexInfo = m_listProviderIndex.GetNext(pos);
// is the the correct provider to add this to?
if (pProviderIndexInfo->m_dwProviderID != dwProviderID)
continue;
m_posCurrentProvider = posLast;
bExists = TRUE;
}
if (!bExists)
{
// no provider index exists for this. Create one now.
CProviderIndexInfo * pProviderIndexInfo = new CProviderIndexInfo;
pProviderIndexInfo->m_dwProviderID = dwProviderID;
CHDeviceIndex * pIndex = new CIndexName;
pProviderIndexInfo->m_posCurrentIndex = pProviderIndexInfo->m_listIndicies.AddHead(pIndex);
m_posCurrentProvider = m_listProviderIndex.AddTail(pProviderIndexInfo);
}
}
COM_PROTECT_CATCH
return hr;
}
/*!--------------------------------------------------------------------------
Class CIndexName
---------------------------------------------------------------------------*/
/*!--------------------------------------------------------------------------
CIndexName::BCompare
-
Author: EricDav
---------------------------------------------------------------------------*/
int
CIndexName::BCompare(const void * elem1, const void * elem2)
{
int nRet;
LPHDEVICE phdevice1 = (LPHDEVICE) elem1;
LPHDEVICE phdevice2 = (LPHDEVICE) elem2;
LPDEVICEINFO pRec1 = (LPDEVICEINFO) *phdevice1;
LPDEVICEINFO pRec2 = (LPDEVICEINFO) *phdevice2;
nRet = lstrcmp((LPCTSTR) (g_pStart + pRec1->dwDeviceNameOffset), (LPCTSTR) (g_pStart + pRec2->dwDeviceNameOffset));
if (nRet == 0)
{
// permanent device IDs should be unique
if (pRec1->dwPermanentDeviceID > pRec2->dwPermanentDeviceID)
nRet = 1;
else
nRet = -1;
}
return nRet;
}
/*!--------------------------------------------------------------------------
CIndexName::Sort
-
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CIndexName::Sort(LPBYTE pStart)
{
// save the base pointer for later
g_pStart = pStart;
if (m_bAscending)
qsort(m_hdeviceArray.GetData(), (size_t)m_hdeviceArray.GetSize(), sizeof(HDEVICE), QCompareA);
else
qsort(m_hdeviceArray.GetData(), (size_t)m_hdeviceArray.GetSize(), sizeof(HDEVICE), QCompareD);
return hrOK;
}
/*!--------------------------------------------------------------------------
CIndexName::QCompare
-
Author: EricDav
---------------------------------------------------------------------------*/
int __cdecl
CIndexName::QCompareA(const void * elem1, const void * elem2)
{
int nRet;
LPHDEVICE phdevice1 = (LPHDEVICE) elem1;
LPHDEVICE phdevice2 = (LPHDEVICE) elem2;
LPDEVICEINFO pRec1 = (LPDEVICEINFO) *phdevice1;
LPDEVICEINFO pRec2 = (LPDEVICEINFO) *phdevice2;
nRet = lstrcmp((LPCTSTR) (g_pStart + pRec1->dwDeviceNameOffset), (LPCTSTR) (g_pStart + pRec2->dwDeviceNameOffset));
if (nRet == 0)
{
// permanent device IDs should be unique
if (pRec1->dwPermanentDeviceID > pRec2->dwPermanentDeviceID)
nRet = 1;
else
nRet = -1;
}
return nRet;
}
int __cdecl
CIndexName::QCompareD(const void * elem1, const void * elem2)
{
return -QCompareA(elem1, elem2);
}
/*!--------------------------------------------------------------------------
Class CIndexUsers
---------------------------------------------------------------------------*/
/*!--------------------------------------------------------------------------
CIndexUsers::BCompare
-
Author: EricDav
---------------------------------------------------------------------------*/
int
CIndexUsers::BCompare(const void * elem1, const void * elem2)
{
int nRet;
LPHDEVICE phdevice1 = (LPHDEVICE) elem1;
LPHDEVICE phdevice2 = (LPHDEVICE) elem2;
LPDEVICEINFO pRec1 = (LPDEVICEINFO) *phdevice1;
LPDEVICEINFO pRec2 = (LPDEVICEINFO) *phdevice2;
nRet = lstrcmp((LPCTSTR) (g_pStart + pRec1->dwDomainUserNamesOffset), (LPCTSTR) (g_pStart + pRec2->dwDomainUserNamesOffset));
if (nRet == 0)
nRet = lstrcmp((LPCTSTR) (g_pStart + pRec1->dwDeviceNameOffset), (LPCTSTR) (g_pStart + pRec2->dwDeviceNameOffset));
return nRet;
}
/*!--------------------------------------------------------------------------
CIndexUsers::Sort
-
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CIndexUsers::Sort(LPBYTE pStart)
{
// save the base pointer for later
g_pStart = pStart;
if (m_bAscending)
qsort(m_hdeviceArray.GetData(), (size_t)m_hdeviceArray.GetSize(), sizeof(HDEVICE), QCompareA);
else
qsort(m_hdeviceArray.GetData(), (size_t)m_hdeviceArray.GetSize(), sizeof(HDEVICE), QCompareD);
return hrOK;
}
/*!--------------------------------------------------------------------------
CIndexUsers::QCompare
-
Author: EricDav
---------------------------------------------------------------------------*/
int __cdecl
CIndexUsers::QCompareA(const void * elem1, const void * elem2)
{
int nRet;
LPHDEVICE phdevice1 = (LPHDEVICE) elem1;
LPHDEVICE phdevice2 = (LPHDEVICE) elem2;
LPDEVICEINFO pRec1 = (LPDEVICEINFO) *phdevice1;
LPDEVICEINFO pRec2 = (LPDEVICEINFO) *phdevice2;
nRet = lstrcmp((LPCTSTR) (g_pStart + pRec1->dwDomainUserNamesOffset), (LPCTSTR) (g_pStart + pRec2->dwDomainUserNamesOffset));
if (nRet == 0)
nRet = lstrcmp((LPCTSTR) (g_pStart + pRec1->dwDeviceNameOffset), (LPCTSTR) (g_pStart + pRec2->dwDeviceNameOffset));
return nRet;
}
int __cdecl
CIndexUsers::QCompareD(const void * elem1, const void * elem2)
{
return -QCompareA(elem1, elem2);
}
/*!--------------------------------------------------------------------------
Class CIndexStatus
---------------------------------------------------------------------------*/
/*!--------------------------------------------------------------------------
CIndexStatus::BCompare
-
Author: EricDav
---------------------------------------------------------------------------*/
int
CIndexStatus::BCompare(const void * elem1, const void * elem2)
{
LPHDEVICE phdevice1 = (LPHDEVICE) elem1;
LPHDEVICE phdevice2 = (LPHDEVICE) elem2;
LPDEVICEINFO pRec1 = (LPDEVICEINFO) *phdevice1;
LPDEVICEINFO pRec2 = (LPDEVICEINFO) *phdevice2;
//return _mbscmp((const PUCHAR) &pRec1->szRecordName[0], (const PUCHAR) &pRec2->szRecordName[0]);
return 0;
}
/*!--------------------------------------------------------------------------
CIndexStatus::Sort
-
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CIndexStatus::Sort(LPBYTE pStart)
{
// save the base pointer for later
g_pStart = pStart;
if (m_bAscending)
qsort(m_hdeviceArray.GetData(), (size_t)m_hdeviceArray.GetSize(), sizeof(HDEVICE), QCompareA);
else
qsort(m_hdeviceArray.GetData(), (size_t)m_hdeviceArray.GetSize(), sizeof(HDEVICE), QCompareD);
return hrOK;
}
/*!--------------------------------------------------------------------------
CIndexIpAddr::QCompare
-
Author: EricDav
---------------------------------------------------------------------------*/
int __cdecl
CIndexStatus::QCompareA(const void * elem1, const void * elem2)
{
LPHDEVICE phdevice1 = (LPHDEVICE) elem1;
LPHDEVICE phdevice2 = (LPHDEVICE) elem2;
LPHDEVICE pRec1 = (LPHDEVICE) *phdevice1;
LPHDEVICE pRec2 = (LPHDEVICE) *phdevice2;
//return lstrcmp((LPCTSTR) (g_pStart + pRec1->dwDeviceNameOffset), (LPCTSTR) (g_pStart + pRec2->dwDeviceNameOffset));
return 0;
}
int __cdecl
CIndexStatus::QCompareD(const void * elem1, const void * elem2)
{
return -QCompareA(elem1, elem2);
}
Copy Permalink