So, we only override offer().
178147
@Override
	public boolean offer( Message e ) {

		boolean result = super.offer( e );
		if( result ) {
			this.receivedMessagesCount.incrementAndGet();
			this.timestampOfLastReceivedMessage.set( new Date().getTime());
		}

		return result;
	}
1154513
def cancel_offer(self, offer_id):
        
        return self._create_put_request(
            resource=OFFERS,
            billomat_id=offer_id,
            command=CANCEL,
        )
237490
static AssignmentService override(AssignmentStrategy strategy) {
        Holder.INSTANCE.setAssignmentService(new AssignmentServiceImpl(strategy)); 
        
        return get();
    }
1256938
public void removeOverride(String operation) {
        if (this.overrideOnce.containsKey(operation) == true) {
            this.overrideOnce.remove(operation);
        }

        if (this.override.containsKey(operation) == true) {
            this.override.remove(operation);
        }
    }
1291919
@Override
    public boolean offer(E e) {
        Objects.requireNonNull(e);

        boolean notEmpty = false;
        _tailLock.lock(); // Size cannot grow... only shrink
        try {
            int size = _size.get();
            if (size >= _maxCapacity)
                return false;

            // Should we expand array?
            if (size == _elements.length) {
                _headLock.lock();
                try {
                    if (!grow())
                        return false;
                } finally {
                    _headLock.unlock();
                }
            }

            // Re-read head and tail after a possible grow
            int tail = _indexes[TAIL_OFFSET];
            _elements[tail] = e;
            _indexes[TAIL_OFFSET] = (tail + 1) % _elements.length;
            notEmpty = _size.getAndIncrement() == 0;
        } finally {
            _tailLock.unlock();
        }

        if (notEmpty) {
            _headLock.lock();
            try {
                _notEmpty.signal();
            } finally {
                _headLock.unlock();
            }
        }

        return true;
    }
391479
def reject(self):
        """"""
        self.stochastic.revert()

        # Increment rejected count
        self.rejected[self.current_kernel] += 1

        if self.verbose > 1:
            print_(
                self._id,
                "rejected, reverting to value =",
                self.stochastic.value)
654410
function () {
			
			var i, length;
			
			for (i = 0, length = this.choicesList.length; i < length; i += 1) {
				this.disableChoice(this.choicesList[i], false);
			}
			
		}
4244
def override(self, value):
        """"""
        if self._value is not value:
            return _ScopedValueOverrideContext(self, value)
        else:
            return empty_context
1200116
def ReplaceOffer(self, offer_link, offer):
        
        CosmosClient.__ValidateResource(offer)
        path = base.GetPathFromLink(offer_link)
        offer_id = base.GetResourceIdOrFullNameFromLink(offer_link)
        return self.Replace(offer, path, 'offers', offer_id, None, None)
846809
function overrideCheck(msg) {
      if (msg.srclang){
        var langCode = payloadutils.langTransToSTTFormat(msg.srclang);
        config.lang = langCode;
      }
      return Promise.resolve();
    }
683220
static void setOverrideNotificationReceipt(Boolean value) {
        if (value == null) {
            remove(OVERRIDE_NOTIFICATION_RECEIPT_PREF_NAME);
        } else {
            putBoolean(OVERRIDE_NOTIFICATION_RECEIPT_PREF_NAME, value);
        }
    }
495362
public boolean offer(E e) {
        final Node<E> newNode = newNode(Objects.requireNonNull(e));

        for (Node<E> t = tail, p = t;;) {
            Node<E> q = p.next;
            if (q == null) {
                // p is last node
                if (casNext(p, null, newNode)) {
                    // Successful CAS is the linearization point
                    // for e to become an element of this queue,
                    // and for newNode to become "live".
                    if (p != t) // hop two nodes at a time
                        casTail(t, newNode);  // Failure is OK.
                    return true;
                }
                // Lost CAS race to another thread; re-read next
            }
            else if (sentinel() == q)
                // We have fallen off list.  If tail is unchanged, it
                // will also be off-list, in which case we need to
                // jump to head, from which all live nodes are always
                // reachable.  Else the new tail is a better bet.
                p = (t != (t = tail)) ? t : head;
            else
                // Check for tail updates after two hops.
                p = (p != t && t != (t = tail)) ? t : q;
        }
    }
1281924
def sent_request(self, value):
        
        if value == self._defaults['sentRequest'] and 'sentRequest' in self._values:
            del self._values['sentRequest']
        else:
            self._values['sentRequest'] = value
161796
def modify(self, **kwargs):
        """"""
        self._check_exclusive_parameters(**kwargs)
        return super(Rule, self)._modify(**kwargs)
192675
function(reject) {
      let index = _.indexOf(this.deferred, reject);
      if (index >= 0) {
        this.deferred.splice(index, 1);
      }
    }
1227710
@Override
    public final boolean offer(T e, long timeout, TimeUnit unit) throws InterruptedException {
        final Queue<T> queue = this.getOrCreateQueue(e);

        final long start = getWriteLockWithOptionalWait(timeout, unit);
        if (start == Long.MIN_VALUE) {
            // Min value signals a timeout while waiting
            return false;
        }
        final long maxWait = start >= 0 ? unit.toMillis(timeout) : -1;

        try {
            if (!this.waitForRemove(start, maxWait)) {
                return false;
            }

            final boolean added = queue.add(e);
            if (added) {
                this.size++;
                this.notEmpty.signal();
            }
            return added;
        } finally {
            this.writeLock.unlock();
        }
    }
198597
def typed_override(criterion, operator)
      if criterion
        criterion.update_values do |value|
          yield(value)
        end
      end
      __override__(criterion, operator)
    end