HRESULT CordbAppDomain::QueryInterface(REFIID id, void **ppInterface) { if (id == IID_ICorDebugAppDomain) { *ppInterface = (ICorDebugAppDomain*)this; } else if (id == IID_ICorDebugAppDomain2) { *ppInterface = (ICorDebugAppDomain2*)this; } else if (id == IID_ICorDebugAppDomain3) { *ppInterface = (ICorDebugAppDomain3*)this; } else if (id == IID_ICorDebugAppDomain4) { *ppInterface = (ICorDebugAppDomain4*)this; } else if (id == IID_ICorDebugController) *ppInterface = (ICorDebugController*)(ICorDebugAppDomain*)this; else if (id == IID_IUnknown) *ppInterface = (IUnknown*)(ICorDebugAppDomain*)this; else { *ppInterface = NULL; return E_NOINTERFACE; } ExternalAddRef(); return S_OK; }
// IDispatch implementation void CoAuthRenewTokenAsync::ReadyStateChange() { ExternalAddRef(); // lock protect your instance try { TRACE1("CoAuthRenewTokenAsync::IXMLDOMDocumentEvents::OnReadyStateChange() readyState: 0x%.8x\n", m_spRequest->readyState); switch (m_spRequest->readyState) { case READYSTATE_COMPLETE: // = 4 { /* * das hier uebergebene X,Y,Z this hat KEINERLEI funktionale bedeutung und dient lediglich dazu * dem progrmierer auf evtl. fehler hinzuweisen. * Hintergrund: * es kann NUR EINEN "wirksamen" CRenewTokenAsync geben. Das ist der der als erstes erzeugt wurde. * NUR der CRenewTokenAsync der Lock aufgerufen hat kann auch UnLock aufrufen! * mit dem ersten CRenewTokenAsync wird the<Service> (IAuthorize) verriegelt. * damit folgerequests nicht blockieren und nicht verlorengehen werden sie in einer queue aufbewahrt. * * m_spAuthorize kennt den m_spRequest weil er ihn ja initial selbst erstellt hat. * m_spAuthorize braucht den m_spRequest weil dort das ergebnis des "Renew" ermittelt wird. * wir (CRenewTokenAsync) brauchen den m_spRequest lediglich um den callback (OnReadyStateChange) zu registrien bzw. zu deregistrieren. */ HRESULT hr = m_spAuthorize->raw_UnLockFromRenew(); _ASSERT(SUCCEEDED(hr)); // break reference cycle, Remove sink from xml http request // CAUTION: this wont work for this implementation MFC/DISPATCH (Heap corrupt) // m_spRequest->put_onreadystatechange(NULL); if (SUCCEEDED(hr)) { ATLTRACE2(atlTraceGeneral, 1, _T(" continue previous workflow\n")); m_spRenewCallback->Continue(); } else { ATLTRACE2(atlTraceGeneral, 1, _T(" terminate previous workflow\n")); m_spRenewCallback->Terminate(); } m_spRenewCallback = NULL; } break; case READYSTATE_UNINITIALIZED: // = 0, case READYSTATE_LOADING: // = 1, case READYSTATE_LOADED: // = 2, case READYSTATE_INTERACTIVE: // = 3, default: break; } } catch (const _com_error& e) { HRESULT hr = e.Error(); } ExternalRelease(); // unlock instance, may the last one }
// return addref'd IDispatch part of CCmdTarget object LPDISPATCH CCmdTarget::GetIDispatch(BOOL bAddRef) { ASSERT_VALID(this); ASSERT(m_xDispatch.m_vtbl != 0); // forgot to call EnableAutomation? // AddRef the object if requested if (bAddRef) ExternalAddRef(); // return pointer to IDispatch implementation return (LPDISPATCH)GetInterface(&IID_IDispatch); }
//=--------------------------------------------------------------------------= // CStandardEnum::InternalQueryInterface //=--------------------------------------------------------------------------= // we support our internal iid, and that's all // // Parameters: // REFIID - [in] interface they want // void ** - [out] where they want to put the resulting object ptr. // // Output: // HRESULT - S_OK, E_NOINTERFACE // // Notes: // HRESULT CStandardEnum::InternalQueryInterface ( REFIID riid, void **ppvObjOut ) { if (DO_GUIDS_MATCH(riid, m_iid)) { ExternalAddRef(); *ppvObjOut = (IEnumGeneric *)this; return S_OK; } return E_NOINTERFACE; }
COM_METHOD CorpubPublish::QueryInterface(REFIID id, void **ppInterface) { if (id == IID_ICorPublish) *ppInterface = (ICorPublish*)this; else if (id == IID_IUnknown) *ppInterface = (IUnknown*)(ICorPublish*)this; else { *ppInterface = NULL; return E_NOINTERFACE; } ExternalAddRef(); return S_OK; }
//----------------------------------------------------------------------------- // Implement IUnknown::QueryInterface. //----------------------------------------------------------------------------- HRESULT CordbMDA::QueryInterface(REFIID riid, void **ppInterface) { if (riid == IID_ICorDebugMDA) *ppInterface = static_cast<ICorDebugMDA*>(this); else if (riid == IID_IUnknown) *ppInterface = static_cast<IUnknown*>(static_cast<ICorDebugMDA*>(this)); else { *ppInterface = NULL; return E_NOINTERFACE; } ExternalAddRef(); return S_OK; }
HRESULT CordbAssembly::QueryInterface(REFIID id, void **ppInterface) { if (id == IID_ICorDebugAssembly) *ppInterface = static_cast<ICorDebugAssembly*>(this); else if (id == IID_ICorDebugAssembly2) *ppInterface = static_cast<ICorDebugAssembly2*>(this); else if (id == IID_IUnknown) *ppInterface = static_cast<IUnknown*>( static_cast<ICorDebugAssembly*>(this) ); else { *ppInterface = NULL; return E_NOINTERFACE; } ExternalAddRef(); return S_OK; }
BOOL CSpaceshipFactory::ExternalQueryInterface(int nIid, void** ppvObj) { TRACE("Entering CSpaceshipFactory::ExternalQueryInterface - ID: %d\n", nIid); switch(nIid) { case IID_IUnknown: case IID_IClassFactory: *ppvObj = &m_xClassFactory; break; default: *ppvObj = NULL; return FALSE; } ExternalAddRef(); return TRUE; }
BOOL CSpaceship::ExternalQueryInterface(int nIid, void** ppvObj) { TRACE("Entering CSpaceship::ExternalQueryInterface - ID: %d\n", nIid); switch(nIid) { case IID_IUnknown: case IID_IMotion: *ppvObj = &m_xMotion; break; case IID_IVisual: *ppvObj = &m_xVisual; break; default: *ppvObj = NULL; return FALSE; } ExternalAddRef(); return TRUE; }
//----------------------------------------------------------------------------- // Standard IUnknown::QI implementation. // See IUnknown::QI for standard semantics. //----------------------------------------------------------------------------- HRESULT CordbClass::QueryInterface(REFIID id, void **pInterface) { if (id == IID_ICorDebugClass) { *pInterface = static_cast<ICorDebugClass*>(this); } else if (id == IID_ICorDebugClass2) { *pInterface = static_cast<ICorDebugClass2*>(this); } else if (id == IID_IUnknown) { *pInterface = static_cast<IUnknown*>(static_cast<ICorDebugClass*>(this)); } else { *pInterface = NULL; return E_NOINTERFACE; } ExternalAddRef(); return S_OK; }
STDMETHODIMP_(ULONG) CFolderDialog::AddRef() { //BFTRACE(_T("CFolderDialog(%p)::AddRef\n"),this); return ExternalAddRef(); }
// IDispatch implementation void CoAuthServiceCall::ReadyStateChange() { const DWORD dwRef = ExternalAddRef(); // lock protect your instance try { switch (m_spRequest->readyState) { case READYSTATE_LOADING: { TRACE2("CoAuthServiceCall(%ls)::IXMLDOMDocumentsEvent::OnReadyStateChange() logical state: %d, m_spRequest->readyState: READYSTATE_LOADING\n", (BSTR)m_bstrUrl, m_eState); /* * siehe auch: kommentar zu * CoAuthServiceCall::m_bstrAccessToken UND * IWorkflow::AuthorizeRequest */ oAuthLib::IAuthorizePtr spAuthorize; if (SUCCEEDED(GetTokenServer(&spAuthorize))) spAuthorize->AuthorizeRequest(m_spRequest, &m_bstrAccessToken); } break; case READYSTATE_COMPLETE: { TRACE2("CoAuthServiceCall(%ls)::IXMLDOMDocumentsEvent::OnReadyStateChange() logical state: %d, m_spRequest->readyState: READYSTATE_COMPLETE\n", (BSTR)m_bstrUrl, m_eState); /* * das wird erst noetig wenn wir den UseCase: Shutdown, Wait for pending requests implementieren * CComPtr < IWorkflow > spWorkflow; * pThis->GetWorkflow(&spWorkflow); * spWorkflow->FinalizeRequest(m_spRequest); */ if (200 == m_spRequest->status) { m_eState = Finish; #ifdef AUTHORIZATION_SERVER_SUPPORT_JSON /* * das ist natuerlich LUXUS pur bzw. schon zuviel spezialisierung. es gibt ja auch noch XML * https://casablanca.codeplex.com/wikipage?title=JSON&referringTitle=Documentation * * CAUTION: this is necessary to avoid false memory leaks reported by the MFC framework; * http://codexpert.ro/blog/2015/05/23/using-lambdas-in-mfc-applications-part-3-dealing-with-c-rest-sdk/ */ web::json::value result = web::json::value::parse(utility::string_t(m_spRequest->responseText)); onSucceeded(result); // wir setzen das onSucceeded NICHT in abhaengigkeit vom m_spRequest->status #else onSucceeded(); // wir setzen das onSucceeded NICHT in abhaengigkeit vom m_spRequest->status #endif // break reference cycle, Remove sink from xml http request // CAUTION: this wont work for this implementation MFC/DISPATCH (Heap corrupt) // entweder KEINEN code mehr ausfuehren ODER Lock/Unlock // m_spRequest->put_onreadystatechange(NULL); } else if (401 == m_spRequest->status && InitialRequest == m_eState) { oAuthLib::IAuthorizePtr spAuthorize; if (SUCCEEDED(GetTokenServer(&spAuthorize))) { const HRESULT _hr = spAuthorize->raw_CanRetryImmediately(m_spRequest, m_bstrAccessToken); _ASSERT(SUCCEEDED(_hr)); // per definition gibt es hier KEIN E_FAIL/E_NOTIMPL ... if (S_FALSE == _hr) { /* * der ERSTE request der ein 401 empfaengt bzw. ALLE folge requests, die beendet wurden OHNE das wir bereits ein NEUES GUELTIGES access_token haben, laufen hier rein. * werden vom client bzw. den clients die requests schneller abgesetzt als ein ExchangeToken() mit gueltigem access_token zurueckkommt muss der second try gequeued werden. */ ASSERT(NULL == m_pRenewTokenAsync); m_pRenewTokenAsync = DYNAMIC_DOWNCAST(CoAuthRenewTokenAsync, RUNTIME_CLASS(CoAuthRenewTokenAsync)->CreateObject()); ASSERT(1 == m_pRenewTokenAsync->m_dwRef); /* * dieses object kuemmert sich transparent und OHNE jegliches zutun des programmieres * darum das es einen pThis->onSucceeded() bzw. pThis->onFailed(); gibt * diese referenz MUSS VOR dem aufruf von ::Init() gelockt anschliessend freigegeben UND NICHT gespeichert werden! * Hinweis: ein per CRunntimeClass::CreateObject()) erzeugtes object hat initial 1 == CCmdTarget::m_dwRef */ { oAuthLib::IRenewCallbackPtr spCallback(GetInterface(&__uuidof(oAuthLib::IRenewCallback))); ASSERT(CCmdTarget::m_dwRef == dwRef + 1); m_pRenewTokenAsync->Init(spAuthorize, spCallback); ASSERT(CCmdTarget::m_dwRef == dwRef + 2); } } else { /* * wir haben bereits ein NEUES GUELTIGES access_token empfangen. * wir koennen diesen request SOFORT neu anstossen. MUSS NATUERLICH ASYNC sein. */ // wir loeschen das alte/unbrauchbare access_token aus dem initialen request m_bstrAccessToken.Empty(); // mit IRenewCallback::Continue() wird der m_spRequest NEU initialisiert und indirekt ueber IWorkflow::AuthorizeRequest() wieder authorisiert. oAuthLib::IRenewCallbackPtr spCallback(GetInterface(&__uuidof(oAuthLib::IRenewCallback))); spCallback->Continue(); // here we go: NEUES GUELTIGES access_token ASSERT(0 < m_bstrAccessToken.Length()); } } else { // saudummer zustand wir koennen den fehler NICHT an den aufrufer liefern // ohne Workflow object geht nix da machen wir ganz ALLGEMEIN schluss m_eState = Finish; onFailed(); // break reference cycle, Remove sink from xml http request // CAUTION: this wont work for this implementation MFC/DISPATCH (Heap corrupt) // entweder KEINEN code mehr ausfuehren ODER Lock/Unlock // m_spRequest->put_onreadystatechange(NULL); } } else { // IRGENDEIN (unbehandelter) http-status m_eState = Finish; onFailed(); // break reference cycle // Remove sink from xml http request, hie faellt evtl. die letzte referenz // entweder KEINEN code mehr ausfuehren ODER Lock/Unlock // m_spRequest->put_onreadystatechange(NULL); } } break; default: TRACE2(" logical state: %d, m_spRequest->readyState: %d\n", m_eState, m_spRequest->readyState); break; } } catch (const _com_error& e) { TRACE0("CoAuthServiceCall::ReadyStateChange(): ignore exception keep system stable!!!\n"); } ExternalRelease(); // unlock your instance }