Update the priority of the file handle. The element is first
        removed and then added to the left of the deque.
503863
def _update(self, dataFile, handle):
        
        self._cache.remove((dataFile, handle))
        self._add(dataFile, handle)
1166528
def prioritize(self, item, force=False):
        
        with self.condition:
            # If the job is already running (or about to be forced),
            # there is nothing to be done.
            if item in self.working or item in self.force:
                return
            self.queue.remove(item)
            if force:
                self.force.append(item)
            else:
                self.queue.appendleft(item)
            self.condition.notify_all()
335628
def reorder(self, handle, low_value):
        
        return lib.zlistx_reorder(self._as_parameter_, handle, low_value)
557525
private void performInitialCleanup() {
        listeEinsortieren.removeIf(f -> !f.arr[DatenFilm.FILM_URL].toLowerCase().startsWith("http"));
        listeEinsortieren.removeIf(f -> {
            String groesse = f.arr[DatenFilm.FILM_GROESSE];
            if (groesse.isEmpty())
                return false;
            else {
                return Long.parseLong(groesse) < MIN_SIZE_ADD_OLD;
            }

        });
    }
36061
function (target) {
        if (!target) {
            return
        }
        var id = target.id,
            elementUpdate = this.hashForUpdates[id]
        if (elementUpdate) {
            // Remove from updates list
            if (elementUpdate.priority === 0) {
                this.updates0.splice(this.updates0.indexOf(elementUpdate), 1)
            } else if (elementUpdate.priority < 0) {
                this.updatesNeg.splice(this.updatesNeg.indexOf(elementUpdate), 1)
            } else /* priority > 0 */{
                this.updatesPos.splice(this.updatesPos.indexOf(elementUpdate), 1)
            }
        }
        // Release HashMethodEntry object
        this.hashForUpdates[id] = null
    }
802555
void remove(T obj) {
        _queue.remove(obj);
        if (_prioritize == obj) {
            _prioritize = null;
        }
    }
51138
private function fixSorting(): void
    {
        $fixer = $this->file->getFixer();

        $fixer->beginChangeset();

        $firstTag = $this->removeOldTagLines();

        $fixer->addContent($firstTag['pointer'] - 1, $this->createNewSortedTagsContent());

        $fixer->endChangeset();
    }
1323501
public void processQueue(
      Predicate<RequestHandler> handlerConsumer,
      Prioritizer prioritizer) {

    Comparator<RequestHandler> comparator =
        prioritizer == null ?
        Ordering.allEqual()::compare :
        (a, b) -> prioritizer.compareTo(
            a.getRequest().getDesiredCapabilities(), b.getRequest().getDesiredCapabilities());

    lock.writeLock().lock();
    try {

      newSessionRequests.stream()
          .sorted(comparator)
          .filter(handlerConsumer)
          .forEach(requestHandler -> {
            if (!removeNewSessionRequest(requestHandler)) {
              log.severe("Bug removing request " + requestHandler);
            }
          });
    } finally {
      lock.writeLock().unlock();
    }
  }
578770
function (layer, props) {
		if (props.handle || objectContainsPathCoords(props)) {
			// Add handles if handle property was added
			removeHandles(layer);
			addHandles(layer);
		} else if (props.handle === null) {
			removeHandles(layer);
		}
		if (isRectLayer(layer)) {
			// If width/height was changed
			if (props.width !== undefined || props.height !== undefined || props.x !== undefined || props.y !== undefined) {
				// Update handle positions
				updateRectHandles(layer);
			}
		} else if (isPathLayer(layer)) {
			updatePathHandles(layer);
		}

	}
894791
function update () {
      sourceOrOptions.bundle()
        .pipe(concat(function (data) {
          add(filepath, data.toString())
        }))
        .on('error', function (err) {
          console.error(err.stack)
          ASSET_PENDING--
        })
    }
172200
public boolean updateLevelPriority()
    {
        Priority newPriority = taskHandle.getPriority();
        Priority oldPriority = priority.getAndSet(newPriority);
        return newPriority.getLevel() != oldPriority.getLevel();
    }
432874
public void setPriority (byte priority)
    {
        info.priority = (byte)Math.max(
            Byte.MIN_VALUE, Math.min(Byte.MAX_VALUE, priority));
    }
1151442
private void updateRemove()
    {
        if (willDelete)
        {
            for (final Integer id : toDelete)
            {
                final Featurable featurable = featurables.get(id);
                for (final HandlerListener listener : listeners)
                {
                    listener.notifyHandlableRemoved(featurable);
                }
                featurable.getFeature(Identifiable.class).notifyDestroyed();
                featurables.remove(featurable, id);
            }
            toDelete.clear();
            willDelete = false;
        }
    }
1156119
public final void put(long priority, Object value)
  {
//    if (tc.isEntryEnabled())
//      SibTr.entry(tc, "put", new Object[] { new Long(priority), value});

    PriorityQueueNode node = new PriorityQueueNode(priority,value);

    // Resize the array (double it) if we are out of space.
    if (size == elements.length)
    {
      PriorityQueueNode[] tmp = new PriorityQueueNode[2*size];
      System.arraycopy(elements,0,tmp,0,size);
      elements = tmp;
    }

    int pos = size++;
    setElement(node, pos);

    moveUp(pos);

//    if (tc.isEntryEnabled())
//      SibTr.exit(tc, "put");
  }
479364
def add_element(self, priority, element, count=None):
        
        if count is None:
            count = next(self.counter)
        entry = [priority, count, element]
        self.element_finder[element] = entry
        heapq.heappush(self.pq, entry)
660903
def setPriority(self, queue, priority):
        '''
        
        '''
        q = self.queueindex[queue]
        self.queues[q[0]].removeSubQueue(q[1])
        newPriority = self.queues.setdefault(priority, CBQueue.MultiQueue(self, priority))
        q[0] = priority
        newPriority.addSubQueue(q[1])
1259505
function addJobAtHeadOfPriority(node, priority) {
        var marker = markerFromPriority(priority);
        if (marker.priority > highWaterMark) {
            highWaterMark = marker.priority;
            immediateYield = true;
        }
        marker._insertJobAfter(node);
    }