org.yaml.snakeyaml.DumperOptions Maven / Gradle / Ivy
/**
* Copyright (c) 2008, http://www.snakeyaml.org
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.yaml.snakeyaml;
import java.util.Map;
import java.util.TimeZone;
import org.yaml.snakeyaml.emitter.Emitter;
import org.yaml.snakeyaml.error.YAMLException;
import org.yaml.snakeyaml.serializer.AnchorGenerator;
import org.yaml.snakeyaml.serializer.NumberAnchorGenerator;
public class DumperOptions {
/**
* YAML provides a rich set of scalar styles. Block scalar styles include
* the literal style and the folded style; flow scalar styles include the
* plain style and two quoted styles, the single-quoted style and the
* double-quoted style. These styles offer a range of trade-offs between
* expressive power and readability.
*
* @see Chapter 9. Scalar
* Styles
* @see 2.3. Scalars
*/
public enum ScalarStyle {
DOUBLE_QUOTED('"'), SINGLE_QUOTED('\''), LITERAL(
'|'), FOLDED('>'), PLAIN(null);
private Character styleChar;
private ScalarStyle(Character style) {
this.styleChar = style;
}
public Character getChar() {
return styleChar;
}
@Override
public String toString() {
return "Scalar style: '" + styleChar + "'";
}
public static ScalarStyle createStyle(Character style) {
if (style == null) {
return PLAIN;
} else {
switch (style) {
case '"':
return DOUBLE_QUOTED;
case '\'':
return SINGLE_QUOTED;
case '|':
return LITERAL;
case '>':
return FOLDED;
default:
throw new YAMLException("Unknown scalar style character: " + style);
}
}
}
}
/**
* Block styles use indentation to denote nesting and scope within the
* document. In contrast, flow styles rely on explicit indicators to denote
* nesting and scope.
*
* @see 3.2.3.1.
* Node Styles (http://yaml.org/spec/1.1)
*/
public enum FlowStyle {
FLOW(Boolean.TRUE), BLOCK(Boolean.FALSE), AUTO(null);
private Boolean styleBoolean;
private FlowStyle(Boolean flowStyle) {
styleBoolean = flowStyle;
}
/*
* Convenience for legacy constructors that took {@link Boolean} arguments since replaced by {@link FlowStyle}.
* Introduced in v1.22 but only to support that for backwards compatibility.
* @deprecated Since restored in v1.22. Use the {@link FlowStyle} constants in your code instead.
*/
@Deprecated
public static FlowStyle fromBoolean(Boolean flowStyle) {
return flowStyle==null ? AUTO
: flowStyle ? FLOW
: BLOCK;
}
public Boolean getStyleBoolean() {
return styleBoolean;
}
@Override
public String toString() {
return "Flow style: '" + styleBoolean + "'";
}
}
/**
* Platform dependent line break.
*/
public enum LineBreak {
WIN("\r\n"), MAC("\r"), UNIX("\n");
private String lineBreak;
private LineBreak(String lineBreak) {
this.lineBreak = lineBreak;
}
public String getString() {
return lineBreak;
}
@Override
public String toString() {
return "Line break: " + name();
}
public static LineBreak getPlatformLineBreak() {
String platformLineBreak = System.getProperty("line.separator");
for (LineBreak lb : values()) {
if (lb.lineBreak.equals(platformLineBreak)) {
return lb;
}
}
return LineBreak.UNIX;
}
}
/**
* Specification version. Currently supported 1.0 and 1.1
*/
public enum Version {
V1_0(new Integer[] { 1, 0 }), V1_1(new Integer[] { 1, 1 });
private Integer[] version;
private Version(Integer[] version) {
this.version = version;
}
public int major() { return version[0]; }
public int minor() { return version[1]; }
public String getRepresentation() {
return version[0] + "." + version[1];
}
@Override
public String toString() {
return "Version: " + getRepresentation();
}
}
public enum NonPrintableStyle {
/**
* Tranform String to binary if it contains non-printable characters
*/
BINARY,
/**
* Escape non-printable characters
*/
ESCAPE
}
private ScalarStyle defaultStyle = ScalarStyle.PLAIN;
private FlowStyle defaultFlowStyle = FlowStyle.AUTO;
private boolean canonical = false;
private boolean allowUnicode = true;
private boolean allowReadOnlyProperties = false;
private int indent = 2;
private int indicatorIndent = 0;
private int bestWidth = 80;
private boolean splitLines = true;
private LineBreak lineBreak = LineBreak.UNIX;
private boolean explicitStart = false;
private boolean explicitEnd = false;
private TimeZone timeZone = null;
private int maxSimpleKeyLength = 128;
private NonPrintableStyle nonPrintableStyle = NonPrintableStyle.BINARY;
private Version version = null;
private Map tags = null;
private Boolean prettyFlow = false;
private AnchorGenerator anchorGenerator = new NumberAnchorGenerator(0);
public boolean isAllowUnicode() {
return allowUnicode;
}
/**
* Specify whether to emit non-ASCII printable Unicode characters.
* The default value is true.
* When set to false then printable non-ASCII characters (Cyrillic, Chinese etc)
* will be not printed but escaped (to support ASCII terminals)
*
* @param allowUnicode
* if allowUnicode is false then all non-ASCII characters are
* escaped
*/
public void setAllowUnicode(boolean allowUnicode) {
this.allowUnicode = allowUnicode;
}
public ScalarStyle getDefaultScalarStyle() {
return defaultStyle;
}
/**
* Set default style for scalars. See YAML 1.1 specification, 2.3 Scalars
* (http://yaml.org/spec/1.1/#id858081)
*
* @param defaultStyle
* set the style for all scalars
*/
public void setDefaultScalarStyle(ScalarStyle defaultStyle) {
if (defaultStyle == null) {
throw new NullPointerException("Use ScalarStyle enum.");
}
this.defaultStyle = defaultStyle;
}
public void setIndent(int indent) {
if (indent < Emitter.MIN_INDENT) {
throw new YAMLException("Indent must be at least " + Emitter.MIN_INDENT);
}
if (indent > Emitter.MAX_INDENT) {
throw new YAMLException("Indent must be at most " + Emitter.MAX_INDENT);
}
this.indent = indent;
}
public int getIndent() {
return this.indent;
}
public void setIndicatorIndent(int indicatorIndent) {
if (indicatorIndent < 0) {
throw new YAMLException("Indicator indent must be non-negative.");
}
if (indicatorIndent > Emitter.MAX_INDENT - 1) {
throw new YAMLException("Indicator indent must be at most Emitter.MAX_INDENT-1: " + (Emitter.MAX_INDENT - 1));
}
this.indicatorIndent = indicatorIndent;
}
public int getIndicatorIndent() {
return this.indicatorIndent;
}
public void setVersion(Version version) {
this.version = version;
}
public Version getVersion() {
return this.version;
}
/**
* Force the emitter to produce a canonical YAML document.
*
* @param canonical
* true produce canonical YAML document
*/
public void setCanonical(boolean canonical) {
this.canonical = canonical;
}
public boolean isCanonical() {
return this.canonical;
}
/**
* Force the emitter to produce a pretty YAML document when using the flow
* style.
*
* @param prettyFlow
* true produce pretty flow YAML document
*/
public void setPrettyFlow(boolean prettyFlow) {
this.prettyFlow = prettyFlow;
}
public boolean isPrettyFlow() {
return this.prettyFlow;
}
/**
* Specify the preferred width to emit scalars. When the scalar
* representation takes more then the preferred with the scalar will be
* split into a few lines. The default is 80.
*
* @param bestWidth
* the preferred width for scalars.
*/
public void setWidth(int bestWidth) {
this.bestWidth = bestWidth;
}
public int getWidth() {
return this.bestWidth;
}
/**
* Specify whether to split lines exceeding preferred width for
* scalars. The default is true.
*
* @param splitLines
* whether to split lines exceeding preferred width for scalars.
*/
public void setSplitLines(boolean splitLines) {
this.splitLines = splitLines;
}
public boolean getSplitLines() {
return this.splitLines;
}
public LineBreak getLineBreak() {
return lineBreak;
}
public void setDefaultFlowStyle(FlowStyle defaultFlowStyle) {
if (defaultFlowStyle == null) {
throw new NullPointerException("Use FlowStyle enum.");
}
this.defaultFlowStyle = defaultFlowStyle;
}
public FlowStyle getDefaultFlowStyle() {
return defaultFlowStyle;
}
/**
* Specify the line break to separate the lines. It is platform specific:
* Windows - "\r\n", old MacOS - "\r", Unix - "\n". The default value is the
* one for Unix.
* @param lineBreak to be used for the input
*/
public void setLineBreak(LineBreak lineBreak) {
if (lineBreak == null) {
throw new NullPointerException("Specify line break.");
}
this.lineBreak = lineBreak;
}
public boolean isExplicitStart() {
return explicitStart;
}
public void setExplicitStart(boolean explicitStart) {
this.explicitStart = explicitStart;
}
public boolean isExplicitEnd() {
return explicitEnd;
}
public void setExplicitEnd(boolean explicitEnd) {
this.explicitEnd = explicitEnd;
}
public Map getTags() {
return tags;
}
public void setTags(Map tags) {
this.tags = tags;
}
/**
* Report whether read-only JavaBean properties (the ones without setters)
* should be included in the YAML document
*
* @return false when read-only JavaBean properties are not emitted
*/
public boolean isAllowReadOnlyProperties() {
return allowReadOnlyProperties;
}
/**
* Set to true to include read-only JavaBean properties (the ones without
* setters) in the YAML document. By default these properties are not
* included to be able to parse later the same JavaBean.
*
* @param allowReadOnlyProperties
* - true to dump read-only JavaBean properties
*/
public void setAllowReadOnlyProperties(boolean allowReadOnlyProperties) {
this.allowReadOnlyProperties = allowReadOnlyProperties;
}
public TimeZone getTimeZone() {
return timeZone;
}
/**
* Set the timezone to be used for Date. If set to null UTC is
* used.
* @param timeZone for created Dates or null to use UTC
*/
public void setTimeZone(TimeZone timeZone) {
this.timeZone = timeZone;
}
public AnchorGenerator getAnchorGenerator() {
return anchorGenerator;
}
public void setAnchorGenerator(AnchorGenerator anchorGenerator) {
this.anchorGenerator = anchorGenerator;
}
public int getMaxSimpleKeyLength() {
return maxSimpleKeyLength;
}
/**
* Define max key length to use simple key (without '?')
* More info https://yaml.org/spec/1.1/#id934537
* @param maxSimpleKeyLength - the limit after which the key gets explicit key indicator '?'
*/
public void setMaxSimpleKeyLength(int maxSimpleKeyLength) {
if(maxSimpleKeyLength > 1024) {
throw new YAMLException("The simple key must not span more than 1024 stream characters. See https://yaml.org/spec/1.1/#id934537");
}
this.maxSimpleKeyLength = maxSimpleKeyLength;
}
public NonPrintableStyle getNonPrintableStyle() {
return this.nonPrintableStyle;
}
/**
* When String contains non-printable characters SnakeYAML convert it to binary data with the !!binary tag.
* Set this to ESCAPE to keep the !!str tag and escape the non-printable chars with \\x or \\u
* @param style ESCAPE to force SnakeYAML to keep !!str tag for non-printable data
*/
public void setNonPrintableStyle(NonPrintableStyle style) {
this.nonPrintableStyle = style;
}
}