Write all of lines from file using the writer.
437298
def write_file(writer, filename):
  """"""
  for line in txt_line_iterator(filename):
    writer.write(line)
    writer.write("\n")
1364321
def write(self, output):
        
        self._stream.write(output)

        if self._auto_flush:
            self._stream.flush()
1193502
def write(self, iterable):
        """"""

        io_error_text = _("Error writing to file {filepath}.")
        io_error_text = io_error_text.format(filepath=self.path)

        try:

            with open(self.path, "wb") as csvfile:
                csv_writer = csv.writer(csvfile, self.dialect)

                for line in iterable:
                    csv_writer.writerow(
                        list(encode_gen(line, encoding=self.encoding)))

        except IOError:
            txt = \
                _("Error opening file {filepath}.").format(filepath=self.path)
            try:
                post_command_event(self.main_window, self.StatusBarMsg,
                                   text=txt)
            except TypeError:
                # The main window does not exist any more
                pass

            return False
279749
public static void writeFile( List<String> lines, File file ) throws IOException {
        try (BufferedWriter bw = new BufferedWriter(new FileWriter(file))) {
            for( String line : lines ) {
                bw.write(line);
                bw.write("\n"); //$NON-NLS-1$
            }
        }
    }
87521
public void write(PrintWriter writer) {
        this.output = writer;
        dispatch(base, false);
        writer.flush();
    }
1277071
def write(self, *args):
        '''
        '''
        for s in args: self.out.write(s)
        event = ''.join(*args)
787661
public void write(Object from, File target) throws IOException {
    OutputStream outputStream = new FileOutputStream(target);
    try {
      write(from, outputStream);
    } finally {
      outputStream.close();
    }
  }
608949
public static Writer writer(File file) {
        try {
            return new FileWriter(file);
        } catch (IOException e) {
            throw E.ioException(e);
        }
    }
634057
def write(self, buf, newline=True):
        

        buf = buf or ''

        if newline:
            buf += os.linesep

        try:
            self._output.write(buf)

            if hasattr(self._output, 'flush'):
                self._output.flush()

        except IOError as exc:
            if exc.errno != errno.EPIPE:  # silence EPIPE errors
                raise
408176
def write(self, s):
        """"""
        for line in re.split(r'\n+', s):
            if line != '':
                self._logger.log(self._level, line)
707270
def write(self, chunk):
        """"""
        if self.chunked_write and chunk:
            buf = [hex(len(chunk))[2:], CRLF, chunk, CRLF]
            self.conn.wfile.sendall("".join(buf))
        else:
            self.conn.wfile.sendall(chunk)
999500
def write_all(self, data):
        
        self._set_cursor_x(0)
        self._set_cursor_y(0)

        self.DC.on()

        self._write(data)
232367
def write_file_lines(self, filename, contents):
        
        with open(filename, 'wb') as f:
            self.log.debug(contents)
            f.writelines(contents)
1137668
def _writen(fd, data):
    """"""
    while data:
        n = os.write(fd, data)
        data = data[n:]
589704
def write(self, data):
        """"""

        if len(data) > self.data_size:
            raise ValueError

        self.__fileobj.seek(self.data_offset)
        self.__fileobj.write(data)
627680
def write(self, dry_run=True):
    
    start_lines = self._build_file_source_lines[:]
    end_lines = self.build_file_lines()
    diff_generator = unified_diff(start_lines,
                                  end_lines,
                                  fromfile=self.build_file.relpath,
                                  tofile=self.build_file.relpath,
                                  lineterm='')
    if dry_run:
      msg = 'DRY RUN, would have written this diff:'
    else:
      msg = 'REAL RUN, about to write the following diff:'
    sys.stderr.write(msg + '\n')
    sys.stderr.write('*' * 40 + '\n')
    sys.stderr.write('target at: ')
    sys.stderr.write(str(self.target_address) + '\n')

    for line in diff_generator:
      sys.stderr.write(line + '\n')

    sys.stderr.write('*' * 40 + '\n')
    if not dry_run:
      with open(self.build_file.full_path, 'w') as bf:
        bf.write('\n'.join(end_lines))
      sys.stderr.write('WROTE to {full_path}\n'.format(full_path=self.build_file.full_path))
837571
public void writeLine() throws IORuntimeException {
		try {
			writer.write(config.lineDelimiter);
		} catch (IOException e) {
			throw new IORuntimeException(e);
		}
		newline = true;
	}