#4057

Committed 11 Feb 2025 06:00AM CUT coverage: 35.269% (+1.9%) from 33.377%

Build # #4057

Build Type

push

github

Committed by

topframe

Commit Message

Update

Run Details

13 of 42 new or added lines in 7 files covered. (30.95%)

4 existing lines in 3 files now uncovered.

14247 of 40395 relevant lines covered (35.27%)

0.35 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

67.39

/utils/src/main/java/com/aspectran/utils/json/JsonWriter.java

/*
 * Copyright (c) 2008-2025 The Aspectran Project
 *
 * 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 com.aspectran.utils.json;

import com.aspectran.utils.ArrayStack;
import com.aspectran.utils.Assert;
import com.aspectran.utils.BeanUtils;
import com.aspectran.utils.StringifyContext;
import com.aspectran.utils.annotation.jsr305.NonNull;
import com.aspectran.utils.apon.Parameter;
import com.aspectran.utils.apon.Parameters;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.StringReader;
import java.io.Writer;
import java.lang.reflect.Array;
import java.lang.reflect.InvocationTargetException;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.Collection;
import java.util.Date;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Map;

/**
 * Converts an object to a JSON formatted string.
 * <p>If pretty-printing is enabled, the JsonWriter will add newlines and
 * indentation to the written data. Pretty-printing is disabled by default.</p>
 *
 * <p>Created: 2008. 06. 12 PM 8:20:54</p>
 *
 * @author Juho Jeong
 */
public class JsonWriter {

    private static final String DEFAULT_INDENT_STRING = "  ";

    private static final String NULL_STRING = "null";

    private final ArrayStack<Boolean> writtenFlags = new ArrayStack<>();

    private final Writer writer;

    private StringifyContext stringifyContext;

    private boolean prettyPrint = true;

    private String indentString = DEFAULT_INDENT_STRING;

    private boolean nullWritable = true;

    private int indentDepth;

    private String pendedName;

    private Object upperObject;

    /**
     * Instantiates a new JsonWriter.
     * Pretty printing is enabled by default, and the indent string is
     * set to "  " (two spaces).
     * @param writer the character-output stream
     */
    public JsonWriter(Writer writer) {
        Assert.notNull(writer, "out must not be null");
        this.writer = writer;
        writtenFlags.push(false);
    }

    public void setStringifyContext(StringifyContext stringifyContext) {
        this.stringifyContext = stringifyContext;
        if (stringifyContext != null) {
            if (stringifyContext.hasPrettyPrint()) {
                setPrettyPrint(stringifyContext.isPrettyPrint());
            }
            if (stringifyContext.hasIndentSize()) {
                setIndentString(stringifyContext.getIndentString());
            }
            if (stringifyContext.hasNullWritable()) {
                setNullWritable(stringifyContext.isNullWritable());
            }
        }
    }

    @SuppressWarnings("unchecked")
    public <T extends JsonWriter> T apply(StringifyContext stringifyContext) {
        setStringifyContext(stringifyContext);
        return (T)this;
    }

    public void setPrettyPrint(boolean prettyPrint) {
        this.prettyPrint = prettyPrint;
        if (prettyPrint) {
            if (indentString == null) {
                indentString = DEFAULT_INDENT_STRING;
            }
        } else {
            indentString = null;
        }
    }

    @SuppressWarnings("unchecked")
    public <T extends JsonWriter> T prettyPrint(boolean prettyPrint) {
        setPrettyPrint(prettyPrint);
        return (T)this;
    }

    public void setIndentString(String indentString) {
        this.indentString = indentString;
    }

    @SuppressWarnings("unchecked")
    public <T extends JsonWriter> T indentString(String indentString) {
        setIndentString(indentString);
        return (T)this;
    }

    public void setNullWritable(boolean nullWritable) {
        this.nullWritable = nullWritable;
    }

    @SuppressWarnings("unchecked")
    public <T extends JsonWriter> T nullWritable(boolean nullWritable) {
        setNullWritable(nullWritable);
        return (T)this;
    }

    /**
     * Begins encoding a new object.
     * @throws IOException if an I/O error has occurred
     */
    @SuppressWarnings("unchecked")
    public <T extends JsonWriter> T beginObject() throws IOException {
        writePendedName();
        writer.write("{");
        nextLine();
        indentDepth++;
        writtenFlags.push(false);
        return (T)this;
    }

    /**
     * Ends encoding the current object.
     * @throws IOException if an I/O error has occurred
     */
    @SuppressWarnings("unchecked")
    public <T extends JsonWriter> T endObject() throws IOException {
        indentDepth--;
        if (writtenFlags.pop()) {
            nextLine();
        }
        indent();
        writer.write("}");
        writtenFlags.update(true);
        return (T)this;
    }

    /**
     * Begins encoding a new array.
     * @throws IOException if an I/O error has occurred
     */
    @SuppressWarnings("unchecked")
    public <T extends JsonWriter> T beginArray() throws IOException {
        writePendedName();
        writer.write("[");
        nextLine();
        indentDepth++;
        writtenFlags.push(false);
        return (T)this;
    }

    /**
     * Ends encoding the current array.
     * @throws IOException if an I/O error has occurred
     */
    @SuppressWarnings("unchecked")
    public <T extends JsonWriter> T endArray() throws IOException {
        indentDepth--;
        if (writtenFlags.pop()) {
            nextLine();
        }
        indent();
        writer.write("]");
        writtenFlags.update(true);
        return (T)this;
    }

    @SuppressWarnings("unchecked")
    public <T extends JsonWriter> T name(String name) throws IOException {
        writeName(name);
        return (T)this;
    }

    @SuppressWarnings("unchecked")
    public <T extends JsonWriter> T value(Object value) throws IOException {
        writeValue(value);
        return (T)this;
    }

    /**
     * Writes a key name to the writer.
     * @param name the string to write to the writer
     */
    public void writeName(String name) {
        pendedName = name;
    }

    private void writePendedName() throws IOException {
        if (writtenFlags.peek()) {
            writeComma();
        }
        if (pendedName != null) {
            indent();
            writer.write(escape(pendedName));
            writer.write(":");
            if (prettyPrint) {
                writer.write(" ");
            }
            pendedName = null;
        } else {
            indent();
        }
    }

    private void clearPendedName() {
        pendedName = null;
    }

    /**
     * Writes an object to the writer.
     * @param object the object to write to the writer.
     * @throws IOException if an I/O error has occurred.
     */
    public void writeValue(Object object) throws IOException {
        if (object == null) {
            writeNull();
        } else if (object instanceof String string) {
            writeString(string);
        } else if (object instanceof JsonString) {
            writeJson(object.toString());
        } else if (object instanceof Character) {
            writeString(String.valueOf(object));
        } else if (object instanceof Boolean bool) {
            writeBool(bool);
        } else if (object instanceof Number number) {
            writeNumber(number);
        } else if (object instanceof Parameters parameters) {
            beginObject();
            for (Parameter p : parameters.getParameterValues()) {
                String name = p.getName();
                Object value = p.getValue();
                writeName(name);
                writeValue(value, object);
            }
            endObject();
        } else if (object instanceof Map<?, ?> map) {
            beginObject();
            for (Map.Entry<?, ?> entry : map.entrySet()) {
                String name = entry.getKey().toString();
                Object value = entry.getValue();
                writeName(name);
                writeValue(value, object);
            }
            endObject();
        } else if (object instanceof Collection<?> collection) {
            beginArray();
            for (Object value : collection) {
                if (value != null) {
                    writeValue(value, object);
                } else {
                    writeNull(true);
                }
            }
            endArray();
        } else if (object instanceof Iterator<?> iterator) {
            beginArray();
            while (iterator.hasNext()) {
                Object value = iterator.next();
                if (value != null) {
                    writeValue(value, object);
                } else {
                    writeNull(true);
                }
            }
            endArray();
        } else if (object instanceof Enumeration<?> enumeration) {
            beginArray();
            while (enumeration.hasMoreElements()) {
                Object value = enumeration.nextElement();
                if (value != null) {
                    writeValue(value, object);
                } else {
                    writeNull(true);
                }
            }
            endArray();
        } else if (object.getClass().isArray()) {
            beginArray();
            int len = Array.getLength(object);
            for (int i = 0; i < len; i++) {
                Object value = Array.get(object, i);
                if (value != null) {
                    writeValue(value, object);
                } else {
                    writeNull(true);
                }
            }
            endArray();
        } else if (object instanceof LocalDateTime localDateTime) {
            if (stringifyContext != null) {
                writeString(stringifyContext.toString(localDateTime));
            } else {
                writeString(localDateTime.toString());
            }
        } else if (object instanceof LocalDate localDate) {
            if (stringifyContext != null) {
                writeString(stringifyContext.toString(localDate));
            } else {
                writeString(localDate.toString());
            }
        } else if (object instanceof LocalTime localTime) {
            if (stringifyContext != null) {
                writeString(stringifyContext.toString(localTime));
            } else {
                writeString(localTime.toString());
            }
        } else if (object instanceof Date date) {
            if (stringifyContext != null) {
                writeString(stringifyContext.toString(date));
            } else {
                writeString(date.toString());
            }
        } else {
            String[] readablePropertyNames = BeanUtils.getReadablePropertyNamesWithoutNonSerializable(object);
            if (readablePropertyNames != null && readablePropertyNames.length > 0) {
                beginObject();
                for (String propertyName : readablePropertyNames) {
                    Object value;
                    try {
                        value = BeanUtils.getProperty(object, propertyName);
                    } catch (InvocationTargetException e) {
                        throw new IOException(e);
                    }
                    writeName(propertyName);
                    writeValue(value, object);
                }
                endObject();
            } else {
                writeString(object.toString());
            }
        }
    }

    private void writeValue(Object object, Object container) throws IOException {
        checkCircularReference(container, object);
        this.upperObject = container;
        writeValue(object);
        this.upperObject = null;
    }

    /**
     * Writes a "null" string to the writer.
     * @throws IOException if an I/O error has occurred
     */
    public void writeNull() throws IOException {
        writeNull(false);
    }

    /**
     * Writes a "null" string to the writer.
     * @param force true if forces should be written null value
     * @throws IOException if an I/O error has occurred
     */
    public void writeNull(boolean force) throws IOException {
        if (nullWritable || force) {
            writePendedName();
            writer.write(NULL_STRING);
            writtenFlags.update(true);
        } else {
            clearPendedName();
        }
    }

    /**
     * Writes a string directly to the writer stream without
     * quoting or escaping.
     * @param json the string to write to the writer
     * @throws IOException if an I/O error has occurred
     */
    public void writeJson(String json) throws IOException {
        if (nullWritable || json != null) {
            writePendedName();
            if (json != null) {
                BufferedReader reader = new BufferedReader(new StringReader(json));
                boolean first = true;
                String line;
                while ((line = reader.readLine()) != null) {
                    if (!first) {
                        nextLine();
                        indent();
                    }
                    writer.write(line);
                    first = false;
                }
            } else {
                writer.write(NULL_STRING);
            }
            writtenFlags.update(true);
        } else {
            clearPendedName();
        }
    }

    /**
     * Writes a string to the writer.
     * If {@code value} is null, write a null string ("").
     * @param value the string to write to the writer
     * @throws IOException if an I/O error has occurred
     */
    private void writeString(String value) throws IOException {
        if (nullWritable || value != null) {
            writePendedName();
            writer.write(escape(value));
            writtenFlags.update(true);
        } else {
            clearPendedName();
        }
    }

    /**
     * Writes a {@code Boolean} object to the writer.
     * @param value a {@code Boolean} object to write to the writer
     * @throws IOException if an I/O error has occurred
     */
    private void writeBool(Boolean value) throws IOException {
        if (nullWritable || value != null) {
            writePendedName();
            writer.write(value.toString());
            writtenFlags.update(true);
        } else {
            clearPendedName();
        }
    }

    /**
     * Writes a {@code Number} object to the writer.
     * @param value a {@code Number} object to write to the writer
     * @throws IOException if an I/O error has occurred
     */
    private void writeNumber(Number value) throws IOException {
        if (nullWritable || value != null) {
            writePendedName();
            writer.write(value.toString());
            writtenFlags.update(true);
        } else {
            clearPendedName();
        }
    }

    /**
     * Writes a comma character to the writer.
     * @throws IOException if an I/O error has occurred
     */
    private void writeComma() throws IOException {
        writer.write(",");
        nextLine();
    }

    /**
     * Writes a tab character to the writer.
     * @throws IOException if an I/O error has occurred
     */
    private void indent() throws IOException {
        if (prettyPrint && indentString != null && !indentString.isEmpty()) {
            for (int i = 0; i < indentDepth; i++) {
                writer.write(indentString);
            }
        }
    }

    /**
     * Writes a new line character to the writer.
     * @throws IOException if an I/O error has occurred
     */
    private void nextLine() throws IOException {
        if (prettyPrint) {
            writer.write("\n");
        }
    }

    /**
     * Ensures all buffered data is written to the underlying
     * {@link Writer} and flushes that writer.
     * @throws IOException if an I/O error has occurred
     */
    public void flush() throws IOException {
        writer.flush();
    }

    public void close() throws IOException {
        writer.close();
    }

    @Override
    public String toString() {
        return writer.toString();
    }

    private void checkCircularReference(Object object, Object member) throws IOException {
        if (object == member || (upperObject != null && upperObject == member)) {
            String what;
            if (pendedName != null) {
                what = "member '" + pendedName + "'";
            } else {
                what = "a member";
            }
            throw new IOException("JSON Serialization Failure: " +
                    "A circular reference was detected while converting " + what);
        }
    }

    /**
     * Produce a string in double quotes with backslash sequences in all the
     * right places. A backslash will be inserted within &lt;/, allowing JSON
     * text to be delivered in HTML. In JSON text, a string cannot contain a
     * control character or an unescaped quote or backslash.
     * @param string the input String, may be null
     * @return a String correctly formatted for insertion in a JSON text
     */
    @NonNull
    private static String escape(String string) {
        if (string == null || string.isEmpty()) {
            return "\"\"";
        }

        int len = string.length();
        char b;
        char c = 0;
        String t;

        StringBuilder sb = new StringBuilder(len + 4);
        sb.append('"');
        for (int i = 0; i < len; i++) {
            b = c;
            c = string.charAt(i);

            switch (c) {
                case '\\':
                case '"':
                    sb.append('\\');
                    sb.append(c);
                    break;
                case '/':
                    if (b == '<') {
                        sb.append('\\');
                    }
                    sb.append(c);
                    break;
                case '\b':
                    sb.append("\\b");
                    break;
                case '\t':
                    sb.append("\\t");
                    break;
                case '\n':
                    sb.append("\\n");
                    break;
                case '\f':
                    sb.append("\\f");
                    break;
                case '\r':
                    sb.append("\\r");
                    break;
                default:
                    if (c < ' ' || (c >= '\u0080' && c < '\u00a0') || (c >= '\u2000' && c < '\u2100')) {
                        t = "000" + Integer.toHexString(c);
                        sb.append("\\u").append(t.substring(t.length() - 4));
                    } else {
                        sb.append(c);
                    }
            }
        }
        sb.append('"');
        return sb.toString();
    }

}

1	/*
2	* Copyright (c) 2008-2025 The Aspectran Project
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16	package com.aspectran.utils.json;
17
18	import com.aspectran.utils.ArrayStack;
19	import com.aspectran.utils.Assert;
20	import com.aspectran.utils.BeanUtils;
21	import com.aspectran.utils.StringifyContext;
22	import com.aspectran.utils.annotation.jsr305.NonNull;
23	import com.aspectran.utils.apon.Parameter;
24	import com.aspectran.utils.apon.Parameters;
25
26	import java.io.BufferedReader;
27	import java.io.IOException;
28	import java.io.StringReader;
29	import java.io.Writer;
30	import java.lang.reflect.Array;
31	import java.lang.reflect.InvocationTargetException;
32	import java.time.LocalDate;
33	import java.time.LocalDateTime;
34	import java.time.LocalTime;
35	import java.util.Collection;
36	import java.util.Date;
37	import java.util.Enumeration;
38	import java.util.Iterator;
39	import java.util.Map;
40
41	/**
42	* Converts an object to a JSON formatted string.
43	* <p>If pretty-printing is enabled, the JsonWriter will add newlines and
44	* indentation to the written data. Pretty-printing is disabled by default.</p>
45	*
46	* <p>Created: 2008. 06. 12 PM 8:20:54</p>
47	*
48	* @author Juho Jeong
49	*/
50	public class JsonWriter {
51
52	private static final String DEFAULT_INDENT_STRING = " ";
53
54	private static final String NULL_STRING = "null";
55
56	private final ArrayStack<Boolean> writtenFlags = new ArrayStack<>();	1✔
57
58	private final Writer writer;
59
60	private StringifyContext stringifyContext;
61
62	private boolean prettyPrint = true;	1✔
63
64	private String indentString = DEFAULT_INDENT_STRING;	1✔
65
66	private boolean nullWritable = true;	1✔
67
68	private int indentDepth;
69
70	private String pendedName;
71
72	private Object upperObject;
73
74	/**
75	* Instantiates a new JsonWriter.
76	* Pretty printing is enabled by default, and the indent string is
77	* set to " " (two spaces).
78	* @param writer the character-output stream
79	*/
80	public JsonWriter(Writer writer) {	1✔
81	Assert.notNull(writer, "out must not be null");	1✔
82	this.writer = writer;	1✔
83	writtenFlags.push(false);	1✔
84	}	1✔
85
86	public void setStringifyContext(StringifyContext stringifyContext) {
87	this.stringifyContext = stringifyContext;	1✔
88	if (stringifyContext != null) {	1✔
89	if (stringifyContext.hasPrettyPrint()) {	1✔
NEW 90	setPrettyPrint(stringifyContext.isPrettyPrint());	×
91	}
92	if (stringifyContext.hasIndentSize()) {	1✔
NEW 93	setIndentString(stringifyContext.getIndentString());	×
94	}
95	if (stringifyContext.hasNullWritable()) {	1✔
NEW 96	setNullWritable(stringifyContext.isNullWritable());	×
97	}
98	}
99	}	1✔
100
101	@SuppressWarnings("unchecked")
102	public <T extends JsonWriter> T apply(StringifyContext stringifyContext) {
103	setStringifyContext(stringifyContext);	1✔
104	return (T)this;	1✔
105	}
106
107	public void setPrettyPrint(boolean prettyPrint) {
UNCOV 108	this.prettyPrint = prettyPrint;	×
109	if (prettyPrint) {	×
NEW 110	if (indentString == null) {	×
NEW 111	indentString = DEFAULT_INDENT_STRING;	×
112	}
113	} else {
NEW 114	indentString = null;	×
115	}
116	}	×
117
118	@SuppressWarnings("unchecked")
119	public <T extends JsonWriter> T prettyPrint(boolean prettyPrint) {
NEW 120	setPrettyPrint(prettyPrint);	×
NEW 121	return (T)this;	×
122	}
123
124	public void setIndentString(String indentString) {
125	this.indentString = indentString;	×
NEW 126	}	×
127
128	@SuppressWarnings("unchecked")
129	public <T extends JsonWriter> T indentString(String indentString) {
NEW 130	setIndentString(indentString);	×
UNCOV 131	return (T)this;	×
132	}
133
134	public void setNullWritable(boolean nullWritable) {
135	this.nullWritable = nullWritable;	1✔
136	}	1✔
137
138	@SuppressWarnings("unchecked")
139	public <T extends JsonWriter> T nullWritable(boolean nullWritable) {
140	setNullWritable(nullWritable);	1✔
141	return (T)this;	1✔
142	}
143
144	/**
145	* Begins encoding a new object.
146	* @throws IOException if an I/O error has occurred
147	*/
148	@SuppressWarnings("unchecked")
149	public <T extends JsonWriter> T beginObject() throws IOException {
150	writePendedName();	1✔
151	writer.write("{");	1✔
152	nextLine();	1✔
153	indentDepth++;	1✔
154	writtenFlags.push(false);	1✔
155	return (T)this;	1✔
156	}
157
158	/**
159	* Ends encoding the current object.
160	* @throws IOException if an I/O error has occurred
161	*/
162	@SuppressWarnings("unchecked")
163	public <T extends JsonWriter> T endObject() throws IOException {
164	indentDepth--;	1✔
165	if (writtenFlags.pop()) {	1✔
166	nextLine();	1✔
167	}
168	indent();	1✔
169	writer.write("}");	1✔
170	writtenFlags.update(true);	1✔
171	return (T)this;	1✔
172	}
173
174	/**
175	* Begins encoding a new array.
176	* @throws IOException if an I/O error has occurred
177	*/
178	@SuppressWarnings("unchecked")
179	public <T extends JsonWriter> T beginArray() throws IOException {
180	writePendedName();	1✔
181	writer.write("[");	1✔
182	nextLine();	1✔
183	indentDepth++;	1✔
184	writtenFlags.push(false);	1✔
185	return (T)this;	1✔
186	}
187
188	/**
189	* Ends encoding the current array.
190	* @throws IOException if an I/O error has occurred
191	*/
192	@SuppressWarnings("unchecked")
193	public <T extends JsonWriter> T endArray() throws IOException {
194	indentDepth--;	1✔
195	if (writtenFlags.pop()) {	1✔
196	nextLine();	1✔
197	}
198	indent();	1✔
199	writer.write("]");	1✔
200	writtenFlags.update(true);	1✔
201	return (T)this;	1✔
202	}
203
204	@SuppressWarnings("unchecked")
205	public <T extends JsonWriter> T name(String name) throws IOException {
206	writeName(name);	×
207	return (T)this;	×
208	}
209
210	@SuppressWarnings("unchecked")
211	public <T extends JsonWriter> T value(Object value) throws IOException {
212	writeValue(value);	1✔
213	return (T)this;	1✔
214	}
215
216	/**
217	* Writes a key name to the writer.
218	* @param name the string to write to the writer
219	*/
220	public void writeName(String name) {
221	pendedName = name;	1✔
222	}	1✔
223
224	private void writePendedName() throws IOException {
225	if (writtenFlags.peek()) {	1✔
226	writeComma();	1✔
227	}
228	if (pendedName != null) {	1✔
229	indent();	1✔
230	writer.write(escape(pendedName));	1✔
231	writer.write(":");	1✔
232	if (prettyPrint) {	1✔
233	writer.write(" ");	1✔
234	}
235	pendedName = null;	1✔
236	} else {
237	indent();	1✔
238	}
239	}	1✔
240
241	private void clearPendedName() {
242	pendedName = null;	1✔
243	}	1✔
244
245	/**
246	* Writes an object to the writer.
247	* @param object the object to write to the writer.
248	* @throws IOException if an I/O error has occurred.
249	*/
250	public void writeValue(Object object) throws IOException {
251	if (object == null) {	1✔
252	writeNull();	1✔
253	} else if (object instanceof String string) {	1✔
254	writeString(string);	1✔
255	} else if (object instanceof JsonString) {	1✔
256	writeJson(object.toString());	×
257	} else if (object instanceof Character) {	1✔
258	writeString(String.valueOf(object));	×
259	} else if (object instanceof Boolean bool) {	1✔
260	writeBool(bool);	1✔
261	} else if (object instanceof Number number) {	1✔
262	writeNumber(number);	1✔
263	} else if (object instanceof Parameters parameters) {	1✔
264	beginObject();	1✔
265	for (Parameter p : parameters.getParameterValues()) {	1✔
266	String name = p.getName();	1✔
267	Object value = p.getValue();	1✔
268	writeName(name);	1✔
269	writeValue(value, object);	1✔
270	}	1✔
271	endObject();	1✔
272	} else if (object instanceof Map<?, ?> map) {	1✔
273	beginObject();	1✔
274	for (Map.Entry<?, ?> entry : map.entrySet()) {	1✔
275	String name = entry.getKey().toString();	1✔
276	Object value = entry.getValue();	1✔
277	writeName(name);	1✔
278	writeValue(value, object);	1✔
279	}	1✔
280	endObject();	1✔
281	} else if (object instanceof Collection<?> collection) {	1✔
282	beginArray();	1✔
283	for (Object value : collection) {	1✔
284	if (value != null) {	1✔
285	writeValue(value, object);	1✔
286	} else {
287	writeNull(true);	×
288	}
289	}	1✔
290	endArray();	1✔
291	} else if (object instanceof Iterator<?> iterator) {	1✔
292	beginArray();	×
293	while (iterator.hasNext()) {	×
294	Object value = iterator.next();	×
295	if (value != null) {	×
296	writeValue(value, object);	×
297	} else {
298	writeNull(true);	×
299	}
300	}	×
301	endArray();	×
302	} else if (object instanceof Enumeration<?> enumeration) {	1✔
303	beginArray();	×
304	while (enumeration.hasMoreElements()) {	×
305	Object value = enumeration.nextElement();	×
306	if (value != null) {	×
307	writeValue(value, object);	×
308	} else {
309	writeNull(true);	×
310	}
311	}	×
312	endArray();	×
313	} else if (object.getClass().isArray()) {	1✔
314	beginArray();	1✔
315	int len = Array.getLength(object);	1✔
316	for (int i = 0; i < len; i++) {	1✔
317	Object value = Array.get(object, i);	1✔
318	if (value != null) {	1✔
319	writeValue(value, object);	×
320	} else {
321	writeNull(true);	1✔
322	}
323	}
324	endArray();	1✔
325	} else if (object instanceof LocalDateTime localDateTime) {	1✔
326	if (stringifyContext != null) {	×
327	writeString(stringifyContext.toString(localDateTime));	×
328	} else {
329	writeString(localDateTime.toString());	×
330	}
331	} else if (object instanceof LocalDate localDate) {	1✔
332	if (stringifyContext != null) {	1✔
333	writeString(stringifyContext.toString(localDate));	×
334	} else {
335	writeString(localDate.toString());	1✔
336	}
337	} else if (object instanceof LocalTime localTime) {	×
338	if (stringifyContext != null) {	×
339	writeString(stringifyContext.toString(localTime));	×
340	} else {
341	writeString(localTime.toString());	×
342	}
343	} else if (object instanceof Date date) {	×
344	if (stringifyContext != null) {	×
345	writeString(stringifyContext.toString(date));	×
346	} else {
347	writeString(date.toString());	×
348	}
349	} else {
350	String[] readablePropertyNames = BeanUtils.getReadablePropertyNamesWithoutNonSerializable(object);	×
351	if (readablePropertyNames != null && readablePropertyNames.length > 0) {	×
352	beginObject();	×
353	for (String propertyName : readablePropertyNames) {	×
354	Object value;
355	try {
356	value = BeanUtils.getProperty(object, propertyName);	×
357	} catch (InvocationTargetException e) {	×
358	throw new IOException(e);	×
359	}	×
360	writeName(propertyName);	×
361	writeValue(value, object);	×
362	}
363	endObject();	×
364	} else {
365	writeString(object.toString());	×
366	}
367	}
368	}	1✔
369
370	private void writeValue(Object object, Object container) throws IOException {
371	checkCircularReference(container, object);	1✔
372	this.upperObject = container;	1✔
373	writeValue(object);	1✔
374	this.upperObject = null;	1✔
375	}	1✔
376
377	/**
378	* Writes a "null" string to the writer.
379	* @throws IOException if an I/O error has occurred
380	*/
381	public void writeNull() throws IOException {
382	writeNull(false);	1✔
383	}	1✔
384
385	/**
386	* Writes a "null" string to the writer.
387	* @param force true if forces should be written null value
388	* @throws IOException if an I/O error has occurred
389	*/
390	public void writeNull(boolean force) throws IOException {
391	if (nullWritable \|\| force) {	1✔
392	writePendedName();	1✔
393	writer.write(NULL_STRING);	1✔
394	writtenFlags.update(true);	1✔
395	} else {
396	clearPendedName();	1✔
397	}
398	}	1✔
399
400	/**
401	* Writes a string directly to the writer stream without
402	* quoting or escaping.
403	* @param json the string to write to the writer
404	* @throws IOException if an I/O error has occurred
405	*/
406	public void writeJson(String json) throws IOException {
407	if (nullWritable \|\| json != null) {	1✔
408	writePendedName();	1✔
409	if (json != null) {	1✔
410	BufferedReader reader = new BufferedReader(new StringReader(json));	1✔
411	boolean first = true;	1✔
412	String line;
413	while ((line = reader.readLine()) != null) {	1✔
414	if (!first) {	1✔
415	nextLine();	1✔
416	indent();	1✔
417	}
418	writer.write(line);	1✔
419	first = false;	1✔
420	}
421	} else {	1✔
422	writer.write(NULL_STRING);	×
423	}
424	writtenFlags.update(true);	1✔
425	} else {
426	clearPendedName();	×
427	}
428	}	1✔
429
430	/**
431	* Writes a string to the writer.
432	* If {@code value} is null, write a null string ("").
433	* @param value the string to write to the writer
434	* @throws IOException if an I/O error has occurred
435	*/
436	private void writeString(String value) throws IOException {
437	if (nullWritable \|\| value != null) {	1✔
438	writePendedName();	1✔
439	writer.write(escape(value));	1✔
440	writtenFlags.update(true);	1✔
441	} else {
442	clearPendedName();	×
443	}
444	}	1✔
445
446	/**
447	* Writes a {@code Boolean} object to the writer.
448	* @param value a {@code Boolean} object to write to the writer
449	* @throws IOException if an I/O error has occurred
450	*/
451	private void writeBool(Boolean value) throws IOException {
452	if (nullWritable \|\| value != null) {	1✔
453	writePendedName();	1✔
454	writer.write(value.toString());	1✔
455	writtenFlags.update(true);	1✔
456	} else {
457	clearPendedName();	×
458	}
459	}	1✔
460
461	/**
462	* Writes a {@code Number} object to the writer.
463	* @param value a {@code Number} object to write to the writer
464	* @throws IOException if an I/O error has occurred
465	*/
466	private void writeNumber(Number value) throws IOException {
467	if (nullWritable \|\| value != null) {	1✔
468	writePendedName();	1✔
469	writer.write(value.toString());	1✔
470	writtenFlags.update(true);	1✔
471	} else {
472	clearPendedName();	×
473	}
474	}	1✔
475
476	/**
477	* Writes a comma character to the writer.
478	* @throws IOException if an I/O error has occurred
479	*/
480	private void writeComma() throws IOException {
481	writer.write(",");	1✔
482	nextLine();	1✔
483	}	1✔
484
485	/**
486	* Writes a tab character to the writer.
487	* @throws IOException if an I/O error has occurred
488	*/
489	private void indent() throws IOException {
490	if (prettyPrint && indentString != null && !indentString.isEmpty()) {	1✔
491	for (int i = 0; i < indentDepth; i++) {	1✔
492	writer.write(indentString);	1✔
493	}
494	}
495	}	1✔
496
497	/**
498	* Writes a new line character to the writer.
499	* @throws IOException if an I/O error has occurred
500	*/
501	private void nextLine() throws IOException {
502	if (prettyPrint) {	1✔
503	writer.write("\n");	1✔
504	}
505	}	1✔
506
507	/**
508	* Ensures all buffered data is written to the underlying
509	* {@link Writer} and flushes that writer.
510	* @throws IOException if an I/O error has occurred
511	*/
512	public void flush() throws IOException {
513	writer.flush();	×
514	}	×
515
516	public void close() throws IOException {
517	writer.close();	×
518	}	×
519
520	@Override
521	public String toString() {
522	return writer.toString();	1✔
523	}
524
525	private void checkCircularReference(Object object, Object member) throws IOException {
526	if (object == member \|\| (upperObject != null && upperObject == member)) {	1✔
527	String what;
528	if (pendedName != null) {	1✔
529	what = "member '" + pendedName + "'";	1✔
530	} else {
531	what = "a member";	1✔
532	}
533	throw new IOException("JSON Serialization Failure: " +	1✔
534	"A circular reference was detected while converting " + what);
535	}
536	}	1✔
537
538	/**
539	* Produce a string in double quotes with backslash sequences in all the
540	* right places. A backslash will be inserted within </, allowing JSON
541	* text to be delivered in HTML. In JSON text, a string cannot contain a
542	* control character or an unescaped quote or backslash.
543	* @param string the input String, may be null
544	* @return a String correctly formatted for insertion in a JSON text
545	*/
546	@NonNull
547	private static String escape(String string) {
548	if (string == null \|\| string.isEmpty()) {	1✔
549	return "\"\"";	×
550	}
551
552	int len = string.length();	1✔
553	char b;
554	char c = 0;	1✔
555	String t;
556
557	StringBuilder sb = new StringBuilder(len + 4);	1✔
558	sb.append('"');	1✔
559	for (int i = 0; i < len; i++) {	1✔
560	b = c;	1✔
561	c = string.charAt(i);	1✔
562
563	switch (c) {	1✔
564	case '\\':
565	case '"':
566	sb.append('\\');	×
567	sb.append(c);	×
568	break;	×
569	case '/':
570	if (b == '<') {	×
571	sb.append('\\');	×
572	}
573	sb.append(c);	×
574	break;	×
575	case '\b':
576	sb.append("\\b");	×
577	break;	×
578	case '\t':
579	sb.append("\\t");	×
580	break;	×
581	case '\n':
582	sb.append("\\n");	×
583	break;	×
584	case '\f':
585	sb.append("\\f");	×
586	break;	×
587	case '\r':
588	sb.append("\\r");	×
589	break;	×
590	default:
591	if (c < ' ' \|\| (c >= '\u0080' && c < '\u00a0') \|\| (c >= '\u2000' && c < '\u2100')) {	1✔
592	t = "000" + Integer.toHexString(c);	×
593	sb.append("\\u").append(t.substring(t.length() - 4));	×
594	} else {
595	sb.append(c);	1✔
596	}
597	}
598	}
599	sb.append('"');	1✔
600	return sb.toString();	1✔
601	}
602
603	}

aspectran / aspectran / #4057

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous