Partilhar via


IDebugPendingBreakpoint2::CanBind

Determines whether this pending breakpoint can bind to a code location.

HRESULT CanBind ( 
   IEnumDebugErrorBreakpoints2** ppErrorEnum
);
int CanBind ( 
   out IEnumDebugErrorBreakpoints2 ppErrorEnum
);

Parameters

Return Value

If successful, returns S_OK. Returns S_FALSE if the breakpoint cannot bind, in which case the errors are returned by the ppErrorEnum parameter. Otherwise, returns an error code. Returns E_BP_DELETED if the breakpoint has been deleted.

Remarks

This method is called to determine what would happen if this pending breakpoint was bound. Call the IDebugPendingBreakpoint2::Bind method to actually bind the pending breakpoint.

Example

The following example shows how to implement this method for a simple CPendingBreakpoint object that exposes the IDebugPendingBreakpoint2 interface.

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;  
}  

See Also

Reference

IDebugPendingBreakpoint2

IEnumDebugErrorBreakpoints2

IDebugErrorBreakpoint2

IDebugPendingBreakpoint2::Bind