Flushes the source attributes
427774
protected function flushSources()
    {
        foreach ($this->translations as $translation)
        {
            $translation->source->delete();
            $translation->flushTemporarySource();

            unset($translation->relations['source']);
        }
    }
57574
def _flush(self, buffer):
        
        container, obj = self._client_args
        with _handle_client_exception():
            self._client.put_object(container, obj, buffer)
846954
def flush(self):
        """"""
        writer = self.writer
        if writer is None:
            raise GaugedUseAfterFreeError
        self.flush_writer_position()
        keys = self.translate_keys()
        blocks = []
        current_block = self.current_block
        statistics = self.statistics
        driver = self.driver
        flags = 0  # for future extensions, e.g. block compression
        for namespace, key, block in self.pending_blocks():
            length = block.byte_length()
            if not length:
                continue
            key_id = keys[(namespace, key)]
            statistics[namespace].byte_count += length
            blocks.append((namespace, current_block, key_id, block.buffer(),
                           flags))
        if self.config.overwrite_blocks:
            driver.replace_blocks(blocks)
        else:
            driver.insert_or_append_blocks(blocks)
            if not Gauged.writer_flush_maps(writer, True):
                raise MemoryError
        update_namespace = driver.add_namespace_statistics
        for namespace, stats in statistics.iteritems():
            update_namespace(namespace, self.current_block,
                             stats.data_points, stats.byte_count)
        statistics.clear()
        driver.commit()
        self.flush_now = False
1185854
protected void flushData()
    {
        try
        {
            out.write(buffer, 0, validBufferBytes);
            lastFlushOffset += validBufferBytes;
        }
        catch (IOException e)
        {
            throw new FSWriteError(e, getPath());
        }
        if (runPostFlush != null)
            runPostFlush.run();
    }
245040
def _flush(self):
        
        with open(self.metadata_file, 'w') as f:
            json.dump(self.metadata, f)
850569
public function flush() {
		$specRawer = new SpecRawer($this->attributes);
		$specRawer->rawTypes($this->eiTypeExtractions, $this->customTypeExtractions);
		$specRawer->rawEiMasks($this->eiTypeExtensionExtractionGroups);
		$specRawer->rawEiModificatorExtractionGroups($this->eiModificatorExtractionGroups);
		$specRawer->rawLaunchPads($this->launchPadExtractions);
		
		$this->configSource->writeArray($this->attributes->toArray());
	}
264544
def _flush(self, buffer):
        
        with _handle_oss_error():
            self._bucket.put_object(key=self._key, data=buffer.tobytes())
1093610
def flush(now)
      if now || @entries.length > WATERMARK
        @entries.each do |e|
          if e.modified
            e.obj.save
            e.modified = false
          end
        end

        # Delete all but the first WATERMARK entry.
        @entries = @entries[0..WATERMARK - 1] if @entries.length > WATERMARK
      end
    end
936617
def flush(self):
        

        self.clear()
        self.delete(self.session_key)
        self.create()
1059051
public void flush()
  {
    int level = getLevel().intValue();
    
    for (int i = 0; i < _handlers.length; i++) {
      Handler handler = _handlers[i];

      if (level <= handler.getLevel().intValue())
        handler.flush();
    }
  }
322193
def flush(**kwargs):
    

    expression = lambda target, table: target.execute(table.delete())
    test = lambda target, table: not table.exists(target)
    op(expression, reversed(metadata.sorted_tables), test=test,
       primary='flush', secondary='flush', **kwargs)
696212
def flush(self):
        """"""
        if self._wbuf:
            buffer = ''.join(self._wbuf)
            self._wbuf = []
            self.write(buffer)
353046
def _flush(self):
        """"""
        self._buffer.sort()
        self._replace_batch()
        self._buffer = []
        self._compress()
1202415
def flush(self):
        """"""
        now = time.time()
        to_remove = []
        for k, entry in self.pool.items():
            if entry.timestamp < now:
                entry.client.close()
                to_remove.append(k)
        for k in to_remove:
            del self.pool[k]
284935
public void flush() {
    lock.writeLock().lock();
    try {
      OMMapBufferEntry entry;
      for (Iterator<OMMapBufferEntry> it = bufferPoolLRU.iterator(); it.hasNext();) {
        entry = it.next();
        if (entry.file != null && entry.file.isClosed()) {
          if (removeEntry(entry))
            it.remove();
        }
      }
    } finally {
      lock.writeLock().unlock();
    }
  }
341183
def flush(self):
        
        if not self.nostdout:
            self.stdout.flush()
        if self.file is not None:
            self.file.flush()
809484
def flush(self, meta=None):
        ''''''
        pattern = self.basekey(meta) if meta else self.namespace
        return self.client.delpattern('%s*' % pattern)