CommonError.cpp

Go to the documentation of this file.

#include "stdafx.h"
#include "CommonError.h"
#include "CommonSmart.h"
#include <stdio.h>

// --------------------------- hresult_exception

hresult_exception::hresult_exception()
{
        hr = 0;
}

hresult_exception::hresult_exception(const hresult_exception &e)
{
        hr = e.hr;
}

hresult_exception::hresult_exception(HRESULT a)
{
        hr = a;
}

hresult_exception &hresult_exception::operator=(const hresult_exception &e)
{
        hr = e.hr;
        return *this;
}

hresult_exception &hresult_exception::operator=(HRESULT a)
{
        hr = a;
        return *this;
}

hresult_exception::~hresult_exception()
{
}

const char *hresult_exception::what() const
{
        static char message[80];
        sprintf_s(message, sizeof(message), "HRESULT (0x%08lx) exception", hr);
        return message;
}

// --------------------------- Error Codes

LPOLESTR common_descs[] = 
{
        OLESTR("Improper use of object"),
        OLESTR("Unknown exception"),
        OLESTR("Data conversion has failed"),
        OLESTR("Requested != count in GetAll"),
        OLESTR("[out] parameter is not empty"),
        OLESTR("Passed interface is not from the same project"),
        OLESTR("Object was not found"),
        OLESTR("File could not be opened"),
        OLESTR("VERIFY has failed"),
        OLESTR("COMTHROW test exception throwed"),
};

LPOLESTR core_descs[] = 
{
        OLESTR("Object is locked by another Core component"),
        OLESTR("Lock value in Storage is invalid"),
        OLESTR("Attribute is not found"),
        OLESTR("Meta object is not found"),
        OLESTR("Meta project is invalid"),
        OLESTR("Invalid response from Repository"),
        OLESTR("CoreProject - CoreMetaProject mismatch"),
        OLESTR("Object is deleted or unloaded (zombie)"),
        OLESTR("Invalid ValueType"),
        OLESTR("No active transaction"),
        OLESTR("Object already exists"),
        OLESTR("No Territory has been selected"),
        OLESTR("Object is not locked"),
        OLESTR("Invalid data in Repository"),
        OLESTR("Cannot delete Object, has nonempty collection"),
        OLESTR("Cannot resolve the connection string"),
        OLESTR("Invalid binary file storage"),
        OLESTR("Project has no name"),
};

LPOLESTR meta_descs[] = 
{
        OLESTR("Invalid ATTVAL type"),
        OLESTR("MetaProject is not open"),
        OLESTR("Invalid Path"),
        OLESTR("Invalid MetaRef")
};

LPOLESTR parser_descs[] = 
{
        OLESTR("Invalid DTD file"),
        OLESTR("Invalid GUID"),
        OLESTR("Invalid XML filename"),
        OLESTR("Invalid MGA object"),
        OLESTR("Invalid META object"),
        OLESTR("Too many passes while parsing the XML file"),
        OLESTR("Invalid long value in XML file")
};

void throw_com_error(HRESULT hr, LPCOLESTR desc)
{
        ASSERT( desc != NULL );

        try
        {
                CComObjPtr<ICreateErrorInfo> errorinfo;
                COMTHROW( CreateErrorInfo(PutOut(errorinfo)) );
                COMTHROW( errorinfo->SetDescription(const_cast<LPOLESTR>(desc)) );
                COMTHROW( errorinfo->SetSource(OLESTR("GME")) );

                CComObjPtr<IErrorInfo> errorinfo2;
                COMTHROW( QueryInterface(errorinfo, errorinfo2) );
                COMTHROW( SetErrorInfo(0, errorinfo2) );

                throw _com_error(hr, errorinfo2, true);
        }
        catch(hresult_exception &)
        {
                // do nothing
        }
}

void SetErrorInfo(LPCOLESTR desc)
{
        ASSERT( desc != NULL );

        try
        {
                CComObjPtr<ICreateErrorInfo> errorinfo;
                COMTHROW( CreateErrorInfo(PutOut(errorinfo)) );
                COMTHROW( errorinfo->SetDescription(const_cast<LPOLESTR>(desc)) );
                COMTHROW( errorinfo->SetSource(OLESTR("GME")) );

                CComObjPtr<IErrorInfo> errorinfo2;
                COMTHROW( QueryInterface(errorinfo, errorinfo2) );
                COMTHROW( SetErrorInfo(0, errorinfo2) );
        }
        catch(hresult_exception &)
        {
                // do nothing
        }
}


struct errtab {
        long code;
        LPOLESTR descr;
};

#include "..\Mga\MgaErr.c"

#define MGAERRCODEBASE 0x87650000
#define MGAERRCODESPAN 0x1000

LPCOLESTR MgaGetErrorInfo(HRESULT hr) {
        if(hr >= MGAERRCODEBASE && hr < MGAERRCODEBASE + MGAERRCODESPAN) {
                for(struct errtab const *hh = MgaErrTab; hh->code != 0; hh++) { 
                        if(hh->code == hr) {
                                return hh->descr;
                        }
                }
        }
        return NULL;
}

bool MgaSetErrorInfo(HRESULT hr) {
        LPCOLESTR mgaError = MgaGetErrorInfo(hr);
        if (mgaError)
        {
                SetErrorInfo(mgaError);
                return true;
        }
        return false;
}

void SetErrorInfo(HRESULT hr, LPOLESTR desc2)
{
        ASSERT( sizeof(common_descs)/sizeof(LPOLESTR) == (E_COMMON_LAST-E_COMMON_FIRST+1) );
        ASSERT( sizeof(core_descs)/sizeof(LPOLESTR) == (E_CORE_LAST-E_CORE_FIRST+1) );
        ASSERT( sizeof(meta_descs)/sizeof(LPOLESTR) == (E_META_LAST-E_META_FIRST+1) );
        ASSERT( sizeof(parser_descs)/sizeof(LPOLESTR) == (E_PARSER_LAST-E_PARSER_FIRST+1) );

        LPOLESTR desc = NULL;
        if( E_COMMON_FIRST <= hr && hr <= E_COMMON_LAST ) desc = common_descs[hr - E_COMMON_FIRST];
        else if( E_CORE_FIRST <= hr && hr <= E_CORE_LAST ) desc = core_descs[hr - E_CORE_FIRST];
        else if( E_META_FIRST <= hr && hr <= E_META_LAST ) desc = meta_descs[hr - E_META_FIRST];
        else if( E_PARSER_FIRST <= hr && hr <= E_PARSER_LAST ) desc = parser_descs[hr - E_PARSER_FIRST];

        if( desc2 == NULL )
        {
                if( desc != NULL )
                        SetErrorInfo(desc);
                else if (hr >= MGAERRCODEBASE && hr < MGAERRCODEBASE + MGAERRCODESPAN)
                {
                        MgaSetErrorInfo(hr);
                }
        }
        else
        {
                CComBSTR d(desc);
                if( desc != NULL )
                        COMTHROW(d.Append(L" :"));

                COMTHROW(d.Append(desc2));
                SetErrorInfo(d);
        }
}

bool GetErrorInfo(BSTR *desc)
{
        ASSERT( desc != NULL );

        try
        {
                CComObjPtr<IErrorInfo> errinfo;
                COMTHROW( GetErrorInfo(0, PutOut(errinfo)) );
                ASSERT( errinfo != NULL );

                if( errinfo) COMTHROW( errinfo->GetDescription(desc) );
        }
        catch(hresult_exception &)
        {
                // do nothing
                return false;
        }
        return true;
}

void GetErrorInfo(HRESULT hr, BSTR *p)
{
        ASSERT( p != NULL );

        LPOLESTR desc = NULL;
        if( E_COMMON_FIRST <= hr && hr <= E_COMMON_LAST ) desc = common_descs[hr - E_COMMON_FIRST];
        else if( E_CORE_FIRST <= hr && hr <= E_CORE_LAST ) desc = core_descs[hr - E_CORE_FIRST];
        else if( E_META_FIRST <= hr && hr <= E_META_LAST ) desc = meta_descs[hr - E_META_FIRST];
        else if( E_PARSER_FIRST <= hr && hr <= E_PARSER_LAST ) desc = parser_descs[hr - E_PARSER_FIRST];
        
        if( desc != NULL )
        {
                SysFreeString(*p);
                *p = SysAllocString(desc);
        }
        else if (hr >= MGAERRCODEBASE && hr < MGAERRCODEBASE + MGAERRCODESPAN)
        {
                LPCOLESTR mgaError = MgaGetErrorInfo(hr);
                if (mgaError)
                        *p = SysAllocString(mgaError);
                else
                        GetErrorInfo(E_FAIL, p);
        }
        else
        {
                LPWSTR errorText = NULL;
                FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_ALLOCATE_BUFFER |FORMAT_MESSAGE_IGNORE_INSERTS,  
                   NULL, hr, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR)&errorText, 0, NULL);
                if (errorText != NULL) {
                        SysFreeString(*p);
                        *p = SysAllocString(errorText);
                        LocalFree(errorText);
                } else {
                        if (!GetErrorInfo(p))
                        {
                                GetErrorInfo(E_FAIL, p);
                        }
                }
        }
}

---