iterator() {
82 | int size = sections.size();
83 | return sections.stream()
84 | .map(s -> new Section(s, sections.indexOf(s) == size - 1))
85 | .iterator();
86 | }
87 |
88 | @Override
89 | public boolean equals(Object o) {
90 | if (this == o) return true;
91 | if (o == null || getClass() != o.getClass()) return false;
92 |
93 | Path path = (Path) o;
94 |
95 | if (!sections.equals(path.sections)) return false;
96 | return Objects.equals(attribute, path.attribute);
97 | }
98 |
99 | @Override
100 | public int hashCode() {
101 | int result = sections.hashCode();
102 | result = 31 * result + Objects.hashCode(attribute);
103 | return result;
104 | }
105 |
106 | @Override
107 | public String toString() {
108 | return "/" + String.join("/", sections) + (attribute == null ? "" : "[" + attribute + "]");
109 | }
110 | }
111 |
--------------------------------------------------------------------------------
/xjx-serdes/src/main/java/io/jonasg/xjx/serdes/Section.java:
--------------------------------------------------------------------------------
1 | package io.jonasg.xjx.serdes;
2 |
3 | public record Section(String name, boolean isLeaf) {
4 | }
5 |
--------------------------------------------------------------------------------
/xjx-serdes/src/main/java/io/jonasg/xjx/serdes/Tag.java:
--------------------------------------------------------------------------------
1 | package io.jonasg.xjx.serdes;
2 |
3 | import java.lang.annotation.ElementType;
4 | import java.lang.annotation.Retention;
5 | import java.lang.annotation.RetentionPolicy;
6 | import java.lang.annotation.Target;
7 |
8 | /**
9 | * The {@code Tag} annotation is used to mark a field for XML serialization and deserialization.
10 | * It provides information about the XML path and optional attributes to be used during serialization and deserialization.
11 | *
12 | * Example XML document:
13 | * {@code
14 | *
15 | * Product 1
16 | * Product 2
17 | * Product 3
18 | *
19 | * }
20 | *
21 | * Example Usage:
22 | * {@code
23 | * @Tag(path = "/Products", items = "Name")
24 | * List productNames;
25 | * }
26 | * In this example, the {@code List} field 'productNames' will be serialized to and deserialized from the XML path "/Products/Name".
27 | *
28 | * Example XML for Serialization:
29 | * {@code
30 | *
31 | * Product 1
32 | * Product 2
33 | * Product 3
34 | *
35 | * }
36 | * In this example, when the {@code List} field 'productNames' is serialized, the generated XML will look like the above representation.
37 | *
38 | * Annotation Usage:
39 | *
40 | * - {@code path}: Specifies the Path expression indicating the location of the XML data for serialization and deserialization.
41 | * - {@code attribute}: Specifies the name of an XML attribute to be used during serialization and deserialization (optional).
42 | * - {@code items}: Specifies additional information for serializing and deserializing items within a collection (optional).
43 | *
44 | */
45 | @Retention(RetentionPolicy.RUNTIME)
46 | @Target({ElementType.TYPE, ElementType.FIELD, ElementType.RECORD_COMPONENT})
47 | public @interface Tag {
48 | /**
49 | * Specifies the Path expression indicating the location of the XML data for serialization and deserialization.
50 | *
51 | * @return The Path expression representing the location of the XML data.
52 | */
53 | String path();
54 |
55 | /**
56 | * Specifies the name of an XML attribute to be used during serialization and deserialization (optional).
57 | *
58 | * @return The name of the XML attribute.
59 | */
60 | String attribute() default "";
61 |
62 | /**
63 | * Specifies additional information for serializing and deserializing items within a collection (optional).
64 | *
65 | * @return Additional information for serializing and deserializing items.
66 | */
67 | String items() default "";
68 | }
69 |
--------------------------------------------------------------------------------
/xjx-serdes/src/main/java/io/jonasg/xjx/serdes/TypeMappers.java:
--------------------------------------------------------------------------------
1 | package io.jonasg.xjx.serdes;
2 |
3 | import io.jonasg.xjx.serdes.deserialize.XjxDeserializationException;
4 | import io.jonasg.xjx.serdes.deserialize.config.XjxConfiguration;
5 |
6 | import java.math.BigDecimal;
7 | import java.time.LocalDate;
8 | import java.time.LocalDateTime;
9 | import java.time.ZonedDateTime;
10 | import java.util.HashSet;
11 | import java.util.List;
12 | import java.util.Set;
13 | import java.util.function.Function;
14 |
15 | public final class TypeMappers {
16 |
17 | static List> DOUBLE_TYPES = List.of(double.class, Double.class);
18 | static List> LONG_TYPES = List.of(long.class, Long.class);
19 | static List> INTEGER_TYPES = List.of(int.class, Integer.class);
20 | static List> CHAR_TYPES = List.of(char.class, Character.class);
21 | static List> BOOLEAN_TYPES = List.of(boolean.class, Boolean.class);
22 |
23 | public static Set> TYPES;
24 |
25 | static {
26 | TYPES = new HashSet<>();
27 | TYPES.addAll(INTEGER_TYPES);
28 | TYPES.addAll(DOUBLE_TYPES);
29 | TYPES.addAll(LONG_TYPES);
30 | TYPES.addAll(CHAR_TYPES);
31 | TYPES.addAll(BOOLEAN_TYPES);
32 | TYPES.add(String.class);
33 | TYPES.add(LocalDate.class);
34 | }
35 |
36 | public static Function forType(Class type, XjxConfiguration configuration) {
37 | Function mapper = Function.identity();
38 | if (type.equals(String.class)) {
39 | mapper = String::valueOf;
40 | }
41 | if (INTEGER_TYPES.contains(type)) {
42 | mapper = value -> Integer.parseInt(String.valueOf(value));
43 | }
44 | if (LONG_TYPES.contains(type)) {
45 | mapper = value -> Long.parseLong(String.valueOf(value));
46 | }
47 | if (type.equals(BigDecimal.class)) {
48 | mapper = value -> new BigDecimal(String.valueOf(value));
49 | }
50 | if (DOUBLE_TYPES.contains(type)) {
51 | mapper = value -> Double.valueOf(String.valueOf(value));
52 | }
53 | if (CHAR_TYPES.contains(type)) {
54 | mapper = value -> String.valueOf(value).charAt(0);
55 | }
56 | if (BOOLEAN_TYPES.contains(type)) {
57 | mapper = value -> {
58 | String lowered = String.valueOf(value).toLowerCase();
59 | if (lowered.equals("true") || lowered.equals("yes") || lowered.equals("1")) {
60 | return true;
61 | }
62 | return false;
63 | };
64 | }
65 | if (type.equals(LocalDate.class)) {
66 | mapper = value -> LocalDate.parse(String.valueOf(value));
67 | }
68 | if (type.equals(LocalDateTime.class)) {
69 | mapper = value -> LocalDateTime.parse(String.valueOf(value));
70 | }
71 | if (type.equals(ZonedDateTime.class)) {
72 | mapper = value -> ZonedDateTime.parse(String.valueOf(value));
73 | }
74 | if (type.isEnum()) {
75 | mapper = value -> {
76 | Object enumValue = toEnum(type, String.valueOf(value));
77 | if (enumValue == null && configuration.failOnUnknownEnumValue()) {
78 | throw new XjxDeserializationException("Cannot map value '" + value + "' to enum " + type.getSimpleName());
79 | }
80 | return enumValue;
81 | };
82 | }
83 | return mapper;
84 | }
85 |
86 | @SuppressWarnings("unchecked")
87 | private static > T toEnum(Class type, String value) {
88 | try {
89 | T[] enumConstants = (T[]) type.getEnumConstants();
90 | for (T constant : enumConstants) {
91 | if (value.equals(constant.name())) {
92 | return constant;
93 | }
94 | }
95 | } catch (Exception e) {
96 | throw new RuntimeException(e);
97 | }
98 | return null;
99 | }
100 | }
101 |
--------------------------------------------------------------------------------
/xjx-serdes/src/main/java/io/jonasg/xjx/serdes/XjxSerdes.java:
--------------------------------------------------------------------------------
1 | package io.jonasg.xjx.serdes;
2 |
3 | import java.io.Reader;
4 | import java.io.StringReader;
5 | import java.util.HashMap;
6 | import java.util.Map;
7 | import java.util.function.Consumer;
8 |
9 | import io.jonasg.xjx.sax.SaxParser;
10 | import io.jonasg.xjx.serdes.deserialize.config.ConfigurationBuilder;
11 | import io.jonasg.xjx.serdes.deserialize.MapOf;
12 | import io.jonasg.xjx.serdes.deserialize.MapRootSaxHandler;
13 | import io.jonasg.xjx.serdes.deserialize.PathBasedSaxHandler;
14 | import io.jonasg.xjx.serdes.deserialize.PathWriterIndexFactory;
15 | import io.jonasg.xjx.serdes.deserialize.XjxDeserializationException;
16 | import io.jonasg.xjx.serdes.deserialize.config.XjxConfiguration;
17 | import io.jonasg.xjx.serdes.serialize.XmlNodeStructureFactory;
18 | import io.jonasg.xjx.serdes.serialize.XmlStringBuilder;
19 |
20 | /**
21 | * XjxSerdes provides functionality for serializing and deserializing objects to and from XML.
22 | */
23 | public class XjxSerdes {
24 |
25 | private final SaxParser saxParser;
26 |
27 | private final PathWriterIndexFactory pathWriterIndexFactory;
28 |
29 | private final XmlNodeStructureFactory xmlNodeStructureFactory = new XmlNodeStructureFactory();
30 |
31 | private final XmlStringBuilder xmlStringBuilder;
32 |
33 | private final XjxConfiguration configuration;
34 |
35 | private XjxSerdes(SaxParser saxParser,
36 | XmlStringBuilder xmlStringBuilder,
37 | Consumer configurationBuilder) {
38 | this.configuration = new XjxConfiguration();
39 | configurationBuilder.accept(new ConfigurationBuilder(configuration));
40 | this.saxParser = saxParser;
41 | this.pathWriterIndexFactory = new PathWriterIndexFactory(configuration);
42 | this.xmlStringBuilder = xmlStringBuilder;
43 | }
44 |
45 | /**
46 | * Constructs an XjxSerdes instance with default configurations.
47 | */
48 | public XjxSerdes() {
49 | this(new SaxParser(), new XmlStringBuilder(), (builder) -> {});
50 | }
51 |
52 | /**
53 | * Constructs an XjxSerdes instance with custom configurations.
54 | * @param configurationBuilder The configuration builder to configure the XjxSerdes instance.
55 | */
56 | public XjxSerdes(Consumer configurationBuilder) {
57 | this(new SaxParser(), new XmlStringBuilder(), configurationBuilder);
58 | }
59 |
60 | /**
61 | * Reads XML data and deserializes it into an object of the specified class.
62 | *
63 | * @param data The XML data to read.
64 | * @param clazz The class type to deserialize the XML data into.
65 | * @param The generic type of the class.
66 | * @return The deserialized object.
67 | */
68 | public T read(String data, Class clazz) {
69 | return read(new StringReader(data), clazz);
70 | }
71 |
72 | /**
73 | * Reads XML data from a reader and deserializes it into an object of the specified class.
74 | *
75 | * @param data The reader containing XML data to read.
76 | * @param clazz The class type to deserialize the XML data into.
77 | * @param The generic type of the class.
78 | * @return The deserialized object.
79 | */
80 | public T read(Reader data, Class clazz) {
81 | PathBasedSaxHandler saxHandler = new PathBasedSaxHandler<>((rootTag) -> pathWriterIndexFactory.createIndexForType(clazz, rootTag), this.configuration);
82 | saxParser.parse(data, saxHandler);
83 | return saxHandler.instance();
84 | }
85 |
86 |
87 | /**
88 | * Reads XML data and deserializes it into a map with specified key and value types.
89 | *
90 | * @param data The XML data to read.
91 | * @param mapOf The MapOf instance specifying key and value types.
92 | * @param The type of map keys (only supports String).
93 | * @param The type of map values.
94 | * @return The deserialized map.
95 | * @throws XjxDeserializationException If the map key type is not supported (only supports String).
96 | *
97 | * Example usage:
98 | *
{@code
99 | * MapOf mapOf = new MapOf() {};
100 | * Map deserializedMap = new XjxSerdes().read("...", mapOf);
101 | * }
102 | */
103 | public Map read(String data, MapOf mapOf) {
104 | return read(new StringReader(data), mapOf);
105 | }
106 |
107 | @SuppressWarnings("unchecked")
108 | public Map read(Reader data, MapOf mapOf) {
109 | Class keyType = mapOf.keyType();
110 | Class valueType = mapOf.valueType();
111 | if (keyType == String.class && valueType == Object.class) {
112 | HashMap map = new HashMap<>();
113 | MapRootSaxHandler mapRootSaxHandler = new MapRootSaxHandler(map, true);
114 | saxParser.parse(data, mapRootSaxHandler);
115 | return (Map) map;
116 | }
117 | throw new XjxDeserializationException("Maps only support String as key");
118 | }
119 |
120 | /**
121 | * Writes an object to an XML document.
122 | *
123 | * @param data The object to serialize to XML.
124 | * @param The generic type of the object.
125 | * @return The XML representation of the object.
126 | */
127 | public String write(T data) {
128 | var nodes = xmlNodeStructureFactory.build(data);
129 | return xmlStringBuilder.build(nodes);
130 | }
131 |
132 | }
133 |
--------------------------------------------------------------------------------
/xjx-serdes/src/main/java/io/jonasg/xjx/serdes/deserialize/DeserializationFeature.java:
--------------------------------------------------------------------------------
1 | package io.jonasg.xjx.serdes.deserialize;
2 |
3 | public enum DeserializationFeature {
4 | FAIL_ON_UNMAPPABLE_ENUM_VALUE
5 |
6 | }
7 |
--------------------------------------------------------------------------------
/xjx-serdes/src/main/java/io/jonasg/xjx/serdes/deserialize/LazySupplier.java:
--------------------------------------------------------------------------------
1 | package io.jonasg.xjx.serdes.deserialize;
2 |
3 | import java.util.function.Supplier;
4 |
5 | public class LazySupplier implements Supplier {
6 | private T instance;
7 | private Supplier initializer;
8 |
9 | public LazySupplier(Supplier initializer) {
10 | this.initializer = initializer;
11 | }
12 |
13 | @Override
14 | public T get() {
15 | if (instance == null) {
16 | instance = initializer.get();
17 | }
18 | return instance;
19 | }
20 |
21 | public void reset(Supplier supplier) {
22 | this.instance = null;
23 | this.initializer = supplier;
24 | }
25 | }
26 |
27 |
--------------------------------------------------------------------------------
/xjx-serdes/src/main/java/io/jonasg/xjx/serdes/deserialize/MapAsRoot.java:
--------------------------------------------------------------------------------
1 | package io.jonasg.xjx.serdes.deserialize;
2 |
3 | import java.util.Map;
4 |
5 | public record MapAsRoot(Object root, Map map) {
6 | }
7 |
--------------------------------------------------------------------------------
/xjx-serdes/src/main/java/io/jonasg/xjx/serdes/deserialize/MapOf.java:
--------------------------------------------------------------------------------
1 | package io.jonasg.xjx.serdes.deserialize;
2 |
3 | import java.lang.reflect.ParameterizedType;
4 | import java.lang.reflect.Type;
5 |
6 | public abstract class MapOf {
7 |
8 | protected final Type keyType;
9 |
10 | protected final Type valueType;
11 |
12 | protected MapOf() {
13 | Type superClass = this.getClass().getGenericSuperclass();
14 | this.keyType = ((ParameterizedType) superClass).getActualTypeArguments()[0];
15 | this.valueType = ((ParameterizedType) superClass).getActualTypeArguments()[1];
16 | }
17 |
18 | @SuppressWarnings("unchecked")
19 | public Class keyType() {
20 | return (Class) keyType;
21 | }
22 |
23 | @SuppressWarnings("unchecked")
24 | public Class valueType() {
25 | return (Class) valueType;
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/xjx-serdes/src/main/java/io/jonasg/xjx/serdes/deserialize/MapRootSaxHandler.java:
--------------------------------------------------------------------------------
1 | package io.jonasg.xjx.serdes.deserialize;
2 |
3 | import java.util.HashMap;
4 | import java.util.LinkedHashMap;
5 | import java.util.LinkedList;
6 | import java.util.List;
7 | import java.util.Map;
8 |
9 | import io.jonasg.xjx.sax.Attribute;
10 | import io.jonasg.xjx.sax.SaxHandler;
11 |
12 | public class MapRootSaxHandler implements SaxHandler {
13 |
14 | private final LinkedList> mapsStack;
15 |
16 | private final boolean skipRootTag;
17 |
18 | private Map instance;
19 |
20 | private String characterData;
21 |
22 | private String prevStartTag;
23 |
24 | private String rootTag;
25 |
26 | public MapRootSaxHandler(Map instance) {
27 | this.mapsStack = new LinkedList<>();
28 | this.mapsStack.add(instance);
29 | this.skipRootTag = false;
30 | this.instance = instance;
31 | }
32 |
33 | public MapRootSaxHandler(HashMap instance, boolean skipRootTag) {
34 | this.mapsStack = new LinkedList<>();
35 | this.mapsStack.add(instance);
36 | this.skipRootTag = skipRootTag;
37 | }
38 |
39 | @Override
40 | public void startDocument() {
41 | }
42 |
43 | @Override
44 | public void startTag(String namespace, String name, List attributes) {
45 | if (this.rootTag != null || !skipRootTag) {
46 | Map activeMap = this.mapsStack.getLast();
47 | Map newMap = new LinkedHashMap<>();
48 | activeMap.put(name, newMap);
49 | this.mapsStack.add(newMap);
50 | this.prevStartTag = name;
51 | }
52 | if (this.rootTag == null) {
53 | this.rootTag = name;
54 | }
55 | }
56 |
57 | @Override
58 | public void endTag(String namespace, String name) {
59 | if (name.equals(this.prevStartTag)) {
60 | this.mapsStack.removeLast();
61 | }
62 | if (characterData != null) {
63 | Map currentMap = this.mapsStack.getLast();
64 | currentMap.put(name, characterData);
65 | this.characterData = null;
66 | } else {
67 | this.mapsStack.removeLast();
68 | }
69 | }
70 |
71 | @Override
72 | public void characters(String data) {
73 | this.characterData = data;
74 | }
75 |
76 | public Map instance() {
77 | return instance;
78 | }
79 | }
80 |
--------------------------------------------------------------------------------
/xjx-serdes/src/main/java/io/jonasg/xjx/serdes/deserialize/MapWithTypeInfo.java:
--------------------------------------------------------------------------------
1 | package io.jonasg.xjx.serdes.deserialize;
2 |
3 | import java.util.Map;
4 |
5 | public record MapWithTypeInfo(Map map, Class valueType) {
6 | }
7 |
--------------------------------------------------------------------------------
/xjx-serdes/src/main/java/io/jonasg/xjx/serdes/deserialize/PathBasedSaxHandler.java:
--------------------------------------------------------------------------------
1 | package io.jonasg.xjx.serdes.deserialize;
2 |
3 | import java.util.HashMap;
4 | import java.util.LinkedList;
5 | import java.util.List;
6 | import java.util.Map;
7 | import java.util.function.Function;
8 |
9 | import io.jonasg.xjx.sax.Attribute;
10 | import io.jonasg.xjx.sax.SaxHandler;
11 | import io.jonasg.xjx.serdes.Path;
12 | import io.jonasg.xjx.serdes.deserialize.config.XjxConfiguration;
13 |
14 | public class PathBasedSaxHandler implements SaxHandler {
15 |
16 | private final Function indexSupplier;
17 |
18 | private final XjxConfiguration configuration;
19 |
20 | private final LinkedList