:param SetBreakpointsRequest request:
540669
def on_setbreakpoints_request(self, py_db, request):
        '''
        
        '''
        arguments = request.arguments  # : :type arguments: SetBreakpointsArguments
        # TODO: Path is optional here it could be source reference.
        filename = arguments.source.path
        filename = self.api.filename_to_server(filename)
        func_name = 'None'

        self.api.remove_all_breakpoints(py_db, filename)

        # Validate breakpoints and adjust their positions.
        try:
            lines = sorted(_get_code_lines(filename))
        except Exception:
            pass
        else:
            for bp in arguments.breakpoints:
                line = bp['line']
                if line not in lines:
                    # Adjust to the first preceding valid line.
                    idx = bisect.bisect_left(lines, line)
                    if idx > 0:
                        bp['line'] = lines[idx - 1]

        btype = 'python-line'
        suspend_policy = 'ALL'

        if not filename.lower().endswith('.py'):
            if self._debug_options.get('DJANGO_DEBUG', False):
                btype = 'django-line'
            elif self._debug_options.get('FLASK_DEBUG', False):
                btype = 'jinja2-line'

        breakpoints_set = []

        for source_breakpoint in arguments.breakpoints:
            source_breakpoint = SourceBreakpoint(**source_breakpoint)
            line = source_breakpoint.line
            condition = source_breakpoint.condition
            breakpoint_id = line

            hit_condition = self._get_hit_condition_expression(source_breakpoint.hitCondition)
            log_message = source_breakpoint.logMessage
            if not log_message:
                is_logpoint = None
                expression = None
            else:
                is_logpoint = True
                expression = convert_dap_log_message_to_expression(log_message)

            self.api.add_breakpoint(
                py_db, filename, btype, breakpoint_id, line, condition, func_name, expression, suspend_policy, hit_condition, is_logpoint)

            # Note that the id is made up (the id for pydevd is unique only within a file, so, the
            # line is used for it).
            # Also, the id is currently not used afterwards, so, we don't even keep a mapping.
            breakpoints_set.append({'id': self._next_breakpoint_id(), 'verified': True, 'line': line})

        body = {'breakpoints': breakpoints_set}
        set_breakpoints_response = pydevd_base_schema.build_response(request, kwargs={'body': body})
        return NetCommand(CMD_RETURN, 0, set_breakpoints_response, is_json=True)
731433
public void setRequest(HttpServletRequest request) {
		WaybackRequest wbRequest = new WaybackRequest();
		wbRequest.extractHttpRequestInfo(request);
		this.wbRequest = wbRequest;
	}
815645
protected void addBreakpoint(final IDbgpSession session,
			IVdmBreakpoint breakpoint) throws CoreException, DbgpException
	{
		final IDbgpCoreCommands commands = session.getCoreCommands();
		DbgpBreakpointConfig config = createBreakpointConfig(breakpoint);

		String id = null;
		URI bpUri = null;

		// map the outgoing uri if we're a line breakpoint
		if (breakpoint instanceof IVdmLineBreakpoint)
		{
			IVdmLineBreakpoint bp = (IVdmLineBreakpoint) breakpoint;
			bpUri = bpPathMapper.map(bp.getResourceURI());
		}

		// Type specific
		if (breakpoint instanceof IVdmWatchpoint)
		{
			IVdmWatchpoint watchpoint = (IVdmWatchpoint) breakpoint;
			config.setExpression(makeWatchpointExpression(watchpoint));

			id = commands.setWatchBreakpoint(bpUri, watchpoint.getLineNumber(), config);
		} else if (breakpoint instanceof IVdmMethodEntryBreakpoint)
		{
			IVdmMethodEntryBreakpoint entryBreakpoint = (IVdmMethodEntryBreakpoint) breakpoint;

			if (entryBreakpoint.breakOnExit())
			{
				final String exitId = commands.setReturnBreakpoint(bpUri, entryBreakpoint.getMethodName(), config);

				entryBreakpoint.setExitBreakpointId(exitId);
			}

			if (entryBreakpoint.breakOnEntry())
			{
				final String entryId = commands.setCallBreakpoint(bpUri, entryBreakpoint.getMethodName(), config);

				entryBreakpoint.setEntryBreakpointId(entryId);
			}
		} else if (breakpoint instanceof IVdmLineBreakpoint)
		{
			IVdmLineBreakpoint lineBreakpoint = (IVdmLineBreakpoint) breakpoint;

			if (VdmBreakpointUtils.isConditional(lineBreakpoint))
			{
				id = commands.setConditionalBreakpoint(bpUri, lineBreakpoint.getLineNumber(), config);
			} else
			{
				id = commands.setLineBreakpoint(bpUri, lineBreakpoint.getLineNumber(), config);
			}
		}

		// else if (breakpoint instanceof IVdmExceptionBreakpoint) {
		// IVdmExceptionBreakpoint lineBreakpoint = (IVdmExceptionBreakpoint) breakpoint;
		// id = commands.setExceptionBreakpoint(lineBreakpoint.getTypeName(),
		// config);
		// }

		// Identifier
		breakpoint.setId(session, id);
	}
19109
public void setRequest(Object request)
    {
        ExternalContext ctx = _MyFacesExternalContextHelper.firstInstance.get();
        
        if (ctx == null)
        {
            throw new UnsupportedOperationException();
        }
        
        ctx.setRequest(request);
    }
746366
public ResumeAppStreamResponse resumeAppStream(ResumeAppStreamRequest request) {
        checkNotNull(request, "The parameter request should NOT be null.");
        checkStringNotEmpty(request.getApp(), "The parameter app should NOT be null or empty string.");
        checkStringNotEmpty(request.getStream(), "The parameter stream should NOT be null or empty string.");
        InternalRequest internalRequest = createRequest(HttpMethodName.PUT, request, LIVE_APP,
                request.getApp(), LIVE_SESSION, request.getStream());
        internalRequest.addParameter(RESUME, null);
        return invokeHttpClient(internalRequest, ResumeAppStreamResponse.class);
    }
696846
public ResumeSessionResponse resumeSession(ResumeSessionRequest request) {
        checkNotNull(request, "The parameter request should NOT be null.");
        checkStringNotEmpty(request.getSessionId(), "The parameter sessionId should NOT be null or empty string.");
        InternalRequest internalRequest = createRequest(HttpMethodName.PUT, request, LIVE_SESSION,
                request.getSessionId());
        internalRequest.addParameter(RESUME, null);
        return invokeHttpClient(internalRequest, ResumeSessionResponse.class);
    }
272964
def clearBreakpoints( self ):
        
        self.markerDeleteAll(self._breakpointMarker)
        
        if ( not self.signalsBlocked() ):
            self.breakpointsChanged.emit()
778768
func (c *DOMDebugger) SetXHRBreakpointWithParams(v *DOMDebuggerSetXHRBreakpointParams) (*gcdmessage.ChromeResponse, error) {
	return gcdmessage.SendDefaultRequest(c.target, c.target.GetSendCh(), &gcdmessage.ParamRequest{Id: c.target.GetId(), Method: "DOMDebugger.setXHRBreakpoint", Params: v})
}
456016
public void resizeEip(ResizeEipRequest request) {
        checkNotNull(request.getNewBandwidthInMbps(), "newBandwidthInMbps should not be null");
        checkStringNotEmpty(request.getEip(), "eip should not be empty");
        if (Strings.isNullOrEmpty(request.getClientToken())) {
            request.setClientToken(generateDefaultClientToken());
        }
        InternalRequest internalRequest = this.createRequest(request, HttpMethodName.PUT, request.getEip());
        internalRequest.addParameter("resize", null);
        internalRequest.addParameter(CLIENT_TOKEN_IDENTIFY, request.getClientToken());
        fillPayload(internalRequest, request);
        invokeHttpClient(internalRequest, AbstractBceResponse.class);
    }
616486
@GuardedBy("lock")
    private Request findOverlappingRequest(Request request) {
        Map.Entry<Long, Request> previousEntry = this.pendingRequests.floorEntry(request.getOffset());
        if (previousEntry != null && request.getOffset() < previousEntry.getValue().getEndOffset()) {
            // Found one.
            return previousEntry.getValue();
        }

        // Either no previous entry, or the highest previous entry does not overlap.
        return null;
    }
1256695
protected final void requestCheckpoint(boolean persistent)
                    throws ObjectManagerException
    {
        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.entry(this,
                        cclass,
                        "requestCheckpoint",
                        new Object[] { new Boolean(persistent) });

        // During restart checkpointHelper is not running so don't request a checkpoint.
        // A checkpoint is forced at startup once it is safe to do so.
        if (checkpointHelper != null)
            checkpointHelper.requestCheckpoint(persistent);

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.exit(this,
                       cclass,
                       "requestCheckpoint");
    }
1214281
public void setBreakPoint(int line) {
        if (sourceInfo.breakableLine(line)) {
            boolean changed = sourceInfo.breakpoint(line, true);
            if (changed) {
                fileHeader.repaint();
            }
        }
    }
354640
public PauseAppStreamResponse pauseAppStream(PauseAppStreamRequest request) {
        checkNotNull(request, "The parameter request should NOT be null.");
        checkStringNotEmpty(request.getApp(), "The parameter app should NOT be null or empty string.");
        checkStringNotEmpty(request.getStream(), "The parameter stream should NOT be null or empty string.");
        InternalRequest internalRequest = createRequest(HttpMethodName.PUT, request, LIVE_APP,
                request.getApp(), LIVE_SESSION, request.getStream());
        internalRequest.addParameter(PAUSE, null);
        return invokeHttpClient(internalRequest, PauseAppStreamResponse.class);
    }
626584
public function SetBreakpoint(\Google\Cloud\Debugger\V2\SetBreakpointRequest $argument,
      $metadata = [], $options = []) {
        return $this->_simpleRequest('/google.devtools.clouddebugger.v2.Debugger2/SetBreakpoint',
        $argument,
        ['\Google\Cloud\Debugger\V2\SetBreakpointResponse', 'decode'],
        $metadata, $options);
    }
805830
def update_active_breakpoint_flag(cls):
        
        cls.any_active_breakpoint=any([bp.enabled for bp in cls.breakpoints_by_number if bp])
226201
private void setThresholdAttributes(List<String> thresholdIds, HttpServletRequest request) throws APIException {
        if (thresholdIds == null || thresholdIds.isEmpty()) {
            return;
        }

        request.setAttribute("thresholdsPresent", Boolean.TRUE);
        List<ThresholdStatusBean> thresholdStatusBeans = getThresholdBeans(getThresholdAPI().getThresholdStatuses(thresholdIds.toArray(new String[0])));
        request.setAttribute("thresholds", thresholdStatusBeans);
    }
200367
public void setRestartMarker(RestartData restartData)
        throws IOException, ServerException {
        Command cmd = new Command("REST", restartData.toFtpCmdArgument());
        Reply reply = null;
        try {
            reply = controlChannel.exchange(cmd);
        } catch (FTPReplyParseException e) {
            throw ServerException.embedFTPReplyParseException(e);
        }

        if (!Reply.isPositiveIntermediate(reply)) {
            throw ServerException.embedUnexpectedReplyCodeException(
                                new UnexpectedReplyCodeException(reply));
        }
    }