Write the formatted format pieces in order, applying a delay
            between characters for the text only.
541470
def write_char_delay(self, ctl, delay):
        
        for i, fmt in enumerate(self.fmt):
            if '{text' in fmt:
                # The text will use a write delay.
                ctl.text(fmt.format(text=self.text))
                if i != (self.fmt_len - 1):
                    ctl.text(self.join_str)
                ctl.write(
                    file=self.file,
                    delay=delay
                )
            else:
                # Anything else is written with no delay.
                ctl.text(fmt.format(
                    frame=self.frames[self.current_frame],
                    elapsed=self.elapsed
                ))
                if i != (self.fmt_len - 1):
                    # Add the join_str to pieces, except the last piece.
                    ctl.text(self.join_str)
                ctl.write(file=self.file)
        return ctl
1254469
def write(message, priority=Priority.INFO):
    

    priority = int(Priority(int(priority)))

    send(priority=priority, message=message)
506285
public void write(String text, int offset, int length) {
        buffer.append(text, offset, offset + length);
    }
66549
def _Write(self, data, length, progress_callback=None):
        """"""
        if progress_callback:
            progress = self._HandleProgress(length, progress_callback)
            next(progress)
        while length:
            tmp = data.read(self.chunk_kb * 1024)
            length -= len(tmp)
            self.usb.BulkWrite(tmp)

            if progress_callback and progress:
                progress.send(len(tmp))
807338
def _write_separator(self):
        
        tmp = self._page_width - ((4 * self.__indent_level) + 2)
        self._write_line('# ' + ('-' * tmp))
447429
def format(self, parts):
        
        text = self.storage.state_separator.join(parts)
        return self.formatter(text)
793531
def write(self):
        
        if self.text is None:
            # Text has not been sent through the pipe yet.
            # Do not write anything until it is set to non-None value.
            return None
        if self._last_text == self.text:
            char_delay = 0
        else:
            char_delay = self.char_delay
            self._last_text = self.text
        with self.lock:
            ctl = Control().move_column(1).pos_save().erase_line()
            if char_delay == 0:
                ctl.text(str(self)).write(file=self.file)
            else:
                self.write_char_delay(ctl, char_delay)
            ctl.delay(self.delay)
        return None
528741
function rewriteDuration() {
                var
                    buffer = new ArrayBufferDataStream(8),
                    oldPos = blobBuffer.pos;
                
                // Rewrite the data payload (don't need to update the id or size)
                buffer.writeDoubleBE(clusterStartTime);
                
                // And write that through to the file
                blobBuffer.seek(segmentDuration.dataOffset);
                blobBuffer.write(buffer.getAsDataArray());
        
                blobBuffer.seek(oldPos);
            }
155110
public void writeText(char[] buf, int offset, int length)
  {
    closeElementIfNeeded(false);
    writeIndentIfNewLine();
    _strategy.writeText(this, buf, offset, length);
  }
628607
void prepareForWrite(long xaDataRecorderId) throws IOException, InterruptedException {
      this.dataLogger.reopen(AccessMode.WRITE);
      this.writeStartSequence(xaDataRecorderId);
   }
1270186
public static final void setWriter(String format, TreeWriter writer) {
		String key = format.toLowerCase();
		writers.put(key, writer);
		if (JSON.equals(key)) {
			cachedJsonWriter = writer;
		}
	}
53864
def _fill(self, text = ""):
        ""
        if self._do_indent:
            self._write("\n"+"    "*self._indent + text)
        else:
            self._write(text)
151370
private void writeCharsToOut(char[] cbuf, int len) throws IOException {
		if(len > 0) {
			if(len == 1) {
				out.write(cbuf[0]);
			} else {
				out.write(cbuf, 0, len);
			}
		}
	}
487445
public void format(StringBuffer fmt, Set done, Set todo, int indent) {
    formatName(fmt, indent);
    fmt.append("[");
    if (fields != null) {
      fmt.append("\n");
      for (int i = 0; i < fields.length; i++) {
        if (i > 0)
          fmt.append(",\n");
        fields[i].format(fmt, done, todo, indent + 2);
      }
      fmt.append("\n");
      indent(fmt, indent);
    }
    fmt.append("]");
  }
609227
public void write(String[] nextLine) {
    if (nextLine == null) return;
    StringBuilder sb = new StringBuilder(INITIAL_STRING_SIZE);
    for (int i = 0; i < nextLine.length; i++) {
      if (i != 0) {
        sb.append(format.defaultSeparator());
      }

      String nextElement = nextLine[i];
      if (nextElement == null) continue;
      if (!format.isDelimiter(NO_QUOTE_CHARACTER)) sb.append(format.getDelimiter());

      sb.append(stringContainsSpecialCharacters(nextElement) ? processLine(nextElement) : nextElement);

      if (!format.isDelimiter(NO_QUOTE_CHARACTER)) sb.append(format.getDelimiter());
    }
    sb.append(lineEnd);
    pw.write(sb.toString());

  }
607116
public static final void write(WritableByteChannel ch, String text, Charset charset) throws IOException
    {
        write(ch, text.getBytes(charset));
    }
239139
public void formatLine(String line, PrintWriter writer)
    {
        processingState.setLine(line);
        processingState.pwriter = writer;
        processingState = processingState.formatState.formatPartialLine(processingState);
        while (!processingState.isDoneWithLine())
        {
            processingState = processingState.formatState.formatPartialLine(processingState);
        }
    }