Sent by the scheduler to explicitly decline offer(s) received. Note that this is same as sending an
ACCEPT call with no operations.

@param offerIds
353799
public void decline(List<OfferID> offerIds) {
    Builder decline = build().setDecline(Decline.newBuilder().addAllOfferIds(offerIds));
    sendCall(decline, Type.DECLINE);
  }
85757
@Override
  public final boolean offer(final M value, 
                             final long timeout, 
                             final TimeUnit unit)
  {
    Objects.requireNonNull(value);
    
    // completePoll();
    
    //final AtomicLong headRef = _headRef;
    //final AtomicLong tailRef = _tail;
    //final int capacity = _capacity;
    
    while (true) {
      // final AtomicReferenceArray<T> ring = _ring;
      final long tail = _tailRef.get();
      final long head = _headRef.get();
      final long nextHead = head + 1;

      if (nextHead - tail < _capacity) {
        _ring.setLazy(head, value);
        _headRef.lazySet(nextHead);

        return true;
      }
      else {
        long offerSequence = _blocker.nextOfferSequence();
        
        if (_capacity <= head + 1 - tail
            && ! _blocker.offerWait(offerSequence, timeout, unit)) {
          return false;
        }
      }
    }
  }
620161
def receive_accept(self, msg):
        '''
        
        '''
        if self.promised_id is None or msg.proposal_id >= self.promised_id:
            self.promised_id = msg.proposal_id
            self.accepted_id = msg.proposal_id
            self.accepted_value = msg.proposal_value
            return Accepted(self.network_uid, msg.proposal_id, msg.proposal_value)
        else:
            return Nack(self.network_uid, msg.from_uid, msg.proposal_id, self.promised_id)
207922
public void delete(Offer offer, boolean removeWithSubscriptions) {
        ParameterMap<String, String> params = new ParameterMap<String, String>();
        params.add("remove_with_subscriptions", String.valueOf(removeWithSubscriptions));
        RestfulUtils.delete(OfferService.PATH, offer, params, Offer.class, super.httpClient);
    }
932172
public void setServiceIds(java.util.Collection<ServiceId> serviceIds) {
        if (serviceIds == null) {
            this.serviceIds = null;
            return;
        }

        this.serviceIds = new java.util.ArrayList<ServiceId>(serviceIds);
    }
532252
func (offers Index) IDs() []mesos.OfferID {
	ids := make([]mesos.OfferID, 0, len(offers))
	for _, offer := range offers {
		ids = append(ids, offer.GetID())
	}
	return ids
}
87994
def reject(self, *, requeue=True):
        
        self.sender.send_BasicReject(self.delivery_tag, requeue)
697125
@Override
  public final boolean offer(final M value, 
                             final long timeout, 
                             final TimeUnit unit)
  {
    Objects.requireNonNull(value);
    
    // completePoll();
    
    final AtomicLong headRef = _headRef;
    final AtomicLong tailRef = _tail;
    final int capacity = _capacity;
    
    while (true) {
      // final AtomicReferenceArray<T> ring = _ring;
      final long tail = tailRef.get();
      final long head = headRef.get();
      final long nextHead = head + 1;

      if (nextHead - tail < capacity) {
        _ring.setLazy(head, value);
        headRef.lazySet(nextHead);

        return true;
      }
      else {
        long offerSequence = _blocker.nextOfferSequence();
        
        if (capacity <= headRef.get() + 1 - tailRef.get()
            && ! _blocker.offerWait(offerSequence, timeout, unit)) {
          return false;
        }
      }
    }
  }
271436
@Override
    public boolean offer(final WaitStrategy.Offerable o) throws InterruptedException {
        double currentBackoff = backoffNanos;
        while (!o.offer()) {
            LockSupport.parkNanos((long) currentBackoff);
            currentBackoff = currentBackoff * coefficient;

        }
        return true;
    }
53748
public void setPullRequestIds(java.util.Collection<String> pullRequestIds) {
        if (pullRequestIds == null) {
            this.pullRequestIds = null;
            return;
        }

        this.pullRequestIds = new java.util.ArrayList<String>(pullRequestIds);
    }
1257871
def complete_offer(self, offer_id, complete_dict):
        
        return self._create_put_request(
            resource=OFFERS,
            billomat_id=offer_id,
            command=COMPLETE,
            send_data=complete_dict
        )
580220
def _action_remove(self, ids):
        
        return self._action_get((self.unlisten_to_node(id_) for id_ in ids))
1297278
function rejectAll(requests, error) {
  for (const request of requests) {
    request.abort();
    request.reject(error);
  }
}
1176064
private void offerSlotsToJobManager(final JobID jobId) {
		final JobManagerConnection jobManagerConnection = jobManagerTable.get(jobId);

		if (jobManagerConnection == null) {
			log.debug("There is no job manager connection to the leader of job {}.", jobId);
		} else {
			if (taskSlotTable.hasAllocatedSlots(jobId)) {
				log.info("Offer reserved slots to the leader of job {}.", jobId);

				final JobMasterGateway jobMasterGateway = jobManagerConnection.getJobManagerGateway();

				final Iterator<TaskSlot> reservedSlotsIterator = taskSlotTable.getAllocatedSlots(jobId);
				final JobMasterId jobMasterId = jobManagerConnection.getJobMasterId();

				final Collection<SlotOffer> reservedSlots = new HashSet<>(2);

				while (reservedSlotsIterator.hasNext()) {
					SlotOffer offer = reservedSlotsIterator.next().generateSlotOffer();
					reservedSlots.add(offer);
				}

				CompletableFuture<Collection<SlotOffer>> acceptedSlotsFuture = jobMasterGateway.offerSlots(
					getResourceID(),
					reservedSlots,
					taskManagerConfiguration.getTimeout());

				acceptedSlotsFuture.whenCompleteAsync(
					(Iterable<SlotOffer> acceptedSlots, Throwable throwable) -> {
						if (throwable != null) {
							if (throwable instanceof TimeoutException) {
								log.info("Slot offering to JobManager did not finish in time. Retrying the slot offering.");
								// We ran into a timeout. Try again.
								offerSlotsToJobManager(jobId);
							} else {
								log.warn("Slot offering to JobManager failed. Freeing the slots " +
									"and returning them to the ResourceManager.", throwable);

								// We encountered an exception. Free the slots and return them to the RM.
								for (SlotOffer reservedSlot: reservedSlots) {
									freeSlotInternal(reservedSlot.getAllocationId(), throwable);
								}
							}
						} else {
							// check if the response is still valid
							if (isJobManagerConnectionValid(jobId, jobMasterId)) {
								// mark accepted slots active
								for (SlotOffer acceptedSlot : acceptedSlots) {
									try {
										if (!taskSlotTable.markSlotActive(acceptedSlot.getAllocationId())) {
											// the slot is either free or releasing at the moment
											final String message = "Could not mark slot " + jobId + " active.";
											log.debug(message);
											jobMasterGateway.failSlot(
												getResourceID(),
												acceptedSlot.getAllocationId(),
												new FlinkException(message));
										}
									} catch (SlotNotFoundException e) {
										final String message = "Could not mark slot " + jobId + " active.";
										jobMasterGateway.failSlot(
											getResourceID(),
											acceptedSlot.getAllocationId(),
											new FlinkException(message));
									}

									reservedSlots.remove(acceptedSlot);
								}

								final Exception e = new Exception("The slot was rejected by the JobManager.");

								for (SlotOffer rejectedSlot : reservedSlots) {
									freeSlotInternal(rejectedSlot.getAllocationId(), e);
								}
							} else {
								// discard the response since there is a new leader for the job
								log.debug("Discard offer slot response since there is a new leader " +
									"for the job {}.", jobId);
							}
						}
					},
					getMainThreadExecutor());

			} else {
				log.debug("There are no unassigned slots for the job {}.", jobId);
			}
		}
	}
335678
def reject(self):
        """"""
        if not self.is_fade_running():
            key = Qt.Key_Escape
            self.key_pressed = key
            self.sig_key_pressed.emit()
762307
@Override
  public ArrayModifiableDBIDs order(DBIDs ids) {
    ArrayModifiableDBIDs res = DBIDUtil.newArray(ids.size());
    for(DBIDIter it = this.ids.iter(); it.valid(); it.advance()) {
      if(ids.contains(it)) {
        res.add(it);
      }
    }
    return res;
  }
848775
public void invalidateLookupCacheEntries(Set<ChannelID> channelIDs) {
		for (ChannelID id : channelIDs) {
			this.receiverCache.remove(id);
		}
	}