Deletes all requests and responses for a given flow from the database.
321462
def DeleteAllFlowRequestsAndResponses(self, client_id, flow_id):
    """"""
    flow_key = (client_id, flow_id)
    try:
      self.flows[flow_key]
    except KeyError:
      raise db.UnknownFlowError(client_id, flow_id)

    try:
      del self.flow_requests[flow_key]
    except KeyError:
      pass

    try:
      del self.flow_responses[flow_key]
    except KeyError:
      pass
150103
def remove_data_flows_with_data_port_id(self, data_port_id):
        
        if not self.is_root_state:
            # delete all data flows in parent related to data_port_id and self.state_id
            data_flow_ids_to_remove = []
            for data_flow_id, data_flow in self.parent.data_flows.items():
                if data_flow.from_state == self.state_id and data_flow.from_key == data_port_id or \
                        data_flow.to_state == self.state_id and data_flow.to_key == data_port_id:
                    data_flow_ids_to_remove.append(data_flow_id)

            for data_flow_id in data_flow_ids_to_remove:
                self.parent.remove_data_flow(data_flow_id)
170287
def delete_all_pipelines(self):
		'''
		'''
		code, data = self.get_pipeline()
		if code == requests.codes.ok:
			for pl_data in data:
				c, d = self.delete_pipeline(pl_data['pipelineKey'])
				if c != requests.codes.ok:
					code = c
					data = d
		return code, data
1328225
public void removeAllConversations(Object connectionReference) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "removeAllConversations", connectionReference);

        final ArrayList list;
        synchronized (activeConversations) {
            list = (ArrayList) activeConversations.remove(connectionReference);
        }

        // Remove the connection reference from the list
        if (list != null) {
            try {
                for (int x = 0; x < list.size(); x++) {
                    Conversation conv = (Conversation) list.get(x);
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                        SibTr.debug(this, tc, "Found a Conversation in the table: ", conv);
                    // Now call the server transport receive listener to clean up the resources
                    serverTransportReceiveListener.cleanupConnection(conv);
                }
            } catch (Throwable t) {
                FFDCFilter.processException(t, CLASS_NAME + ".removeAllConversations",
                                            CommsConstants.SERVERTRANSPORTACCEPTLISTENER_REMOVEALL_01,
                                            this);

                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                    SibTr.debug(this, tc, "Caught an exception cleaning up a connection", t);
            }

            // Now clear the list
            list.clear();
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "removeAllConversations");
    }
791465
protected void removeAndProcess(Collection<R> requests) {
        try {
            Collection<R> removed=new ArrayList<>();
            Iterator<R> it=requests.iterator();
            R first_req=it.next();
            removed.add(first_req);
            it.remove();

            while(it.hasNext()) {
                R next=it.next();
                if(req_matcher.test(first_req, next)) {
                    removed.add(next);
                    it.remove();
                }
                else
                    break;
            }
            req_processor.accept(removed);
        }
        catch(Throwable t) {
            log().error("failed processing requests", t);
        }
    }
1143323
function destroy(req, res, err, reply) {
  req.conn.transaction = null;
  req.conn.unwatch(req.db);
  this.queue = null;
  this.error = null;
  res.send(err, reply);
}
181598
def do_DELETE(self):
        
        self.do_initial_operations()
        coap_response = self.client.delete(self.coap_uri.path)
        self.client.stop()
        logger.debug("Server response: %s", coap_response.pretty_print())
        self.set_http_response(coap_response)
781138
def clear(self):
        
        collection = self.ds.connection(COLLECTION_MANAGED_PROCESS)
        return collection.delete_many(filter={})
458043
def AckFlowProcessingRequests(self, requests):
    """"""
    for r in requests:
      key = (r.client_id, r.flow_id)
      if key in self.flow_processing_requests:
        del self.flow_processing_requests[key]
769021
public function removeAll()
    {
        foreach ($this->handles as $transaction) {
            $ch = $this->handles[$transaction];
            curl_multi_remove_handle($this->multi, $ch);
            curl_close($ch);
            unset($this->handles[$transaction]);
        }
    }
828365
def DeleteFlowRequests(self, requests, cursor=None):
    """"""
    if not requests:
      return

    conditions = []
    args = []
    for r in requests:
      conditions.append("(client_id=%s AND flow_id=%s AND request_id=%s)")
      args.append(db_utils.ClientIDToInt(r.client_id))
      args.append(db_utils.FlowIDToInt(r.flow_id))
      args.append(r.request_id)

    req_query = "DELETE FROM flow_requests WHERE " + " OR ".join(conditions)
    res_query = "DELETE FROM flow_responses WHERE " + " OR ".join(conditions)

    cursor.execute(res_query, args)
    cursor.execute(req_query, args)
106570
def clear(**kwargs):
    

    database = kwargs.pop('database', False)
    expression = lambda target, table: table.drop(target)
    test = lambda x, tab: not database_exists(x.url) or not tab.exists(x)

    # TODO: Iterate through all engines in name set.
    if database and database_exists(engine['default'].url):
        drop_database(engine['default'].url)
        clear_cache()

    op(expression, reversed(metadata.sorted_tables), test=test,
       primary='clear', secondary='drop', **kwargs)
918279
def delete_all(self): 
        
        for record in self.find(using_name=False, data_only=True):
            res = self.delete_one(record["id"])
799090
public void clear() {
		requests.clear();
		rootCurrentContextsByThreadId.clear();
		if (errors != null) {
			synchronized (errors) {
				errors.clear();
			}
		}
		startDate = new Date();
	}
776983
public static void clearGrailsWebRequest() {
        RequestAttributes reqAttrs = RequestContextHolder.getRequestAttributes();
        if (reqAttrs != null) {
            // First remove the web request from the HTTP request attributes.
            GrailsWebRequest webRequest = (GrailsWebRequest) reqAttrs;
            webRequest.getRequest().removeAttribute(GrailsApplicationAttributes.WEB_REQUEST);

            // Now remove it from RequestContextHolder.
            RequestContextHolder.resetRequestAttributes();
        }
    }
1290952
public function clearSlow()
    {
        $url = UrlHelper::buildUrl(Urls::URL_QUERY, ['slow']);
        $this->getConnection()->delete($url);
    }
642320
def clear(self):
        
        del self._statements_and_parameters[:]
        self.keyspace = None
        self.routing_key = None
        if self.custom_payload:
            self.custom_payload.clear()