Flush the node operations to the database.

 @api private

 @example Flush the operations.
   node.flush([ command ])

 @param [ Array<Message> ] ops The operations to flush.

 @return [ Object ] The result of the operations.

 @since 2.0.0
512531
def flush(ops = queue)
      operations, callbacks = ops.transpose
      logging(operations) do
        ensure_connected do |conn|
          conn.write(operations)
          replies = conn.receive_replies(operations)

          replies.zip(callbacks).map do |reply, callback|
            callback ? callback[reply] : reply
          end.last
        end
      end
    ensure
      ops.clear
    end
473454
def to_operations
      cloned = Marshal.load Marshal.dump(operations)
      operations.each do |op|
        op.source_account ||= self.source_account
      end
    end
411846
void doFlush()
    {
        enableFlush = true;
        flush();
        execute();
        enableFlush = false;
        flushManager.commit();
        flushManager.clearFlushStack();
    }
1005788
public final void insertOp(Operation op) {
    ArrayList<Operation> tmp = new ArrayList<Operation>(inputQueue.size() + 1);
    tmp.add(op);
    inputQueue.drainTo(tmp);
    inputQueue.addAll(tmp);
  }
978571
def flushdb(self, async_op=False):
        
        if async_op:
            fut = self.execute(b'FLUSHDB', b'ASYNC')
        else:
            fut = self.execute(b'FLUSHDB')
        return wait_ok(fut)
375621
def flush(now = false)
      if now || (@flush_counter -= 1) <= 0
        @modified_entries.each do |id, object|
          object.save
        end
        @modified_entries = ::Hash.new
        @flush_counter = @flush_delay
      end
      @flush_times += 1
    end
1123722
def flush(self):
    """"""
    self.puts.flush()
    self.deletes.flush()
    self.ndb_puts.flush()
    self.ndb_deletes.flush()
62415
protected void flushObjects ()
    {
        long now = System.currentTimeMillis();
        for (Iterator<IntMap.IntEntry<FlushRecord>> iter = _flushes.intEntrySet().iterator();
             iter.hasNext(); ) {
            IntMap.IntEntry<FlushRecord> entry = iter.next();
//             int oid = entry.getIntKey();
            FlushRecord rec = entry.getValue();
            if (rec.expire <= now) {
                iter.remove();
                flushObject(rec.object);
//                 Log.info("Flushed object " + oid + ".");
            }
        }
    }
1028056
def flush_cache
      Rails.cache.delete([self.class.name, symbol_was.to_s])
      Rails.cache.delete([self.class.name, id])
    end
1035650
def flush
      return self if @buffer.empty?

      ary = nil
      sync {
        ary = @buffer.dup
        @buffer.clear
      }

      if ary.length <= write_size
        str = ary.join
        canonical_write str unless str.empty?
      else
        ary.each_slice(write_size) do |a|
          str = a.join
          canonical_write str unless str.empty?
        end
      end

      self
    end
314431
def flush_jobs
      # Get all the jobs, one at a time, pulling from the list
      while job = self.cached_jobs.shift
        # Map the array to the right things
        job_id, args = *job
        # Submit! takes care of rescuing, error logging, etc and never caches
        submit! args, job_id
      end
      self
    end
665060
def poll(self):
        
        if self.complete:
            raise ValueError("The operation has completed.")

        operation_pb = self._get_operation()
        self._update_state(operation_pb)

        return self.complete
658285
def flushall(self, asynchronous=False):
        
        args = []
        if asynchronous:
            args.append(Token.get_token('ASYNC'))
        return self.execute_command('FLUSHALL', *args)
172791
def build_operation_chain(stack)
      empty_op = EmptyOperation.new(nil)

      stack.reverse.reduce(empty_op) do |next_op, current_op|
        klass, args, block = current_op

        if Class === klass
          klass.new(next_op, *args, &block)
        elsif Proc === klass
          lambda do |env|
            next_op.call(klass.call(env, *args))
          end
        else
          raise StandardError, "Invalid operation, doesn't respond to `call`: #{klass.inspect}"
        end
      end
    end
292205
def flush
      return self if @buffer.empty?

      str = nil
      sync {
        str = @buffer.join
        @buffer.clear
      }

      canonical_write str unless str.empty?
      self
    end
369445
def flush(self):
        
        chunks = []
        chunks.append(self._compress(b'', lib.BROTLI_OPERATION_FLUSH))

        while lib.BrotliEncoderHasMoreOutput(self._encoder) == lib.BROTLI_TRUE:
            chunks.append(self._compress(b'', lib.BROTLI_OPERATION_FLUSH))

        return b''.join(chunks)
1026698
def doFlush(self, cname, flushExpression, flushType):
        
        return self.client.service.doFlush(
            cname, flushExpression, flushType)