errcoll.cpp

Windows CE 6.0 Server 源码

    CAutoBSTR               bstrSource;
    CAutoBSTR               bstrDescription;
    CAutoBSTR               bstrHelpFile;
    DWORD                  dwHelpContext; 

    CErrorListEntry     *pList = 0; 

    pList = getCurrentList();
    CHK_BOOL(pList, E_OUTOFMEMORY);

    
    if (pexepInfo)
    {
        // get the information out of the exepInfo structure
        CHK(pList->SetErrorInfo(pexepInfo->bstrDescription , 
                             pexepInfo->bstrSource , 
                             pexepInfo->bstrHelpFile, 
                             pexepInfo->dwHelpContext, 
                             pexepInfo->scode ? pexepInfo->scode : pexepInfo->wCode));
    }
    else
    {
        if (GetErrorInfo(0, &pIErrInfo)==S_OK)
        {
        
            CHK(pIErrInfo->GetSource(&bstrSource));
            CHK(pIErrInfo->GetDescription(&bstrDescription))
            CHK(pIErrInfo->GetHelpFile(&bstrHelpFile));
            CHK(pIErrInfo->GetHelpContext(&dwHelpContext));
            CHK(pList->SetErrorInfo(bstrDescription , 
                             bstrSource , 
                             bstrHelpFile, 
                             dwHelpContext, 
                             hrErrorCode));
            
        

        }
    }

Cleanup:
    return (hr);
    
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////



/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CErrorCollection::GetErrorEntry(CErrorListEntry **ppEntry)
//
//  parameters:
//
//  description:
//
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CErrorCollection::GetErrorEntry(CErrorListEntry **ppEntry)
{
    HRESULT             hr = S_OK;

    *ppEntry =  m_errorList.FindEntry(GetCurrentThreadId());    
    return (hr);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////



/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: void CErrorListEntry * CErrorCollection::getCurrentList(void)
//
//  parameters:
//
//  description:
//      helper to find the current list
//  returns: 
//      0 in case of outofmemory. But there is not a lot we can do, we are the errorhandler anyway.
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
CErrorListEntry * CErrorCollection::getCurrentList(void)
{
    CErrorListEntry                     *pList = 0; 
    DWORD                           dwCookie; 
    CTypedDynArray<CErrorDescription>   *pArr;

    // first find the right list

    dwCookie = GetCurrentThreadId(); 
    
    pList =  m_errorList.FindEntry(dwCookie);    
    if (!pList)
    {
        pArr = new CTypedDynArray<CErrorDescription>();
        if (pArr)
        {
            m_errorList.Add(pArr, dwCookie); 
            pList = m_errorList.FindEntry(dwCookie); 
        }    
    }

    return pList;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////




/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: void CErrorCollection::Shutdown(void)
//
//  parameters:
//
//  description:
//
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
void CErrorCollection::Shutdown(void)
{
    m_errorList.Shutdown();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////




/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: void CErrorCollection::Reset(void)
//
//  parameters:
//
//  description:
//      deletes the current list for the thread
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
void CErrorCollection::Reset(void)
{
    CTypedDynArray<CErrorDescription> *pArr;
    CErrorListEntry *pList;

    pArr = new CTypedDynArray<CErrorDescription>();
    m_errorList.Replace(pArr, GetCurrentThreadId());

    pList = getCurrentList();
    if (pList)
        pList->Reset();
    
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////




/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: void globalAddError(UINT idsResource, HRESULT hr)
//
//  parameters:
//
//  description:
//
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
void globalAddError(UINT idsResource, UINT idsComponent, HRESULT hr)
{
#ifndef UNDER_CE
    TCHAR   achBuffer[ONEK+1]; 
    TCHAR   achComponent[ONEK+1];    
#else
    TCHAR   *achBuffer = new TCHAR[ONEK+1]; 
    TCHAR   *achComponent = new TCHAR[ONEK+1];   
    
    CHK_MEM(achBuffer);
    CHK_MEM(achComponent);
#endif 
    UINT    uiLen;

    uiLen = GetResourceString(idsResource, (WCHAR *)achBuffer, ONEK, 0);
    if (!uiLen)
#ifndef UNDER_CE
        return;        // Error not found
#else
        goto Cleanup;
#endif 
        
    uiLen = GetResourceString(idsComponent, (WCHAR *)achComponent, ONEK, 0);
    if (!uiLen)
#ifndef UNDER_CE
        return;        // Error not found
#else
        goto Cleanup;
#endif 
        
        
    g_cErrorCollection.AddErrorEntry(achBuffer, achComponent, 0, 0, hr);
        
#ifdef UNDER_CE
Cleanup:
    if(achBuffer)
        delete [] achBuffer;
    if(achComponent)
        delete [] achComponent;       
#endif 

}
/////////////////////////////////////////////////////////////////////////////////////////////////////////



/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: void globalAddError(UINT idsResource, HRESULT hr, TCHAR *pchMsgPart)
//
//  parameters:
//
//  description:
//
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
void globalAddError(UINT idsResource, UINT idsComponent, HRESULT hr, ...)
{
#ifndef UNDER_CE
    TCHAR   achBuffer[ONEK+1]; 
    TCHAR   achComponent[ONEK+1];    
#else
    TCHAR   *achBuffer = new TCHAR[ONEK+1]; 
    TCHAR   *achComponent = new TCHAR[ONEK+1];   
    
    CHK_MEM(achBuffer);
    CHK_MEM(achComponent);
#endif 
    
    
    UINT    uiLen;
    va_list args;
    
    
    va_start(args, hr);


    uiLen = GetResourceStringHelper(idsResource, (WCHAR *)achBuffer, ONEK, &args);
    if (!uiLen)
#ifndef UNDER_CE
        return;        // Error not found
#else
        goto Cleanup;
#endif 

    va_end(args);
        
    uiLen = GetResourceString(idsComponent, (WCHAR *)achComponent, ONEK);
    if (!uiLen)
#ifndef UNDER_CE
        return;        // Error not found
#else
        goto Cleanup;
#endif 
        
        
    g_cErrorCollection.AddErrorEntry(achBuffer, achComponent, 0,0, hr);
        
#ifdef UNDER_CE
Cleanup:
    if(achBuffer)
        delete [] achBuffer;
    if(achComponent)
        delete [] achComponent;       
#endif
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////




/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: void globalDeleteErrorList(void)
//
//  parameters:
//
//  description:
//
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
void globalDeleteErrorList(void)
{
     g_cErrorCollection.Shutdown();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////






/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: void globalResetErrors(void)
//
//  parameters:
//
//  description:
//
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
void globalResetErrors(void)
{
    g_cErrorCollection.Reset();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////void globalResetErrors(void)




/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: void globalGetError(CErrorListEntry **ppErrorList)
//
//  parameters:
//
//  description:
//
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
void globalGetError(CErrorListEntry **ppErrorList)
{
    g_cErrorCollection.GetErrorEntry(ppErrorList);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: void         globalAddErrorFromErrorInfo();
//
//  parameters:
//
//  description:
//      adds a global error entry based on IErrorInfo
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
void globalAddErrorFromErrorInfo(EXCEPINFO * pexepInfo, HRESULT hrErrorCode)
{
    g_cErrorCollection.AddErrorFromErrorInfo(pexepInfo, hrErrorCode); 
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////





/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: void globalAddErrorFromISoapError(IDispatch *pDispatch)
//
//  parameters:
//
//  description:
//
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
void globalAddErrorFromISoapError(IDispatch *pDispatch, HRESULT hrErrorCode)
{
    g_cErrorCollection.AddErrorFromSoapError(pDispatch);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT globalSetActor(BSTR bstrCurActor)
//
//  parameters:
//
//  description:
//
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT globalSetActor(WCHAR * pcCurActor)
{
    if (pcCurActor)
    {   
        g_cErrorCollection.setActor(pcCurActor);        
    }
    return S_OK;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////