IDebugPendingBreakpoint2::CanBind

Článek
01/12/2024

Určuje, jestli se tato čekající zarážka může svázat s umístěním kódu.

Syntaxe

int CanBind ( 
   out IEnumDebugErrorBreakpoints2 ppErrorEnum
);

HRESULT CanBind ( 
   IEnumDebugErrorBreakpoints2** ppErrorEnum
);

Parametry

ppErrorEnum
[ven] Vrátí IEnumDebugErrorBreakpoints2 objekt, který obsahuje seznam IDebugErrorBreakpoint2 objekty, pokud by mohlo dojít k chybám.

Vrácená hodnota

V případě úspěchu vrátí hodnotu S_OK. Return S_FALSE , pokud zarážka nemůže vytvořit vazbu, v takovém případě jsou chyby vráceny parametrem ppErrorEnum . V opačném případě vrátí kód chyby. Vrátí E_BP_DELETED , pokud byla zarážka odstraněna.

Poznámky

Tato metoda se volá k určení toho, co by se stalo, pokud by byla tato čekající zarážka vázána. Volání Bind metoda ve skutečnosti svázat čekající zarážku.

Příklad

Následující příklad ukazuje, jak implementovat tuto metodu pro jednoduchý CPendingBreakpoint objekt, který zveřejňuje IDebugPendingBreakpoint2 rozhraní.

HRESULT CPendingBreakpoint::CanBind(IEnumDebugErrorBreakpoints2** ppErrorEnum)
{
   HRESULT hr;
   HRESULT hrT;

   // Check for a valid pointer to an error breakpoint enumerator
   // interface; otherwise, return hr = E_INVALIDARG.
   if (ppErrorEnum)
   {
      // Verify that the pending breakpoint has not been deleted. If
      // deleted, then return hr = E_BP_DELETED.
      if (m_state.state != PBPS_DELETED)
      {
         // Verify that the breakpoint is a file/line breakpoint.
         if (IsFlagSet(m_pBPRequest->m_bpRequestInfo.dwFields, BPREQI_BPLOCATION) &&
             m_pBPRequest->m_bpRequestInfo.bpLocation.bpLocationType == BPLT_CODE_FILE_LINE)
         {
            hr = S_OK;
         }
         // If the breakpoint type is not a file/line breakpoint, then the
         // result should be an error breakpoint.
         else
         {
            // If the error breakpoint member variable does not have
            // allocated memory.
            if (!m_pErrorBP)
            {
               // Create, AddRef, and initialize a CErrorBreakpoint object.
               if (CComObject<CErrorBreakpoint>::CreateInstance(&m_pErrorBP) == S_OK)
               {
                  m_pErrorBP->AddRef();
                  m_pErrorBP->Initialize(this);
               }
            }

            // Create a new enumerator of error breakpoints.
             CComObject<CEnumDebugErrorBreakpoints>* pErrorEnum;
            if (CComObject<CEnumDebugErrorBreakpoints>::CreateInstance(&pErrorEnum) == S_OK)
            {
               // Get the IDebugErrorBreakpoint2 information for the
               // CErrorBreakpoint object.
               CComPtr<IDebugErrorBreakpoint2> spErrorBP;
               hrT = m_pErrorBP->QueryInterface(&spErrorBP);
               assert(hrT == S_OK);
               if (hrT == S_OK)
               {
                  // Initialize the new enumerator of error breakpoints
                  // with the IDebugErrorBreakpoint2 information.
                  IDebugErrorBreakpoint2* rgpErrorBP[] = { spErrorBP.p };
                  hrT = pErrorEnum->Init(rgpErrorBP, &(rgpErrorBP[1]), NULL, AtlFlagCopy);
                  if (hrT == S_OK)
                  {
                     // Verify that the passed IEnumDebugErrorBreakpoints2
                     // interface can be successful queried by the
                     // created CEnumDebugErrorBreakpoints object.
                     hrT = pErrorEnum->QueryInterface(ppErrorEnum);
                     assert(hrT == S_OK);
                  }
               }

               // Otherwise, delete the CEnumDebugErrorBreakpoints object.
               if (FAILED(hrT))
               {
                  delete pErrorEnum;
               }
            }

            hr = S_FALSE;
         }
      }
      else
      {
         hr = E_BP_DELETED;
      }
   }
   else
   {
      hr = E_INVALIDARG;
   }

   return hr;
}

Sdílet prostřednictvím