Put the item in the best location available in the hash table.
761551
private void refillEntry(int baseHash)
  {
    K key = _keys[baseHash];
    V value = _values[baseHash];

    _keys[baseHash] = null;
    _values[baseHash] = null;

    int hash = key.hashCode() & _mask;

    for (int count = _size; count >= 0; count--) {
      if (_values[hash] == null) {
        _keys[hash] = key;
        _values[hash] = value;
        return;
      }

      hash = (hash + 1) & _mask;
    }
  }
71551
def _put(self, item: SQLBaseObject):
        """"""
        if item._dto_type in self._expirations and self._expirations[item._dto_type] == 0:
            # The expiration time has been set to 0 -> shoud not be cached
            return
        item.updated()
        self._session().merge(item)
522914
def add_hashed_value(self, hash_value, store_key):
        
        if self._unique and hash_value in self._index:
            raise NonUnique('Hash value {} already in index'.format(hash_value))
        if store_key not in self._index[hash_value]:
            self._index[hash_value].append(store_key)
        if hash_value not in self._reverse_index[store_key]:
            self._reverse_index[store_key].append(hash_value)
500461
def _position_for_dispense(self, location=None, clearance=0.5):
        

        if location:
            if isinstance(location, Placeable):
                location = location.bottom(min(location.z_size(), clearance))
            self.move_to(location)
70550
def put(key, value)
    value = value.to_f
    @input_values[key] = value
    @smallest_seen_values[key] ||= 0.0
    if @largest_seen_values[key] == nil or @smallest_seen_values[key] > @largest_seen_values[key]
      @largest_seen_values[key] = @smallest_seen_values[key] + 1.0
    end
    @smallest_seen_values[key] = value if value < @smallest_seen_values[key]
    @largest_seen_values[key] = value if value > @largest_seen_values[key]
  end
583654
def move_to_top(self):
        """"""
        self.current_item = self.root
        for f in self._hooks["top"]:
            f(self)
        return self
1158070
def insert(self, item, priority):
        
        heappush(self.heap, HeapItem(item, priority))
668149
def move(self, place, distance = 1):
        """"""
        for d in range(distance):
            self.stream.write(self._get_cap('move '+place))
        self.flush()
1002256
void setRehashFlag(long location)
                    throws IOException,
                    EOFException {
        rehashInProgress = location;
        filemgr.seek(rehashOffset);
        filemgr.writeLong(location);
    }
725408
def place_objects(self):
        """"""
        pos_arr, quat_arr = self.initializer.sample()
        for k, obj_name in enumerate(self.objects):
            self.objects[obj_name].set("pos", array_to_string(pos_arr[k]))
            self.objects[obj_name].set("quat", array_to_string(quat_arr[k]))
923033
def put(self, item, block=True, timeout=None):
        """"""
        return self._queue.put(item, block, timeout)
866792
def insert_right(self, item):
        ''
        k = self._key(item)
        i = bisect_right(self._keys, k)
        self._keys.insert(i, k)
        self._items.insert(i, item)
370721
def put( key, value )
    key = normalize_key( key )
    setter = "#{key}=".to_sym

    if respond_to?( setter )
      send( setter, value )
    else
      @hash[ key ] = value
    end
  end
748391
def _flush_puts(self, items, options):
    """"""
    datastore.Put(items, config=self._create_config(options))
33466
def add(self, item, position=5):
        
        if item in self.items:
            return
        self.items[item] = position
        self._add_dep(item)
        self.order = None
        self.changed(code_changed=True)
144786
def modifyInPlace(self, *, sort=None, purge=False, done=None):
        """"""
        self.data = self.modify(sort=sort, purge=purge, done=done)
199783
def put(self, item, block=True, timeout=None):
        
        if self.maxsize <= 0:
            self.actor.put.remote(item)
        elif not block:
            if not ray.get(self.actor.put.remote(item)):
                raise Full
        elif timeout is None:
            # Polling
            # Use a not_full condition variable or promise?
            while not ray.get(self.actor.put.remote(item)):
                # Consider adding time.sleep here
                pass
        elif timeout < 0:
            raise ValueError("'timeout' must be a non-negative number")
        else:
            endtime = time.time() + timeout
            # Polling
            # Use a condition variable or switch to promise?
            success = False
            while not success and time.time() < endtime:
                success = ray.get(self.actor.put.remote(item))
            if not success:
                raise Full