Tell the writer the output format of type {@link WriterOutputFormat}.

@param format output format of the writer
@return this {@link DataWriterBuilder} instance
519460
public DataWriterBuilder<S, D> writeInFormat(WriterOutputFormat format) {
    this.format = format;
    log.debug("writeInFormat : {}", this.format);
    return this;
  }
523340
public static function setOutputFormat($format)
    {
        $self = Debugger::getInstance();

        if (!isset($self->_templates[$format])) {
            throw new InvalidArgumentException('Invalid Debugger output format.');
        }
        $self->_outputFormat = $format;
    }
286649
public static FileTransformer fileTransformer(Format format) {
        switch (format) {
            case MATLAB_SPARSE:
                return new MatlabSparseFileTransformer();
            case SVDLIBC_SPARSE_TEXT:
                return new SvdlibcSparseTextFileTransformer();
            case SVDLIBC_DENSE_TEXT:
                return new SvdlibcDenseTextFileTransformer();
            case SVDLIBC_SPARSE_BINARY:
                return new SvdlibcSparseBinaryFileTransformer();
            case SVDLIBC_DENSE_BINARY:
                return new SvdlibcDenseBinaryFileTransformer();
            default:
                throw new UnsupportedOperationException(
                        "Transforming format " + format + " is currently " +
                        "not implemented.  Please email " +
                        "s-space-research-dev@googlegroups.com to have this " +
                        "implemented.");
        }
    }
384285
protected static void output(WARCReader reader, String format)
    throws IOException, java.text.ParseException {
    	if (!reader.output(format)) {
            throw new IOException("Unsupported format: " + format);
    	}
    }
470890
public static void format(final Source input, final Result output) {
        try {
            // Use an identity transformation to write the source to the result.
            final Transformer transformer = createTransformer(null);
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");

            transformer.transform(input, output);
        } catch (final Exception ex) {
            LOGGER.error("Problem formatting DOM representation.", ex);
        }
    }
929472
public final OutputFormat getOutputFormat(final PJsonObject specJson) {
        final String format = specJson.getString(MapPrinterServlet.JSON_OUTPUT_FORMAT);
        final boolean mapExport =
                this.configuration.getTemplate(specJson.getString(Constants.JSON_LAYOUT_KEY)).isMapExport();
        final String beanName =
                format + (mapExport ? MAP_OUTPUT_FORMAT_BEAN_NAME_ENDING : OUTPUT_FORMAT_BEAN_NAME_ENDING);

        if (!this.outputFormat.containsKey(beanName)) {
            throw new RuntimeException("Format '" + format + "' with mapExport '" + mapExport
                                               + "' is not supported.");
        }

        return this.outputFormat.get(beanName);
    }
1374439
public function output($data, $format = null)
    {
        $contentType = $this->outputContentType($format);

        try {
            $content = $this->serializeData($data, $contentType);
        } catch (\UnexpectedValueException $e) {
            if (!isset($format) && isset($this->defaultFormat) && $this->defaultFormat !== $contentType) {
                $this->output($data, $this->defaultFormat); // Try default format instead
                return;
            }
            
            throw $e;
        }

        $this->getResponse()->getBody()->write($content);
    }
665211
public void setOutput(java.io.Writer writer) {
        
        fOut = writer instanceof PrintWriter
                ? (PrintWriter)writer : new PrintWriter(writer);
        
    }
515644
private void configureInputFormat(CsvInputFormat<?> format) {
		format.setCharset(this.charset);
		format.setDelimiter(this.lineDelimiter);
		format.setFieldDelimiter(this.fieldDelimiter);
		format.setCommentPrefix(this.commentPrefix);
		format.setSkipFirstLineAsHeader(skipFirstLineAsHeader);
		format.setLenient(ignoreInvalidLines);
		if (this.parseQuotedStrings) {
			format.enableQuotedStringParsing(this.quoteCharacter);
		}
	}
406241
private static OutputFormat whichOutputFormat(CommandLine line) throws ParseException {
        if (!line.hasOption('f')) {
            return OutputFormat.CSV;
        }

        try {
            return OutputFormat.valueOf(line.getOptionValue('f'));
        } catch (IllegalArgumentException e) {
            throw new ParseException(String.format(
                    "format %s is illegal. Available formats: %s",
                    line.getOptionValue('f'),
                    Utils.join(",", OutputFormat.formatNames())));
        }
    }
1204143
public ResourceFormatParser getParserForFormat(final String format) throws UnsupportedFormatException {
        try {
            return providerOfType(format);
        } catch (ExecutionServiceException e) {
            throw new UnsupportedFormatException("No provider available to parse format: " + format,e);
        }
    }
928768
public static String format(Date date, DateFormat format) {
		if (null == format || null == date) {
			return null;
		}
		return format.format(date);
	}
143167
public <Message extends PMessage<Message, Field>, Field extends PField>
    void formatTo(OutputStream out, Message message) {
        IndentedPrintWriter builder = new IndentedPrintWriter(out, indent, newline);
        if (message == null) {
            builder.append(null);
        } else {
            builder.append(message.descriptor().getQualifiedName())
                   .append(space);
            appendMessage(builder, message);
        }
        builder.flush();
    }
1348454
public void setDisplayFormat(DisplayFormat format) {
        getStorageHandler().getStorageEngine().setConfigEntry("longmode", format.toString());
        displayFormat = format;
    }
411469
@SuppressWarnings("unchecked")
  private BufferOutput writeById(int id, Object object, BufferOutput output, TypeSerializer serializer) {
    for (Identifier identifier : Identifier.values()) {
      if (identifier.accept(id)) {
        identifier.write(id, output.writeByte(identifier.code()));
        serializer.write(object, output, this);
        return output;
      }
    }
    throw new SerializationException("invalid type ID: " + id);
  }
25218
public SelectBuilder format(final String _pattern)
    {
        addPoint();
        this.bldr.append("format[").append(_pattern).append("]");
        return this;
    }
1328538
public void generateOutput(Writer outputWriter) throws IOException {
        String s = generateOutput();
        outputWriter.write(s);
    }