can be filled again.
428331
public RString restartGroup(String what) {
    List<Placeholder> all = _placeholders.get(what);
    assert all.size() == 1;

    Placeholder result = all.get(0);
    if( result.group == null ) {
      throw new NoSuchElementException("Element " + what + " is not a group.");
    }
    result.group.clear();
    return result.group;
  }
722767
def reset(self, populations, lag, mu, u_int, j_coup, mean_f):
        """"""

        self.set_filling(populations)
        self.param['lambda'] = lag
        self.param['orbital_e'] = mu
        self.selfconsistency(u_int, j_coup, mean_f)
809116
def _fill_cache(self):
        """"""
        for irow in range(len(self._table)):
            file_handle = self._make_file_handle(irow)
            self._cache[file_handle.path] = file_handle
249602
def _maybe_fill(arr, fill_value=np.nan):
    
    if _isna_compat(arr, fill_value):
        arr.fill(fill_value)
    return arr
538718
public int fillAll(RingByteBuffer ring) throws IOException, InterruptedException
    {
        if (ring.marked() > capacity)
        {
            throw new IllegalArgumentException("marked > capacity");
        }
        fillLock.lock();
        try
        {
            fillSync.waitUntil(()->ring.marked()<=free());
            return fill(ring);
        }
        finally
        {
            fillLock.unlock();
        }
    }
594716
protected function fill()
    {
        $readFilterCallback = $this->readFilterCallback;
        $this->buffer .= $readFilterCallback($this->stream->read(self::BUFFER_SIZE));

        if ($this->stream->eof()) {
            $this->buffer .= $readFilterCallback();
        }
    }
299490
protected function fillOnce()
    {
        $payload = $this->payload();

        if (is_array($payload)) {
            return $this->fillAttributes($payload);
        }

        if ($payload instanceof Arrayable) {
            return $this->fillAttributes($payload->toArray());
        }

        if ($payload instanceof \Traversable) {
            return $this->fillAttributes(iterator_to_array($payload));
        }

        if ($payload instanceof \stdClass) {
            return $this->fillAttributes(json_decode(json_encode($payload), true));
        }

        return $this->fillAttributes([]);
    }
985039
private void internalFillPool(FillRequest fr)
   {
      if (this.threadStarted.compareAndSet(false, true))         
      {
         this.fillerThread.start();
      }
      
      synchronized (pools)
      {
         if (!pools.contains(fr))
         {
            pools.addLast(fr);
            pools.notifyAll();
         }
      }
   }
528634
def refresh(self):
        
        if self.exists:
            self.delete()
        self.populate()
        self.open()
964207
private function fill() {

        //Prefill value
        if(true === $this -> filled) {

            if(true === isset($this -> attributes['name'])) {

                if(true === Request :: isPost()) {
                    $this -> attributes['value'] = Request :: fromPost($this -> attributes['name']);
                }
            }
        }
    }
144718
def fill_out_and_submit(self, data, prefix='', skip_reset=False):
        
        self.fill_out(data, prefix, skip_reset)
        self.submit()
958886
void refresh() {
    int pos = 0;
    for (final T item : backing) {
      if (pos < size()) {
        set(pos, item);
      } else {
        assert pos == size();
        add(pos, item);
      }
      pos++;
    }
    while (backing.size() < size()) {
      remove(size() - 1);
    }
    assert backing.size() == size();
    assert backing.equals(workingCopy);
  }
540339
public void fill(Rectangle clip, IntBiPredicate isInside, int replacement)
    {
        fill(clip.x, clip.y, clip.x+clip.width, clip.y+clip.height, isInside, (x,y)->replacement);
    }
701784
def resize_to_fill(ncols, nrows = nil, gravity = CenterGravity)
      copy.resize_to_fill!(ncols, nrows, gravity)
    end
455794
private function canRetry()
    {
        if ($this->isUnlimitedAttempts()) {
            return true;
        }

        $this->attempts++;

        return $this->attempts < $this->maxAttempts;
    }
211074
def put(self, item, **kwargs):
        """"""
        if self.full():
            raise Full()
        self._append(item)
218951
function arrfill(arr, fill) {
  var ind=0, replace = function(i){ return i===undefined ? fill[ind++] : i }
  return _.map(arr, replace).concat(_slice.call(fill, ind))
}