// CBlackListAwareComCreatorT

template <typename T, const CLSID* t_pClassIdentifier>

class ATL_NO_VTABLE CTransparentCoClassT

{

public:

// CTransparentCoClassT

    static HINSTANCE CoLoadOriginalLibrary()

    {

        const HINSTANCE hModule = CoLoadLibrary(const_cast<LPOLESTR>((LPCOLESTR) CT2COLE(T::GetOriginalLibraryName())), TRUE);

        __E(hModule);

        return hModule;

    }

    static CComPtr<IUnknown> CoCreateOriginalInstance(HINSTANCE hModule, IUnknown* pControllingUnknown = NULL)

    {

        typedef HRESULT (WINAPI *DLLGETCLASSOBJECT)(REFCLSID, REFIID, VOID**);

        DLLGETCLASSOBJECT DllGetClassObject = (DLLGETCLASSOBJECT) GetProcAddress(hModule, "DllGetClassObject");

        __E(DllGetClassObject);

        CComPtr<IClassFactory> pClassFactory;

        __C(DllGetClassObject(*t_pClassIdentifier, __uuidof(IClassFactory), (VOID**) &pClassFactory));

        _A(pClassFactory);

        CComPtr<IUnknown> pUnknown;

        __C(pClassFactory->CreateInstance(pControllingUnknown, __uuidof(IUnknown), (VOID**) &pUnknown));

        return pUnknown;

    }

    static CComPtr<IUnknown> CoCreateOriginalInstance(IUnknown* pControllingUnknown = NULL)

    {

        CComPtr<IUnknown> pUnknown;

        const HINSTANCE hModule = CoLoadOriginalLibrary();

        _ATLTRY

        {

            pUnknown = CoCreateOriginalInstance(hModule, pControllingUnknown);

        }

        _ATLCATCHALL()

        {

            CoFreeLibrary(hModule);

            _ATLRETHROW;

        }

        CoFreeLibrary(hModule);

        return pUnknown;

    }

};

////////////////////////////////////////////////////////////

// CBlackListAwareComCreatorT

template <typename _ObjectClass, typename _Class, LPCTSTR* t_ppszName>

class CBlackListAwareComCreatorT :

    public CComCreator<_ObjectClass>

{

public:

// CBlackListAwareComCreatorT

    static HRESULT WINAPI CreateInstance(VOID* pvControllingUnknown, REFIID InterfaceIdentifier, VOID** ppvObject) throw()

    {

        _A(ppvObject);

        *ppvObject = NULL;

        #pragma region Check Black List

        static INT g_nBlackListed = 0; // 0 Unknown, 1 No, 2 Yes

        {

            _A(_pAtlModule);

            CComCritSecLock<CComCriticalSection> Lock(_pAtlModule->m_csStaticDataInitAndTypeInfo);

            if(!g_nBlackListed)

            {

                TCHAR pszPath[MAX_PATH] = { 0 };

                _W(GetModuleFileName(NULL, pszPath, DIM(pszPath)));

                LPTSTR pszFileName = FindFileName(pszPath);

                _A(pszFileName);

                RemoveExtension(pszFileName);

                const CString sBlackList = _RegKeyHelper::QueryStringValue(HKEY_LOCAL_MACHINE, REGISTRY_ROOT, AtlFormatString(_T("%s Black List"),
*t_ppszName));

                CRoArrayT<CString> BlackListArray;

                _StringHelper::GetCommaSeparatedItems(sBlackList, BlackListArray);

                BOOL bFound = FALSE;

                for(SIZE_T nIndex = 0; nIndex < BlackListArray.GetCount(); nIndex++)

                {

                    CPath sFileName = (LPCTSTR) BlackListArray[nIndex];

                    sFileName.RemoveExtension();

                    if(_tcsicmp(sFileName, pszFileName) == 0)

                    {

                        _Z2(atlTraceCOM, 2, _T("Will instantiate original COM class, sFileName \"%s\"\n"), sFileName);

                        bFound = TRUE;

                        break;

                    }

                }

                g_nBlackListed = bFound ? 2 : 1;

            }

        }

        #pragma endregion 

        if(g_nBlackListed == 2)

            #pragma region CoCreateInstance Original Class

            _ATLTRY

            {

                _A(_pAtlModule);

                const LONG nLockResult = _pAtlModule->Lock();

                _ATLTRY

                {

                    CComPtr<IUnknown> pUnknown = _Class::CoCreateOriginalInstance((IUnknown*) pvControllingUnknown);

                    if(InterfaceIdentifier == __uuidof(IUnknown))

                        *ppvObject = pUnknown.Detach();

                    else

                        __C(pUnknown->QueryInterface(InterfaceIdentifier, ppvObject));

                }

                _ATLCATCHALL()

                {

                    _pAtlModule->Unlock();

                    _ATLRETHROW;

                }

                const LONG nUnlockResult = _pAtlModule->Unlock();

                _Z4(atlTraceGeneral, 6-2, _T("nLockResult %d, nUnlockResult %d\n"), nLockResult, nUnlockResult);

                return S_OK;

            }

            _ATLCATCH(Exception)

            {

                _A(FAILED(Exception));

                _C(Exception);

            }

            #pragma endregion 

        return __super::CreateInstance(pvControllingUnknown, InterfaceIdentifier, ppvObject);

    }

};

////////////////////////////////////////////////////////////