自学教程：C++ ATLVERIFY函数代码示例

void SetClipboardText(const std::wstring& text){	if (!::OpenClipboard(::GetDesktopWindow()))		return;	ATLVERIFY(::EmptyClipboard());	const size_t length = (text.size() + 1) * sizeof(text[0]);	HANDLE hmem = ::GlobalAlloc(GMEM_MOVEABLE, length);	UIETWASSERT(hmem); // We are not hardened against OOM.	void* const ptr = ::GlobalLock(hmem);	UIETWASSERT(ptr != NULL);	wcscpy_s(static_cast<wchar_t*>(ptr), (text.size() + 1), text.c_str());	UnlockGlobalMemory(hmem);	if (::SetClipboardData(CF_UNICODETEXT, hmem) == NULL)	{		ATLVERIFY(!::GlobalFree(hmem));		ATLVERIFY(::CloseClipboard());		return;	}	ATLVERIFY(::CloseClipboard());}

STDMETHODIMP CNdasUnitImpl::GetRaidSimpleStatus (	NDAS_LOGICALUNIT_DEFINITION *NdasLogicalUnitDefinition,	UINT8						*NdasUnitNo,	DWORD						*RaidSimpleStatusFlags	){	HRESULT hr;	HNDAS   ndasHandle;	ATLVERIFY( RaidSimpleStatusFlags != NULL );	hr = ConnectUnitDevice(&ndasHandle);	if (FAILED(hr)) {		return hr;	}	hr = NdasVsmGetRaidSimpleStatus( ndasHandle, NdasLogicalUnitDefinition, NdasUnitNo, RaidSimpleStatusFlags );	if (FAILED(hr)) {		ATLVERIFY(S_OK == DisonnectUnitDevice(ndasHandle));		return hr;	}	ATLVERIFY(S_OK == DisonnectUnitDevice(ndasHandle));	return S_OK;}

DWORD CNdasDevicePropGeneralPage::pUpdateThreadStart(DWORD UnitIndex){	ATLASSERT(UnitIndex < RTL_NUMBER_OF(m_pUnitDevices));	if (UnitIndex >= RTL_NUMBER_OF(m_pUnitDevices))	{		ATLVERIFY(PostMessage(			WM_THREADED_WORK_COMPLETED, 0, static_cast<LPARAM>(UnitIndex)));		return 255;	}	ndas::UnitDevicePtr pUnitDevice = m_pUnitDevices[UnitIndex];	if (!pUnitDevice)	{		ATLVERIFY(PostMessage(			WM_THREADED_WORK_COMPLETED, 0, static_cast<LPARAM>(UnitIndex)));		return 1;	}	(void) pUnitDevice->UpdateHostStats();	ATLVERIFY(PostMessage(		WM_THREADED_WORK_COMPLETED, 0, static_cast<LPARAM>(UnitIndex)));	return 0;}

HRESULT CCurrencyConversionSamplePlugin::StartDisplayingItems() {  CComQIPtr<IGoogleDesktopDisplayPluginHelper> helper(m_pluginHelper);  if (m_pluginHelper == NULL)    return E_FAIL;  // set flags  GoogleDesktopDisplayPluginFlags plugin_flags = GDD_PLUGIN_FLAG_NONE;  GoogleDesktopDisplayContentFlags content_flags = GDD_CONTENT_FLAG_NONE;  ATLVERIFY(SUCCEEDED(helper->SetFlags(plugin_flags, content_flags)));  // set about text  CComBSTR about_text;  about_text.LoadString(IDS_COPYRIGHT);  ATLVERIFY(SUCCEEDED(helper->put_about_text(about_text)));  // set icons  CComPtr<IPicture> title_icon, about_icon;  ATLVERIFY(SUCCEEDED(::LoadPictureFromResource(ghInstance,    MAKEINTRESOURCE(IDR_GIF_CURRENCY_ICON_SMALL), L"GIF",    &title_icon)));  ATLVERIFY(SUCCEEDED(::LoadPictureFromResource(ghInstance,    MAKEINTRESOURCE(IDR_GIF_CURRENCY_ICON_LARGE), L"GIF",    &about_icon)));  ATLVERIFY(SUCCEEDED(helper->SetIcons(title_icon, about_icon)));  UpdateTitle(false);  // display the first set of items  SetContentLayout();  ChangeItems(NULL);  return S_OK;}

CNBNdasDevice::CNBNdasDevice(PNDASUSER_DEVICE_ENUM_ENTRY pBaseInfo, NDAS_DEVICE_STATUS status){	ATLASSERT(pBaseInfo);	CopyMemory(&m_BaseInfo, pBaseInfo, sizeof(NDASUSER_DEVICE_ENUM_ENTRY));	m_status = status;	ATLVERIFY(SUCCEEDED( StringCchCopy(		m_NdasId.Id, RTL_NUMBER_OF(m_NdasId.Id), pBaseInfo->szDeviceStringId) ));	if (pBaseInfo->GrantedAccess & GENERIC_WRITE)	{		// We uses the magic write key in case write access is granted.		ATLVERIFY(SUCCEEDED( StringCchCopy(			m_NdasId.Key, RTL_NUMBER_OF(m_NdasId.Key), _T("*****")) ));	}	ZeroMemory(&m_DeviceId, sizeof(NDAS_DEVICE_ID));	NdasIdStringToDeviceEx(pBaseInfo->szDeviceStringId, &m_DeviceId, NULL, &m_IdExtData);	m_DeviceId.VID = m_IdExtData.VID;		#if 0	NDASUSER_DEVICE_INFORMATION ndasDeviceInfo;	ATLVERIFY( NdasQueryDeviceInformation(pBaseInfo->SlotNo, &ndasDeviceInfo) );	m_DeviceId = ndasDeviceInfo.HardwareInfo.NdasDeviceId;#endif	if (m_DeviceId.VID == 0) {		ATLTRACE(_T("Assume VID is 1 if VID=0/n"));		m_DeviceId.VID = 1;	}	ATLTRACE(_T("new CNBNdasDevice(%p) : Name %s, ID %s, Slot %d, Access %08x/n"),		this, pBaseInfo->szDeviceName, pBaseInfo->szDeviceStringId, pBaseInfo->SlotNo, pBaseInfo->GrantedAccess);}

HRESULT CExeModule::LoadExchangeCodes(){	ATLVERIFY(SUCCEEDED(_LoadExchangeCodes(STOCKEXCHANGECODES_SETTINGS, m_StockExchangeCodes)));	ATLVERIFY(SUCCEEDED(_LoadExchangeCodes(OPTIONEXCHANGECODES_SETTINGS, m_OptionExchangeCodes)));	return S_OK;}

DWORDCDismountDialog::WorkItemStart(){	m_EjectError = 0;	BOOL success = m_pLogDevice->Eject(&m_EjectParam);	if (!success)	{		m_EjectError = GetLastError();		ATLTRACE("Eject failed, error=0x%X/n", m_EjectError);	}	else	{		if (m_EjectParam.ConfigRet != CR_SUCCESS)		{			ATLTRACE("Eject failed from configuration manager, configRet=%d/n",				m_EjectParam.ConfigRet);			ATLTRACE("VetoType=%d,VetoName=%ls/n",				m_EjectParam.VetoType,				m_EjectParam.VetoName);		}	}	ATLVERIFY( PostMessage(WM_WORKITEM_COMPLETED) );	ATLVERIFY( SetEvent(m_WorkItemFinished) );	return 0;}

BOOL CPnpEventConsumerWindow::OnDeviceChange(	UINT EventType, PDEV_BROADCAST_HANDLE Dbch){	switch (EventType)	{	case DBT_DEVICEREMOVECOMPLETE:		{			ATLVERIFY( m_DevNotifyHandles.Remove(Dbch->dbch_hdevnotify) );			printf("Unregistering DevNotifyHandle=%p/n", Dbch->dbch_hdevnotify);			ATLVERIFY( UnregisterDeviceNotification(Dbch->dbch_hdevnotify) );		}		break;	case DBT_CUSTOMEVENT:		if (IsEqualGUID(Dbch->dbch_eventguid, GUID_NDASPORT_PNP_NOTIFICATION))		{			PNDASPORT_PNP_NOTIFICATION ndasportNotification = 				reinterpret_cast<PNDASPORT_PNP_NOTIFICATION>(Dbch->dbch_data);			OnNdasPortEvent(ndasportNotification);		}		else if (IsEqualGUID(Dbch->dbch_eventguid, GUID_NDAS_ATA_LINK_EVENT))		{			PNDAS_ATA_LINK_EVENT ndasAtaLinkEvent =				reinterpret_cast<PNDAS_ATA_LINK_EVENT>(Dbch->dbch_data);			OnNdasAtaLinkEvent(ndasAtaLinkEvent);		}		else if (IsEqualGUID(Dbch->dbch_eventguid, NDAS_DLU_EVENT_GUID))		{			PNDAS_DLU_EVENT ndasDluEvent =				reinterpret_cast<PNDAS_DLU_EVENT>(Dbch->dbch_data);			OnNdasDluEvent(ndasDluEvent);		}		else if (IsEqualGUID(Dbch->dbch_eventguid, GUID_IO_VOLUME_MOUNT))		{			// printf("Volume is mounted, handle=%p/n", Dbch->dbch_handle);		}		else		{			OLECHAR guidString[64] = {0};			StringFromGUID2(				Dbch->dbch_eventguid,				guidString,				64);			if (-1 != Dbch->dbch_nameoffset)			{				printf("Unknown %s (%ls)",					((PUCHAR)Dbch) + Dbch->dbch_nameoffset,					guidString);			}			else			{				printf("Unknown %ls", guidString);			}		}	}	return TRUE;}

void SetRegistryDWORD(const HKEY root, const std::wstring& subkey, const std::wstring& valueName, const DWORD value){	HKEY key;	if (::RegOpenKeyExW(root, subkey.c_str(), 0, KEY_ALL_ACCESS, &key) != ERROR_SUCCESS)		return;	ATLVERIFY(ERROR_SUCCESS == ::RegSetValueExW(key, valueName.c_str(), 0, REG_DWORD, reinterpret_cast<const BYTE*>(&value), sizeof(value)));	ATLVERIFY(::RegCloseKey(key) == ERROR_SUCCESS);}

void CMainFrame::OnNdasServiceConnectFailed(){	ATLTRACE("Connection to the NDAS Service failed./n");	ATLVERIFY(m_taskbarIcon.ChangeIcon(_CreateTaskbarIcon(false)));	ATLVERIFY( m_taskbarIcon.SetToolTipText(IDR_TASKBAR_FAIL) );}

LRESULT CMiniPieFrame::OnCreate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/){	CAppInfo info;	// Full screen mode delayed restoration 	bool bFull = false;	info.Restore(bFull, L"Full");	if (bFull)		PostMessage(WM_COMMAND, ID_VIEW_FULLSCREEN);	CreateSimpleCEMenuBar();#ifdef WIN32_PLATFORM_WFSP // SmartPhone	AtlActivateBackKey(m_hWndCECommandBar);#endif 	UIAddToolBar(m_hWndCECommandBar);	SetCommandButton(ID_APP_EXIT);	// StatusBar state restoration 	bool bVisible = true;	info.Restore(bVisible, L"Status");	DWORD dwStyle = WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | CCS_TOP;	if (bVisible)		dwStyle |= WS_VISIBLE;	// StatusBar creation 	CreateSimpleStatusBar(ATL_IDS_IDLEMESSAGE, dwStyle);	UIAddStatusBar(m_hWndStatusBar);	UISetCheck(ID_VIEW_STATUS_BAR, bVisible);	// Browser view creation	m_hWndClient = m_browser.Create(m_hWnd, NULL, _T("Microsoft.PIEDocView"),                     WS_CHILD | WS_VISIBLE | WS_BORDER, 0, ID_BROWSER);    ATLVERIFY(SUCCEEDED(m_browser.QueryControl(&m_spIWebBrowser2)));    ATLVERIFY(SUCCEEDED(AtlAdviseSinkMap(this, true)));	// Navigation menu initialization	UIEnable(IDM_BACK, FALSE);	UIEnable(IDM_FORWARD, FALSE);	UIEnable(IDM_STOP, FALSE);	UIEnable(IDM_REFRESH, FALSE);#ifdef WIN32_PLATFORM_PSPC 	// PPC Address bar state restoration    VARIANT_BOOL vb = ATL_VARIANT_TRUE;	info.Restore(vb, L"Address");	m_spIWebBrowser2->put_AddressBar(vb);	UISetCheck(ID_VIEW_ADDRESSBAR, vb == ATL_VARIANT_TRUE);#endif 	// register object for message filtering and idle updates	CMessageLoop* pLoop = _Module.GetMessageLoop();	ATLASSERT(pLoop != NULL);	pLoop->AddMessageFilter(this);	pLoop->AddIdleHandler(this);	return 0;}

HRESULT RegisterWithGDEventFramework() {  CComPtr<IGoogleDesktopRegistrar> registrar;  HRESULT hr = registrar.CoCreateInstance(L"GoogleDesktop.Registrar");  if (SUCCEEDED(hr)) {    CComBSTR our_guid(CONSOLE_PLUGIN_GUID);    WCHAR icon_path[_MAX_PATH + 1] = {0};    ATLVERIFY(::GetModuleFileNameW(NULL, icon_path, _MAX_PATH - 2) != 0);    SafeStrCat(icon_path, L"@0", _MAX_PATH+1);    CComSafeArray<VARIANT> description;    ATLVERIFY(SUCCEEDED(description.Create(8)));    VARIANT* props = reinterpret_cast<VARIANT*>(description.m_psa->pvData);    for (DWORD i = 0; i < description.GetCount(); ++i) {      props[i].vt = VT_BSTR;    }    props[0].bstrVal = ::SysAllocString(L"Title");    props[1].bstrVal = ::SysAllocString(L"Console Events");    props[2].bstrVal = ::SysAllocString(L"Description");    props[3].bstrVal = ::SysAllocString(L"Outputs events from Google Desktop to the console");    props[4].bstrVal = ::SysAllocString(L"Icon");    props[5].bstrVal = ::SysAllocString(icon_path);    props[6].bstrVal = ::SysAllocString(L"Homepage");    props[7].bstrVal = ::SysAllocString(L"http://desktop.google.com");    VARIANT desc;    desc.vt = VT_ARRAY | VT_VARIANT;    desc.parray = description;    hr = registrar->StartComponentRegistration(our_guid, desc);    if (SUCCEEDED(hr)) {      CComPtr<IUnknown> unknown;      hr = registrar->GetRegistrationInterface(CComBSTR(L"GoogleDesktop.EventRegistration"),                                               &unknown);      ATLASSERT(SUCCEEDED(hr));      CComQIPtr<IGoogleDesktopRegisterEventPlugin> event_registration(unknown);      if (event_registration != NULL) {        long cookie = 0;        hr = event_registration->RegisterPlugin(our_guid, &cookie);        if (SUCCEEDED(hr)) {          hr = registrar->FinishComponentRegistration();          if (SUCCEEDED(hr)) {            hr = StoreRegistrationCookie(cookie);          }        }      }    }  }  return hr;}

voidCNdasDevicePropGeneralPage::OnReset(){	ATLTRACE(__FUNCTION__ "/n");	ATLVERIFY(AtlWaitWithMessageLoop(m_ThreadCompleted));	ATLVERIFY(m_imageList.Destroy());	ATLVERIFY(DestroyAcceleratorTable(m_hAccel));}

STDMETHODIMP SysMonPluginPropPage::Apply(void) {  int refresh_interval = GetDlgItemInt(IDC_EDIT_REFRESH_INTERVAL, NULL, 0);  int max_disk_rw = GetDlgItemInt(IDC_EDIT_MAX_DISK_RW, NULL, 0);  int max_net_io = GetDlgItemInt(IDC_EDIT_MAX_NET_IO, NULL, 0);  int active_monitors = 0;  int auto_adjust_chart_max = 1;  if (!refresh_interval) {    refresh_interval = 1;   // Minimum 1 seconds  }  if (!max_disk_rw) {    max_disk_rw = 50000;  }  if (!max_net_io) {    max_net_io = 50000;  }  if (::SendMessage(GetDlgItem(IDC_CHECK_CPU),                               BM_GETCHECK, 0, 0) == BST_CHECKED) {    active_monitors |= ACTIVE_MON_CPU;  }  if (::SendMessage(GetDlgItem(IDC_CHECK_MEM),                               BM_GETCHECK, 0, 0) == BST_CHECKED) {    active_monitors |= ACTIVE_MON_MEM;  }  if (::SendMessage(GetDlgItem(IDC_CHECK_DISK),                               BM_GETCHECK, 0, 0) == BST_CHECKED) {    active_monitors |= ACTIVE_MON_DISK;  }  if (::SendMessage(GetDlgItem(IDC_CHECK_NET),                               BM_GETCHECK, 0, 0) == BST_CHECKED) {    active_monitors |= ACTIVE_MON_NET;  }  auto_adjust_chart_max = (::SendMessage(GetDlgItem(IDC_CHECK_AUTO_MAX),    BM_GETCHECK, 0, 0) == BST_CHECKED);  for (int i = 0; i < static_cast<int>(m_nObjects); ++i) {    CComQIPtr<IGoogleDesktopSysMonPlugin> plugin(m_ppUnk[i]);    if (plugin) {      ATLVERIFY(SUCCEEDED(plugin->put_refresh_interval(refresh_interval)));      ATLVERIFY(SUCCEEDED(plugin->put_active_monitors(active_monitors)));      ATLVERIFY(SUCCEEDED(plugin->put_max_disk_rw_in_chart(max_disk_rw)));      ATLVERIFY(SUCCEEDED(plugin->put_max_net_io_in_chart(max_net_io)));      ATLVERIFY(SUCCEEDED(plugin->put_auto_adjust_chart_max(        auto_adjust_chart_max)));    }  }  m_bDirty = FALSE;  return S_OK;}

void CMainFrame::pChangeTaskBarIcon(bool Normal){	if (Normal) {		ATLVERIFY( m_taskbarIcon.ChangeIcon(pCreateTaskbarIcon(true)) );		ATLVERIFY( m_taskbarIcon.SetToolTipText(IDR_TASKBAR) );		} else {		ATLVERIFY( m_taskbarIcon.ChangeIcon(pCreateTaskbarIcon(false)) );		ATLVERIFY( m_taskbarIcon.SetToolTipText(IDR_TASKBAR_FAIL) );	}}

voidCMainFrame::pImportRegistration(LPCTSTR szFileName){	DWORD count = 0;	NDAS_NIF_V1_ENTRY* pEntry;	HRESULT hr = ::NdasNifImport(szFileName, &count, &pEntry);	if (SUCCEEDED(hr))	{		NifEntryArray entryArray;		for (DWORD i = 0; i < count; ++i)		{			ATLTRACE(_T("%d/%d: %s/n"), i+1, count, pEntry->Name);			entryArray.Add(NifEntry(pEntry[i]));		}		if (NULL == m_wndImportDlg.m_hWnd)		{			ATLVERIFY(m_wndImportDlg.Create(m_hWnd, PtrToUlong(&entryArray)));			m_wndImportDlg.CenterWindow(::GetDesktopWindow());			m_wndImportDlg.ShowWindow(SW_SHOWNORMAL);		}		else		{			m_wndImportDlg.AddNifEntry(entryArray);			m_wndImportDlg.SetActiveWindow();		}		ATLVERIFY(NULL == ::LocalFree(pEntry));	}	else	{		ATLTRACE("NdasNifImport Error hr=%x/n", hr);		CString strError;		TCHAR szCompactPath[50];		LPCTSTR lpFileName;		if (::PathCompactPathEx(szCompactPath, szFileName, 50, 0))		{			lpFileName = szCompactPath;		}		else		{			lpFileName = szFileName;		}		strError.FormatMessage(IDS_ERROR_IMPORT_FMT, lpFileName);		ErrorMessageBox(static_cast<LPCTSTR>(strError), IDS_MAIN_TITLE, hr);	}}

// Worker Thread Start RoutineDWORD CDeviceGeneralPage::OnWorkerThreadStart(LPVOID lpParameter){	UINT i = PtrToUlong(lpParameter);	ATLASSERT(i < RTL_NUMBER_OF(m_pUnitDevices));	if (i >= RTL_NUMBER_OF(m_pUnitDevices))	{		return 255;	}	ndas::UnitDevicePtr pUnitDevice = m_pUnitDevices[i];	if (NULL == pUnitDevice.get())	{		return 1;	}	(void) pUnitDevice->UpdateHostStats();	if (::IsWindow(m_hWnd))	{		ATLVERIFY(PostMessage(WM_USER_DONE, 0, static_cast<LPARAM>(i)));	}	return 0;}

inline BYTE IStream::ReadByte(){   BYTE b;   DWORD dwBytesRead = 0;   ATLVERIFY(true == Read(&b, 1, dwBytesRead) && 1 == dwBytesRead);   return b;}

double HighResolutionTimer::TotalElapsed() const throw(){   LARGE_INTEGER lCountNow = {0};   ATLVERIFY(TRUE == ::QueryPerformanceCounter(&lCountNow));   return static_cast<double>(m_lTotalElapsed.QuadPart + (m_bStarted ? (lCountNow.QuadPart-m_lCountStart.QuadPart) : 0LL)) /      GetPerformanceFrequency();}

bool CFotoEntity::findAt(int nX, int nY){	int nR, nL = nX;	ATLVERIFY( addLine(nY, nL, nR) );	CRanges r;	r.push_back( tagUShorts(nL, nR) );	m_mapRanges[nY] = r;		findAtNextLine<-1>(nY-1, nL, nR);	findAtNextLine<1>(nY+1, nL, nR);	int nAdded;	do{		nAdded = 0;		for(std::map<int, CRanges>::iterator it = m_mapRanges.begin(); it != m_mapRanges.end(); it++){			CRanges& r = it->second;			if (r.IsFlag(1|2) == (1|2)) continue;			int nUp = 0, nDown = 0;			for(size_t i=0; i < r.size(); i++){				if (!r.IsFlag(1))					nUp += findAtNextLine<-1>(it->first - 1, r[i].m_us1, r[i].m_us2);				if (!r.IsFlag(2))					nDown += findAtNextLine<1>(it->first + 1, r[i].m_us1, r[i].m_us2);			}			int nFlag = nUp ? 0 : 1;			if (!nDown) nFlag |= 2;			if (nFlag) r.AddFlag( nFlag );			nAdded += nUp + nDown;		}		}while(nAdded);	return true;}

int WINAPI _tWinMain( HINSTANCE hInst, HINSTANCE, LPTSTR, int ){	_tsetlocale( LC_ALL, _T(".OCP") );	ATLVERIFY( SUCCEEDED( _Module.Init( NULL, hInst ) ) );	if( !EnableDebugPrivilege() )	{		MessageBoxV( NULL, IDS_NO_DEBUG_PRIVILEGE, MB_OK | MB_ICONHAND );		return 0;	}	InitializeCriticalSection( &g_cs );	LoadInternalExceptionList();	LoadSettings();	DumpInit();	if( !ProcessCommandLine() )	{		AtlInitCommonControls( ICC_BAR_CLASSES );		LoadLibrary( CRichEditCtrl::GetLibraryName() );		CMainDlg dlgMain;		g_pMainWnd = &dlgMain;		int nRet = dlgMain.DoModal();		g_pMainWnd = NULL;	}	DumpUninit();	SaveSettings();	DeleteCriticalSection( &g_cs );	_Module.Term();	return 0;}

LRESULT MsgOnlyWindow::OnInitPlugin(UINT, WPARAM, LPARAM, BOOL& bHandled) {  bHandled = true;  m_plugin->InitFromSavedLastCurrencies();  HRESULT hr = m_plugin->StartDisplayingItems();  ATLVERIFY(SUCCEEDED(hr));  return 0;}

HRESULT CSwapAPODllModule::DllRegisterServer(BOOL bRegTypeLib) throw(){    HRESULT hResult;    UINT32 u32APORegIndex = 0;    UINT32 u32APOUnregIndex = 0;    // Register all APOs implemented in this module.    for (u32APORegIndex = 0; u32APORegIndex < SIZEOF_ARRAY(gCoreAPOs); u32APORegIndex++)    {        hResult = RegisterAPO(gCoreAPOs[u32APORegIndex]);        if (FAILED(hResult))        {           goto ExitFailed;        }    }    // Register the module.    hResult = CAtlDllModuleT<CSwapAPODllModule>::DllRegisterServer(bRegTypeLib);    if (FAILED(hResult))    {        goto ExitFailed;    }    return hResult;ExitFailed:    // Unregister all registered APOs if something failed.    for (u32APOUnregIndex = 0; u32APOUnregIndex < u32APORegIndex; u32APOUnregIndex++)    {        ATLVERIFY(SUCCEEDED(UnregisterAPO(gCoreAPOs[u32APOUnregIndex]->clsid)));    }    return hResult;} // DllRegisterServer

CDatabase *CCachedDBConnections::GetConnection(const CString &strConnect, BOOL bAutoOpen){    CCacheMap::CPair *pKeyValPair = m_DBCache.PLookup(strConnect);    CDatabase *pDB = NULL;    if (pKeyValPair != NULL)    {        pDB = pKeyValPair->value;    }        if (NULL == pDB)    {        try { pDB = new CDatabase; }        catch (...) { pDB = NULL; }    }    if (pDB != NULL && !pDB->IsOpen() && bAutoOpen)    {        ATLVERIFY(pDB->OpenEx(strConnect,             CDatabase::useCursorLib | CDatabase::noOdbcDialog));    }    if (NULL == pKeyValPair)    {        m_DBCache[strConnect] = pDB;    }    return pDB;}

static HMODULE WINAPI HookLoadLibraryW(PCWSTR lpLibFileName){    PCWSTR pwzName = wcsrchr(lpLibFileName, L'//');    if (NULL != pwzName)        ++pwzName;    else        pwzName = lpLibFileName;    static const PCWSTR pwzDlls[] = {        L"jsdbgui.dll", L"jsprofilerui.dll", L"networkinspection.dll"    };    for (size_t i = 0; i < ARRAYSIZE(pwzDlls); ++i) {        if (0 == _wcsicmp(pwzName, pwzDlls[i])) {            static WCHAR wzIEPath[MAX_PATH] = { 0 };            if (L'/0' == wzIEPath[0]) {                CStaticDataInitCriticalSectionLock lock;                ATLVERIFY(SUCCEEDED(lock.Lock()));                if (L'/0' == wzIEPath[0]) {                    HMODULE hDT = GetModuleHandle(_T("iedvtool.dll"));                    ATLASSERT(NULL != hDT);                    GetModuleFileName(hDT, wzIEPath, MAX_PATH);                    *(wcsrchr(wzIEPath, L'//') + 1) = L'/0';                }                lock.Unlock();            }            wstring wsDll(wzIEPath);            wsDll.append(pwzName);            return RawLoadLibraryW(wsDll.c_str());        }    }    return RawLoadLibraryW(lpLibFileName);}

std::vector<std::wstring> GetFileList(const std::wstring& pattern, const bool fullPaths){	const std::wstring directory = (fullPaths ? GetDirPart(pattern) : L"");	// may not pass an empty string to FindFirstFileEx	UIETWASSERT(pattern.length() > 0);	// string passed to FindFirstFileEx must not end in a backslash	UIETWASSERT(pattern.back() != L'//');	WIN32_FIND_DATA findData;	HANDLE hFindFile = ::FindFirstFileExW(pattern.c_str(), FindExInfoBasic,				&findData, FindExSearchNameMatch, NULL, 0);	std::vector<std::wstring> result;	if (hFindFile == INVALID_HANDLE_VALUE)	{		// If there are NO matching files, then FindFirstFileExW returns		// INVALID_HANDLE_VALUE and the last error is ERROR_FILE_NOT_FOUND.		UIETWASSERT(::GetLastError() == ERROR_FILE_NOT_FOUND);		return result;	}	do	{		result.emplace_back(directory + findData.cFileName);	} while (::FindNextFileW(hFindFile, &findData));	UIETWASSERT(::GetLastError() == ERROR_NO_MORE_FILES);	ATLVERIFY(::FindClose(hFindFile));	return result;}

void CreateRegistryKey(const HKEY root, const std::wstring& subkey, const std::wstring& newKey){	HKEY key;	if (::RegOpenKeyExW(root, subkey.c_str(), 0, KEY_ALL_ACCESS, &key) != ERROR_SUCCESS)		return;	HKEY resultKey;	// TODO: RegCreateKey is deprecated.	const LONG createResult = ::RegCreateKeyW(key, newKey.c_str(), &resultKey);	UIETWASSERT(createResult == ERROR_SUCCESS);	if (createResult == ERROR_SUCCESS)	{		ATLVERIFY(::RegCloseKey(resultKey) == ERROR_SUCCESS);	}	ATLVERIFY(::RegCloseKey(key) == ERROR_SUCCESS);}