[DEV] update to the mapper concept to simplify interface and set it common

src/org/atriasoft/exml/Exml.java

@@ -7,23 +7,15 @@
 package org.atriasoft.exml;
 
 import java.io.IOException;
-import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
 
 import org.atriasoft.aknot.exception.AknotException;
-import org.atriasoft.aknot.model.InterfaceFactoryAccess;
-import org.atriasoft.aknot.model.ModelType;
-import org.atriasoft.aknot.pojo.IntrospectionObject;
 import org.atriasoft.etk.Uri;
 import org.atriasoft.exml.builder.Builder;
 import org.atriasoft.exml.builder.BuilderGeneric;
-import org.atriasoft.exml.builder.BuilderIntrospection;
-import org.atriasoft.exml.exception.ExmlBuilderException;
 import org.atriasoft.exml.exception.ExmlException;
 import org.atriasoft.exml.exception.ExmlParserErrorMulti;
-import org.atriasoft.exml.generator.GeneratorIntrospection;
 import org.atriasoft.exml.internal.Log;
 import org.atriasoft.exml.model.XmlElement;
 import org.atriasoft.exml.model.XmlNode;
@@ -41,26 +33,6 @@ public class Exml {
 		Log.info("Generated XML : \n" + tmpp.toString());
 	}
 	
-	public static void generate(final Object root, final String rootNodeName, final StringBuilder data) throws ExmlException {
-		GeneratorIntrospection generator;
-		try {
-			generator = new GeneratorIntrospection(ModelType.NORMAL, root.getClass(), rootNodeName);
-			generator.generate(root, data);
-			/*
-			final SerializerXmlIntrospection serializer = new SerializerXmlIntrospection(generator);
-			final ParsingProperty property = new ParsingProperty();
-			property.setDisplayError(true);
-			
-			serializer.generate(root, property, tmpp);
-			*/
-		} catch (final ExmlBuilderException ex) {
-			throw ex;
-		} catch (final Exception e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-	}
-	
 	/**
 	 * Generate a string that contain the created XML
 	 *
@@ -95,16 +67,6 @@ public class Exml {
 		return (XmlElement) parser.parse(dataToParse, property);
 	}
 	
-	public static <T> T[] parse(final Path path, final Class<T> classType, final String rootNodeName) throws ExmlException, ExmlParserErrorMulti, AknotException {
-		String content = null;
-		try {
-			content = Exml.readFile(path, StandardCharsets.UTF_8);
-		} catch (final IOException e) {
-			e.printStackTrace();
-		}
-		return Exml.parse(content, classType, rootNodeName);
-	}
-	
 	public static XmlElement parse(final String data) throws ExmlException, ExmlParserErrorMulti, AknotException {
 		final Builder builder = new BuilderGeneric();
 		final ParseXml parser = new ParseXml(builder);
@@ -113,70 +75,6 @@ public class Exml {
 		return (XmlElement) parser.parse(data, property);
 	}
 	
-	@SuppressWarnings("unchecked")
-	public static <T> T[] parse(final String data, final Class<T> classType, final String rootNodeName) throws ExmlException, ExmlParserErrorMulti, AknotException {
-		Builder builder;
-		try {
-			builder = new BuilderIntrospection(ModelType.ARRAY, classType, rootNodeName);
-			final ParseXml parser = new ParseXml(builder);
-			final ParsingProperty property = new ParsingProperty();
-			property.setDisplayError(true);
-			
-			final IntrospectionObject introspectionObject = (IntrospectionObject) parser.parse(data, property);
-			introspectionObject.generateTheObject();
-			final Object listRet = introspectionObject.getData();
-			if (listRet != null && listRet.getClass().isArray() && listRet.getClass().componentType() == classType) {
-				return (T[]) listRet;
-			}
-			return null;
-		} catch (final ExmlException ex) {
-			ex.printStackTrace();
-			throw ex;
-		}
-	}
-	
-	public static Object[] parse(final String data, final InterfaceFactoryAccess widgetXmlFactory) throws ExmlException, ExmlParserErrorMulti, AknotException {
-		Builder builder;
-		try {
-			builder = new BuilderIntrospection(widgetXmlFactory);
-			final ParseXml parser = new ParseXml(builder);
-			final ParsingProperty property = new ParsingProperty();
-			property.setDisplayError(true);
-			
-			final IntrospectionObject introspectionObject = (IntrospectionObject) parser.parse(data, property);
-			introspectionObject.generateTheObject();
-			final Object listRet = introspectionObject.getData();
-			/*
-			if (listRet != null && listRet.getClass().isArray() && listRet.getClass().componentType() == classType) {
-				return (T[]) listRet;
-			}
-			*/
-			return (Object[]) listRet;
-		} catch (final ExmlException ex) {
-			ex.printStackTrace();
-			throw ex;
-		}
-	}
-	
-	/**
-	 * Load the file that might contain the xml
-	 *
-	 * @param _uri URI of the xml
-	 * @return false : An error occured
-	 * @return true : Parsing is OK
-	 * @throws ExmlException
-	 */
-	/*
-	 * public boolean load( Uri _uri){ // Start loading the XML :
-	 * EXML_VERBOSE("open file (xml) " + _uri); clear(); auto fileIo =
-	 * uri::get(_uri); if (fileIo == null) { Log.error("File Does not exist : " +
-	 * _uri); return false; } if (fileIo->open(io::OpenMode::Read) == false) {
-	 * Log.error("Can not open (r) the file : " + _uri); return false; } // load
-	 * data from the file: String tmpDataUnicode = fileIo->readAllString(); // close
-	 * the file: fileIo->close(); // parse the data: boolean ret =
-	 * parse(tmpDataUnicode); //Display(); return ret; }
-	 */
-	
 	public static XmlElement parse(final Uri data) throws ExmlException, AknotException {
 		final Builder builder = new BuilderGeneric();
 		final ParseXml parser = new ParseXml(builder);
@@ -191,60 +89,5 @@ public class Exml {
 		return (XmlElement) parser.parse(dataToParse, property);
 	}
 	
-	public static <T> T parseOne(final Path path, final Class<T> classType, final String rootNodeName) throws ExmlException, ExmlParserErrorMulti, AknotException {
-		final T[] elements = Exml.parse(path, classType, rootNodeName);
-		if (elements == null || elements.length == 0) {
-			throw new ExmlBuilderException("Error in parsing the file, no node find ...");
-		}
-		if (elements.length > 1) {
-			throw new ExmlBuilderException("Error in parsing the file, More than One node find ...");
-		}
-		return elements[0];
-	}
-	
-	public static <T> T parseOne(final String data, final Class<T> classType, final String rootNodeName) throws ExmlException, ExmlParserErrorMulti, AknotException {
-		final T[] elements = Exml.parse(data, classType, rootNodeName);
-		if (elements == null || elements.length == 0) {
-			throw new ExmlBuilderException("Error in parsing the file, no node find ...");
-		}
-		if (elements.length > 1) {
-			throw new ExmlBuilderException("Error in parsing the file, More than One node find ...");
-		}
-		return elements[0];
-	}
-	
-	private static String readFile(final Path path, final Charset encoding) throws IOException {
-		final byte[] encoded = Files.readAllBytes(path);
-		return new String(encoded, encoding);
-	}
-	
-	public static void store(final Path path, final Object root, final String rootNodeName) throws ExmlException, IOException {
-		final StringBuilder builder = new StringBuilder();
-		Exml.generate(root, rootNodeName, builder);
-		Files.writeString(path, builder.toString());
-	}
-	
-	/**
-	 * Store the Xml in the file
-	 *
-	 * @param _uri URI of the xml
-	 * @return false : An error occured
-	 * @return true : Parsing is OK
-	 */
-	public static void store(final Uri uri, final Object root, final String rootNodeName) throws ExmlException, IOException {
-		final StringBuilder builder = new StringBuilder();
-		Exml.generate(root, rootNodeName, builder);
-		Uri.writeAll(uri, builder.toString());
-	}
-	
-	/*
-	 * public boolean store( Uri _uri){ String createData; if (generate(createData)
-	 * == false) { Log.error("Error while creating the XML: " + _uri); return false;
-	 * } auto fileIo = uri::get(_uri); if (fileIo == null) {
-	 * Log.error("Can not create the uri: " + _uri); return false; } if
-	 * (fileIo->open(io::OpenMode::Write) == false) {
-	 * Log.error("Can not open (r) the file : " + _uri); return false; }
-	 * fileIo->writeAll(createData); fileIo->close(); return true; }
-	 */
 	private Exml() {}
 }

src/org/atriasoft/exml/XmlMapper.java

@@ -0,0 +1,119 @@
+package org.atriasoft.exml;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import org.atriasoft.aknot.exception.AknotException;
+import org.atriasoft.aknot.model.ModelType;
+import org.atriasoft.aknot.pojo.IntrospectionObject;
+import org.atriasoft.etk.Uri;
+import org.atriasoft.exml.builder.Builder;
+import org.atriasoft.exml.builder.BuilderIntrospection;
+import org.atriasoft.exml.exception.ExmlBuilderException;
+import org.atriasoft.exml.exception.ExmlException;
+import org.atriasoft.exml.exception.ExmlNodeDoesNotExist;
+import org.atriasoft.exml.generator.GeneratorIntrospection;
+import org.atriasoft.exml.internal.Log;
+import org.atriasoft.exml.parser.ParseXml;
+import org.atriasoft.exml.parser.ParsingProperty;
+
+public class XmlMapper {
+	
+	private static String readFile(final Path path, final Charset encoding) throws IOException {
+		final byte[] encoded = Files.readAllBytes(path);
+		return new String(encoded, encoding);
+	}
+	
+	public XmlMapper() {
+		
+	}
+	
+	public void generate(final Object root, final StringBuilder data) throws ExmlException, AknotException {
+		GeneratorIntrospection generator;
+		try {
+			generator = new GeneratorIntrospection(ModelType.NORMAL, root.getClass());
+			generator.generate(root, data);
+		} catch (final ExmlBuilderException ex) {
+			throw ex;
+		} catch (final Exception e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+	
+	/**
+	 * Parse a single root node that have the name of the Class Parsed:
+	 * <pre>
+	 *   &gt;ClassName a="kk" ... &lt;
+	 *     ...
+	 *   &gt;/ClassName&lt;
+	 * </pre>
+	 * @param <T> Object type to parse
+	 * @param data Data String to Parse
+	 * @param classType Object Class to introspect data (POJO)
+	 * @return The Object parsed or null
+	 */
+	@SuppressWarnings("unchecked")
+	public <T> T parse(final String data, final Class<T> classType) throws ExmlException, ExmlNodeDoesNotExist, AknotException {
+		Builder builder;
+		try {
+			builder = new BuilderIntrospection(ModelType.NORMAL, classType);
+			final ParseXml parser = new ParseXml(builder);
+			final ParsingProperty property = new ParsingProperty();
+			property.setDisplayError(true);
+			
+			final IntrospectionObject introspectionObject = (IntrospectionObject) parser.parse(data, property);
+			introspectionObject.generateTheObject();
+			final Object listRet = introspectionObject.getData();
+			if (listRet != null && !listRet.getClass().isArray() && listRet.getClass().componentType() == classType) {
+				return (T) listRet;
+			} else if (listRet != null && listRet.getClass().isArray() && listRet.getClass().componentType() == classType) {
+				final T[] tmp = (T[]) listRet;
+				if (tmp.length >= 1) {
+					return tmp[0];
+				}
+			}
+			return null;
+		} catch (final ExmlException ex) {
+			ex.printStackTrace();
+			throw ex;
+		}
+	}
+	
+	public <T> T read(final Class<T> classType, final Path path) throws ExmlException, AknotException, IOException {
+		String content = null;
+		try {
+			content = readFile(path, StandardCharsets.UTF_8);
+		} catch (final IOException e) {
+			e.printStackTrace();
+		}
+		return parse(content, classType);
+	}
+	
+	public <T> T read(final Class<T> classType, final Uri uri) throws ExmlException, AknotException, IOException {
+		
+		final byte[] elemData = Uri.getAllData(uri);
+		if (elemData == null) {
+			Log.error("Can not read the Stream : " + uri);
+			return null;
+		}
+		final String content = new String(elemData);
+		return parse(content, classType);
+	}
+	
+	public void store(final Object root, final Path path) throws ExmlException, AknotException, IOException {
+		final StringBuilder builder = new StringBuilder();
+		generate(root, builder);
+		Files.writeString(path, builder.toString());
+	}
+	
+	public void store(final Object root, final Uri uri) throws ExmlException, AknotException, IOException {
+		final StringBuilder builder = new StringBuilder();
+		generate(root, builder);
+		Uri.writeAll(uri, builder.toString());
+	}
+	
+}

src/org/atriasoft/exml/builder/BuilderIntrospection.java

@@ -13,6 +13,7 @@ import org.atriasoft.aknot.pojo.IntrospectionObject;
 import org.atriasoft.exml.exception.ExmlAttributeDoesNotExist;
 import org.atriasoft.exml.exception.ExmlBuilderException;
 import org.atriasoft.exml.exception.ExmlException;
+import org.atriasoft.exml.exception.ExmlNodeDoesNotExist;
 import org.atriasoft.exml.internal.Log;
 
 public class BuilderIntrospection implements Builder {
@@ -24,6 +25,7 @@ public class BuilderIntrospection implements Builder {
 	final InterfaceFactoryAccess factory;
 	
 	public BuilderIntrospection(final InterfaceFactoryAccess factory) throws ExmlException, AknotException {
+		Log.critical("is it used ????");
 		this.factory = factory;
 		this.rootNodeName = null;
 		this.rootClassType = null;
@@ -32,7 +34,15 @@ public class BuilderIntrospection implements Builder {
 		}
 	}
 	
+	public BuilderIntrospection(final ModelType model, final Class<?> classType) throws ExmlException, AknotException {
+		this.factory = null;
+		this.rootClassType = classType;
+		final IntrospectionModel typeModel = this.cacheModel.findOrCreate(model, null, classType);
+		this.rootNodeName = typeModel.getNames()[0];
+	}
+	
 	public BuilderIntrospection(final ModelType model, final Class<?> classType, final String rootNodeName) throws ExmlException, AknotException {
+		Log.critical("is it used ????");
 		this.factory = null;
 		this.rootNodeName = rootNodeName;
 		this.rootClassType = classType;
@@ -101,8 +111,12 @@ public class BuilderIntrospection implements Builder {
 				Log.debug("Ignore node: '" + nodeName + "' Does not exist...");
 				return null;
 			}
+			try {
 				typeClass = introspectionObject.getTypeOfSubNode(nodeName);
 				listTreeName = introspectionObject.getTreeNameOfSubNode(nodeName);
+			} catch (final AknotException e) {
+				throw new ExmlNodeDoesNotExist("Node does not exist: " + e.getMessage());
+			}
 		}
 		if (typeClass != null) {
 			// specific case for List ==> need to get the subType in introspection ...
@@ -120,7 +134,12 @@ public class BuilderIntrospection implements Builder {
 				return new IntrospectionObject(inferData);
 			}
 			if (List.class.isAssignableFrom(typeClass)) {
-				final Class<?> subTypeClass = introspectionObject.getTypeOfSubNodeSubType(nodeName);
+				Class<?> subTypeClass = null;
+				try {
+					subTypeClass = introspectionObject.getTypeOfSubNodeSubType(nodeName);
+				} catch (final AknotException e) {
+					throw new ExmlNodeDoesNotExist("Node does not exist: " + e.getMessage());
+				}
 				Log.verbose("Create List new 'SUB' class: '" + typeClass.getCanonicalName() + "' for node '" + nodeName + "'");
 				IntrospectionModel inferData = null;
 				if (listTreeName == null) {

src/org/atriasoft/exml/generator/GeneratorIntrospection.java

@@ -22,12 +22,13 @@ public class GeneratorIntrospection implements Generator {
 	final Class<?> rootClassType;
 	final String rootNodeName;
 	
-	public GeneratorIntrospection(final ModelType model, final Class<?> classType, final String rootNodeName) throws Exception {
-		this.rootNodeName = rootNodeName;
+	public GeneratorIntrospection(final ModelType model, final Class<?> classType) throws Exception {
 		this.rootClassType = classType;
 		final MapKey key = new MapKey(model, classType);
 		// TODO pb if it is a List or an Array ...
-		this.elements.put(key, IntrospectionModelFactory.createModel(key));
+		final IntrospectionModel typeModel = IntrospectionModelFactory.createModel(key);
+		this.elements.put(key, typeModel);
+		this.rootNodeName = typeModel.getNames()[0];
 	}
 	
 	private <T> String autoArrayToString(final Class<T> clazz, final Object inData, final IntrospectionModel model) throws ExmlBuilderException, AknotException {

src/org/atriasoft/exml/parser/ParseXml.java

@@ -30,12 +30,7 @@ public class ParseXml {
 			}
 			lastElementName = iii;
 		}
-		String name = data.substring(pos.value, lastElementName + 1);
-		if (parsingProperty.getStoreMode() == StoreMode.LOWERCASE) {
-			name = name.toLowerCase();
-		} else if (parsingProperty.getStoreMode() == StoreMode.UPPERCASE) {
-			name = name.toUpperCase();
-		}
+		final String name = data.substring(pos.value, lastElementName + 1);
 		
 		// TODO check if in the current list of attribute one is not currently set with this value...
 		
@@ -452,12 +447,7 @@ public class ParseXml {
 						endPosName = jjj;
 						tmpPos.check(data.charAt(jjj));
 					}
-					String tmpname = data.substring(iii + white + 2, endPosName + 1);
-					if (parsingProperty.getStoreMode() == StoreMode.LOWERCASE) {
-						tmpname = tmpname.toLowerCase();
-					} else if (parsingProperty.getStoreMode() == StoreMode.UPPERCASE) {
-						tmpname = tmpname.toUpperCase();
-					}
+					final String tmpname = data.substring(iii + white + 2, endPosName + 1);
 					// Find declaration marker
 					final Object declaration = this.builder.newDeclaration(parent, tmpname);
 					filePos.add(tmpPos);
@@ -605,13 +595,8 @@ public class ParseXml {
 						endPosName = jjj;
 						tmpPos.check(data.charAt(jjj));
 					}
-					String tmpname = data.substring(iii + white + 1, endPosName + 1);
+					final String tmpname = data.substring(iii + white + 1, endPosName + 1);
 					final String tmpnameOriginal = tmpname;
-					if (parsingProperty.getStoreMode() == StoreMode.LOWERCASE) {
-						tmpname = tmpname.toLowerCase();
-					} else if (parsingProperty.getStoreMode() == StoreMode.UPPERCASE) {
-						tmpname = tmpname.toUpperCase();
-					}
 					
 					Log.debug("find node named : '" + tmpname + "'");
 					// find text:

src/org/atriasoft/exml/parser/ParsingProperty.java

@@ -15,8 +15,6 @@ public class ParsingProperty {
 	private final List<ExmlParserError> errors = new ArrayList<>();
 	/// Permissive XML parsing (allows some errors must not be critical).
 	private boolean permisiveXML = false;
-	// Mode to store the Element name or the Attibute name
-	private StoreMode storeMode = StoreMode.NORMAL;
 	/// throw when an error when it is detected (if permissive XML it throw only at the end of parsing).
 	private boolean throwOnError = true;
 	/// write error when not throw on error.
@@ -101,14 +99,6 @@ public class ParsingProperty {
 		return Collections.unmodifiableList(this.errors);
 	}
 	
-	/**
-	 * Get the current storing mode
-	 * @return store element and attribute values
-	 */
-	public StoreMode getStoreMode() {
-		return this.storeMode;
-	}
-	
 	/**
 	 * Check is error has been detected
 	 * @return true if some error are stored.
@@ -157,14 +147,6 @@ public class ParsingProperty {
 		this.permisiveXML = permisiveXML;
 	}
 	
-	/**
-	 * Set the new storing mode for Element and Attributes
-	 * @param storeMode new Storing mode
-	 */
-	public void setStoreMode(final StoreMode storeMode) {
-		this.storeMode = storeMode;
-	}
-	
 	/**
 	 * Set throwing on error (if permissive, it throw at the end of parsing)
 	 * @param throwOnError true if it throw on error.

src/org/atriasoft/exml/parser/StoreMode.java

@@ -1,7 +0,0 @@
-package org.atriasoft.exml.parser;
-
-public enum StoreMode {
-	NORMAL,
-	UPPERCASE,
-	LOWERCASE,
-}

test/src/test/atriasoft/exml/ExmlTestIntrospection.java

@@ -7,10 +7,9 @@ package test.atriasoft.exml;
 
 import java.util.Arrays;
 
-import org.atriasoft.exml.Exml;
+import org.atriasoft.exml.XmlMapper;
 import org.atriasoft.exml.exception.ExmlBuilderException;
 import org.atriasoft.exml.exception.ExmlParserErrorMulti;
-
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -32,34 +31,39 @@ public class ExmlTestIntrospection {
 	public void test1() throws ExmlParserErrorMulti, ExmlBuilderException {
 		
 		//@formatter:off
-		final String dataToParse = "<elem\n" 
-				+ " memberByte=\"12\"\n"
-				+ " memberShort=\"1223\"\n"
-				+ " memberInteger=\"4541542\"\n"
-				+ " memberLong = \"4564654654\"\n"
-				+ " memberBoolean = \"true\" \n"
-				+ " memberByteClass = \"55\" \n"
-				+ " memberShortClass = \"1523\" \n"
-				+ " memberIntegerClass = \"4654654\" \n"
-				+ " memberLongClass = \"545645645454\"\n"
-				+ " memberBooleanClass = \"true\" \n"
-				+ " memberStringClass = \"sdfgsdkjfglksqjéé\"\n"
-				+ " memberArrayByte=\"12; 15;123; 100; 2\"\n"
-				+ " memberArrayByteClass=\"\t\t\r\n 12;1; 100;122\"\n"
-				+ " memberArrayShort=\"1245;1894; -100;-12542\"\n"
-				+ " memberArrayShortClass=\"-1245;-1894; 0;2542;15615\"\n"
-				+ " memberArrayInteger=\"123456;-654987\"\n"
-				+ " memberArrayIntegerClass=\"1567845;45621354;-5646544\"\n"
-				+ " memberArrayLong=\"1651324654;65421351685;-5\"\n"
-				+ " memberArrayLongClass=\"6746541351;546546546;564654654;654654654654;-45546\"\n"
-				+ " memberArrayBoolean=\"true; true; false\"\n"
-				+ " memberArrayBooleanClass=\"false; false; true; true\"\n"
-				+ "/>\n";
+		final String dataToParse = """
+			<elem
+			 memberByte="12"
+			 memberShort="1223"
+			 memberInteger="4541542"
+			 memberLong = "4564654654"
+			 memberBoolean = "true"\s
+			 memberByteClass = "55"\s
+			 memberShortClass = "1523"\s
+			 memberIntegerClass = "4654654"\s
+			 memberLongClass = "545645645454"
+			 memberBooleanClass = "true"\s
+			 memberStringClass = "sdfgsdkjfglksqjéé"
+			 memberArrayByte="12; 15;123; 100; 2"
+			 memberArrayByteClass="
+		\n 12;1; 100;122"
+			 memberArrayShort="1245;1894; -100;-12542"
+			 memberArrayShortClass="-1245;-1894; 0;2542;15615"
+			 memberArrayInteger="123456;-654987"
+			 memberArrayIntegerClass="1567845;45621354;-5646544"
+			 memberArrayLong="1651324654;65421351685;-5"
+			 memberArrayLongClass="6746541351;546546546;564654654;654654654654;-45546"
+			 memberArrayBoolean="true; true; false"
+			 memberArrayBooleanClass="false; false; true; true"
+			/>
+			""";
 		//@formatter:on
 		
-		final ClassPublicMemberOnly[] root = Assertions.assertDoesNotThrow(() -> Exml.parse(dataToParse, ClassPublicMemberOnly.class, "elem"));
-		Assertions.assertEquals(1, root.length);
-		final ClassPublicMemberOnly elem = root[0];
+		final ClassPublicMemberOnly elem = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataToParse, ClassPublicMemberOnly.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals((byte) 12, elem.memberByte);
 		Assertions.assertEquals((short) 1223, elem.memberShort);
 		Assertions.assertEquals(4541542, elem.memberInteger);
@@ -116,34 +120,38 @@ public class ExmlTestIntrospection {
 	@Test
 	public void test2() {
 		//@formatter:off
-		final String dataToParse = "<elem\n"
-				+ " memberByte=\"12\"\n"
-				+ " memberShort=\"1223\"\n"
-				+ " memberInteger=\"4541542\"\n"
-				+ " memberLong = \"4564654654\"\n"
-				+ " memberBoolean = \"true\" \n"
-				+ " memberByteClass = \"55\" \n"
-				+ " memberShortClass = \"1523\" \n"
-				+ " memberIntegerClass = \"4654654\" \n"
-				+ " memberLongClass = \"545645645454\"\n"
-				+ " memberBooleanClass = \"true\" \n"
-				+ " memberStringClass = \"sdfgsdkjfglksqjéé\"\n"
-				+ " memberArrayByte=\"12; 15;123; 100; 2\"\n"
-				+ " memberArrayByteClass=\"\t\t\r\n 12;1; 100;122\"\n"
-				+ " memberArrayShort=\"1245;1894; -100;-12542\"\n"
-				+ " memberArrayShortClass=\"-1245;-1894; 0;2542;15615\"\n"
-				+ " memberArrayInteger=\"123456;-654987\"\n"
-				+ " memberArrayIntegerClass=\"1567845;45621354;-5646544\"\n"
-				+ " memberArrayLong=\"1651324654;65421351685;-5\"\n"
-				+ " memberArrayLongClass=\"6746541351;546546546;564654654;654654654654;-45546\"\n"
-				+ " memberArrayBoolean=\"true; true; false\"\n"
-				+ " memberArrayBooleanClass=\"false; false; true; true\"\n"
-				+ "/>\n";
+		final String dataToParse = """
+			<elem
+			 memberByte="12"
+			 memberShort="1223"
+			 memberInteger="4541542"
+			 memberLong = "4564654654"
+			 memberBoolean = "true"\s
+			 memberByteClass = "55"\s
+			 memberShortClass = "1523"\s
+			 memberIntegerClass = "4654654"\s
+			 memberLongClass = "545645645454"
+			 memberBooleanClass = "true"\s
+			 memberStringClass = "sdfgsdkjfglksqjéé"
+			 memberArrayByte="12; 15;123; 100; 2"
+			 memberArrayByteClass="
+		\n 12;1; 100;122"
+			 memberArrayShort="1245;1894; -100;-12542"
+			 memberArrayShortClass="-1245;-1894; 0;2542;15615"
+			 memberArrayInteger="123456;-654987"
+			 memberArrayIntegerClass="1567845;45621354;-5646544"
+			 memberArrayLong="1651324654;65421351685;-5"
+			 memberArrayLongClass="6746541351;546546546;564654654;654654654654;-45546"
+			 memberArrayBoolean="true; true; false"
+			 memberArrayBooleanClass="false; false; true; true"
+			/>
+			""";
 		//@formatter:on
-		final ClassPublicMethodOnly[] root = Assertions.assertDoesNotThrow(() -> Exml.parse(dataToParse, ClassPublicMethodOnly.class, "elem"));
-		Assertions.assertEquals(1, root.length);
-		
-		final ClassPublicMethodOnly elem = root[0];
+		final ClassPublicMethodOnly elem = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataToParse, ClassPublicMethodOnly.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals((byte) 12, elem.getMemberByte());
 		Assertions.assertEquals((short) 1223, elem.getMemberShort());
 		Assertions.assertEquals(4541542, elem.getMemberInteger());
@@ -199,73 +207,77 @@ public class ExmlTestIntrospection {
 	@Test
 	public void test3() {
 		//@formatter:off
-		final String dataToParse = "<elem>\n"
-				+ " <memberByte>12</memberByte>\n"
-				+ " <memberShort>1223</memberShort>\n"
-				+ " <memberInteger>4541542</memberInteger>\n"
-				+ " <memberLong>4564654654</memberLong>\n"
-				+ " <memberBoolean>true</memberBoolean>\n"
-				+ " <memberByteClass>55</memberByteClass>\n"
-				+ " <memberShortClass>1523</memberShortClass>\n"
-				+ " <memberIntegerClass>4654654</memberIntegerClass>\n"
-				+ " <memberLongClass>545645645454</memberLongClass>\n"
-				+ " <memberBooleanClass>true</memberBooleanClass>\n"
-				+ " <memberStringClass>sdfgsdkjfglksqjéé</memberStringClass>\n"
-				+ " <memberArrayByte>12</memberArrayByte>\n"
-				+ " <memberArrayByte>15</memberArrayByte>\n"
-				+ " <memberArrayByte>123</memberArrayByte>\n"
-				+ " <memberArrayByte>100</memberArrayByte>\n"
-				+ " <memberArrayByte>2</memberArrayByte>\n"
-				+ " <memberArrayByteClass>\t\t\r\n 12</memberArrayByteClass>\n"
-				+ " <memberArrayByteClass>1</memberArrayByteClass>\n"
-				+ " <memberArrayByteClass> 100</memberArrayByteClass>\n"
-				+ " <memberArrayByteClass>122</memberArrayByteClass>\n"
-				+ " <memberArrayShort>1245</memberArrayShort>\n"
-				+ " <memberArrayShort>1894</memberArrayShort>\n"
-				+ " <memberArrayShort> -100</memberArrayShort>\n"
-				+ " <memberArrayShort>-12542</memberArrayShort>\n"
-				+ " <memberArrayShortClass>-1245</memberArrayShortClass>\n"
-				+ " <memberArrayShortClass>-1894</memberArrayShortClass>\n"
-				+ " <memberArrayShortClass> 0</memberArrayShortClass>\n"
-				+ " <memberArrayShortClass>2542</memberArrayShortClass>\n"
-				+ " <memberArrayShortClass>15615</memberArrayShortClass>\n"
-				+ " <memberArrayInteger>123456</memberArrayInteger>\n"
-				+ " <memberArrayInteger>-654987</memberArrayInteger>\n"
-				+ " <memberArrayIntegerClass>1567845</memberArrayIntegerClass>\n"
-				+ " <memberArrayIntegerClass>45621354</memberArrayIntegerClass>\n"
-				+ " <memberArrayIntegerClass>-5646544</memberArrayIntegerClass>\n"
-				+ " <memberArrayLong>1651324654</memberArrayLong>\n"
-				+ " <memberArrayLong>65421351685</memberArrayLong>\n"
-				+ " <memberArrayLong>-5</memberArrayLong>\n"
-				+ " <memberArrayLongClass>6746541351</memberArrayLongClass>\n"
-				+ " <memberArrayLongClass>546546546</memberArrayLongClass>\n"
-				+ " <memberArrayLongClass>564654654</memberArrayLongClass>\n"
-				+ " <memberArrayLongClass>654654654654</memberArrayLongClass>\n"
-				+ " <memberArrayLongClass>-45546</memberArrayLongClass>\n"
-				+ " <memberArrayBoolean>true</memberArrayBoolean>\n"
-				+ " <memberArrayBoolean> true</memberArrayBoolean>\n"
-				+ " <memberArrayBoolean>false</memberArrayBoolean>\n"
-				+ " <memberArrayBooleanClass>false</memberArrayBooleanClass>\n"
-				+ " <memberArrayBooleanClass> false</memberArrayBooleanClass>\n"
-				+ " <memberArrayBooleanClass>true</memberArrayBooleanClass>\n"
-				+ " <memberArrayBooleanClass> true</memberArrayBooleanClass>\n"
-				+ " <memberListByteClass>55 </memberListByteClass>\n"
-				+ " <memberListByteClass>  -53 </memberListByteClass>\n"
-				+ " <memberListShortClass> 31632</memberListShortClass>\n"
-				+ " <memberListShortClass>-32100 </memberListShortClass>\n"
-				+ " <memberListIntegerClass>15612 </memberListIntegerClass>\n"
-				+ " <memberListIntegerClass>  542 </memberListIntegerClass>\n"
-				+ " <memberListLongClass>16521 </memberListLongClass>\n"
-				+ " <memberListLongClass>  4654 </memberListLongClass>\n"
-				+ " <memberListLongClass>9875546 </memberListLongClass>\n"
-				+ " <memberListBooleanClass> true</memberListBooleanClass>\n"
-				+ " <memberListBooleanClass>false </memberListBooleanClass>\n"
-				+ "</elem>\n";
+		final String dataToParse = """
+			<elem>
+			 <memberByte>12</memberByte>
+			 <memberShort>1223</memberShort>
+			 <memberInteger>4541542</memberInteger>
+			 <memberLong>4564654654</memberLong>
+			 <memberBoolean>true</memberBoolean>
+			 <memberByteClass>55</memberByteClass>
+			 <memberShortClass>1523</memberShortClass>
+			 <memberIntegerClass>4654654</memberIntegerClass>
+			 <memberLongClass>545645645454</memberLongClass>
+			 <memberBooleanClass>true</memberBooleanClass>
+			 <memberStringClass>sdfgsdkjfglksqjéé</memberStringClass>
+			 <memberArrayByte>12</memberArrayByte>
+			 <memberArrayByte>15</memberArrayByte>
+			 <memberArrayByte>123</memberArrayByte>
+			 <memberArrayByte>100</memberArrayByte>
+			 <memberArrayByte>2</memberArrayByte>
+			 <memberArrayByteClass>
+		\n 12</memberArrayByteClass>
+			 <memberArrayByteClass>1</memberArrayByteClass>
+			 <memberArrayByteClass> 100</memberArrayByteClass>
+			 <memberArrayByteClass>122</memberArrayByteClass>
+			 <memberArrayShort>1245</memberArrayShort>
+			 <memberArrayShort>1894</memberArrayShort>
+			 <memberArrayShort> -100</memberArrayShort>
+			 <memberArrayShort>-12542</memberArrayShort>
+			 <memberArrayShortClass>-1245</memberArrayShortClass>
+			 <memberArrayShortClass>-1894</memberArrayShortClass>
+			 <memberArrayShortClass> 0</memberArrayShortClass>
+			 <memberArrayShortClass>2542</memberArrayShortClass>
+			 <memberArrayShortClass>15615</memberArrayShortClass>
+			 <memberArrayInteger>123456</memberArrayInteger>
+			 <memberArrayInteger>-654987</memberArrayInteger>
+			 <memberArrayIntegerClass>1567845</memberArrayIntegerClass>
+			 <memberArrayIntegerClass>45621354</memberArrayIntegerClass>
+			 <memberArrayIntegerClass>-5646544</memberArrayIntegerClass>
+			 <memberArrayLong>1651324654</memberArrayLong>
+			 <memberArrayLong>65421351685</memberArrayLong>
+			 <memberArrayLong>-5</memberArrayLong>
+			 <memberArrayLongClass>6746541351</memberArrayLongClass>
+			 <memberArrayLongClass>546546546</memberArrayLongClass>
+			 <memberArrayLongClass>564654654</memberArrayLongClass>
+			 <memberArrayLongClass>654654654654</memberArrayLongClass>
+			 <memberArrayLongClass>-45546</memberArrayLongClass>
+			 <memberArrayBoolean>true</memberArrayBoolean>
+			 <memberArrayBoolean> true</memberArrayBoolean>
+			 <memberArrayBoolean>false</memberArrayBoolean>
+			 <memberArrayBooleanClass>false</memberArrayBooleanClass>
+			 <memberArrayBooleanClass> false</memberArrayBooleanClass>
+			 <memberArrayBooleanClass>true</memberArrayBooleanClass>
+			 <memberArrayBooleanClass> true</memberArrayBooleanClass>
+			 <memberListByteClass>55 </memberListByteClass>
+			 <memberListByteClass>  -53 </memberListByteClass>
+			 <memberListShortClass> 31632</memberListShortClass>
+			 <memberListShortClass>-32100 </memberListShortClass>
+			 <memberListIntegerClass>15612 </memberListIntegerClass>
+			 <memberListIntegerClass>  542 </memberListIntegerClass>
+			 <memberListLongClass>16521 </memberListLongClass>
+			 <memberListLongClass>  4654 </memberListLongClass>
+			 <memberListLongClass>9875546 </memberListLongClass>
+			 <memberListBooleanClass> true</memberListBooleanClass>
+			 <memberListBooleanClass>false </memberListBooleanClass>
+			</elem>
+			""";
 		//@formatter:on
-		final ClassPublicMethodeNode[] root = Assertions.assertDoesNotThrow(() -> Exml.parse(dataToParse, ClassPublicMethodeNode.class, "elem"));
-		Assertions.assertEquals(1, root.length);
-		
-		final ClassPublicMethodeNode elem = root[0];
+		final ClassPublicMethodeNode elem = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataToParse, ClassPublicMethodeNode.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals((byte) 12, elem.getMemberByte());
 		Assertions.assertEquals((short) 1223, elem.getMemberShort());
 		Assertions.assertEquals(4541542, elem.getMemberInteger());
@@ -321,27 +333,30 @@ public class ExmlTestIntrospection {
 	@Test
 	public void test4() {
 		//@formatter:off
-		final String dataToParse = "<elem>\n"
-				+ " <memberArrayByte>\n"
-				+ " 	<value>12</value>\n"
-				+ " 	<value>15</value>\n"
-				+ " 	<value>123</value>\n"
-				+ " 	<value>100</value>\n"
-				+ " 	<value>2</value>\n"
-				+ " </memberArrayByte>\n"
-				+ " <memberListByte>\n"
-				+ " 	<elem>-12</elem>\n"
-				+ " 	<elem>-15</elem>\n"
-				+ " 	<elem>-123</elem>\n"
-				+ " 	<elem>-100</elem>\n"
-				+ " 	<elem>-2</elem>\n"
-				+ " </memberListByte>\n"
-				+ "</elem>\n";
+		final String dataToParse = """
+			<elem>
+			 <memberArrayByte>
+			 	<value>12</value>
+			 	<value>15</value>
+			 	<value>123</value>
+			 	<value>100</value>
+			 	<value>2</value>
+			 </memberArrayByte>
+			 <memberListByte>
+			 	<elem>-12</elem>
+			 	<elem>-15</elem>
+			 	<elem>-123</elem>
+			 	<elem>-100</elem>
+			 	<elem>-2</elem>
+			 </memberListByte>
+			</elem>
+			""";
 		//@formatter:on
-		final ClassPublicMethodeStructured[] root = Assertions.assertDoesNotThrow(() -> Exml.parse(dataToParse, ClassPublicMethodeStructured.class, "elem"));
-		Assertions.assertEquals(1, root.length);
-
-		final ClassPublicMethodeStructured elem = root[0];
+		final ClassPublicMethodeStructured elem = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataToParse, ClassPublicMethodeStructured.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, elem.getMemberArrayByte().length);
 		Assertions.assertEquals((byte) 12, elem.getMemberArrayByte()[0]);
 		Assertions.assertEquals((byte) 15, elem.getMemberArrayByte()[1]);
@@ -359,15 +374,17 @@ public class ExmlTestIntrospection {
 	@Test
 	public void test5() {
 		//@formatter:off
-		final String dataToParse = "<elem>\n"
-				+ " <data>PLIF</data>\n"
-				+ "</elem>\n";
+		final String dataToParse = """
+			<elem>
+			 <data>PLIF</data>
+			</elem>
+			""";
 		//@formatter:on
-		final ClassMethodEnum[] root = Assertions.assertDoesNotThrow(() -> Exml.parse(dataToParse, ClassMethodEnum.class, "elem"));
-		Assertions.assertEquals(1, root.length);
-		
-		final ClassMethodEnum elem = root[0];
+		final ClassMethodEnum elem = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataToParse, ClassMethodEnum.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(SimpleEnum.PLIF, elem.getData());
 	}
 }
-

test/src/test/atriasoft/exml/ExmlTestIntrospectionBoolean.java

@@ -7,9 +7,9 @@ package test.atriasoft.exml;
 
 import java.util.List;
 
-import org.atriasoft.aknot.annotation.AknotList;
 import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
-import org.atriasoft.exml.Exml;
+import org.atriasoft.aknot.annotation.AknotList;
+import org.atriasoft.exml.XmlMapper;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -183,11 +183,11 @@ public class ExmlTestIntrospectionBoolean {
 		elem.values = new Boolean[] { false, false, true, false, true };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeBooleanStructured>
 					<values>
 						<elem>false</elem>
 						<elem>false</elem>
@@ -195,9 +195,13 @@ public class ExmlTestIntrospectionBoolean {
 						<elem>false</elem>
 						<elem>true</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestArrayNodeBooleanStructured>""", dataTest);
 		
-		final TestArrayNodeBooleanStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeBooleanStructured.class, ExmlTestIntrospectionBoolean.NODE_NAME));
+		final TestArrayNodeBooleanStructured root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeBooleanStructured.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(false, root.values[0]);
 		Assertions.assertEquals(false, root.values[1]);
@@ -212,11 +216,11 @@ public class ExmlTestIntrospectionBoolean {
 		elem.values = List.of(false, false, true, false, true);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeBooleanStructured>
 					<values>
 						<elem>false</elem>
 						<elem>false</elem>
@@ -224,9 +228,13 @@ public class ExmlTestIntrospectionBoolean {
 						<elem>false</elem>
 						<elem>true</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestListNodeBooleanStructured>""", dataTest);
 		
-		final TestListNodeBooleanStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeBooleanStructured.class, ExmlTestIntrospectionBoolean.NODE_NAME));
+		final TestListNodeBooleanStructured root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeBooleanStructured.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.size());
 		Assertions.assertEquals(false, root.values.get(0));
 		Assertions.assertEquals(false, root.values.get(1));
@@ -241,12 +249,16 @@ public class ExmlTestIntrospectionBoolean {
 		elem.values = new Boolean[] { false, false, true, false, true };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"false;false;true;false;true\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayBoolean values=\"false;false;true;false;true\"/>", dataTest);
 		
-		final TestArrayBoolean root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayBoolean.class, ExmlTestIntrospectionBoolean.NODE_NAME));
+		final TestArrayBoolean root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayBoolean.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(false, root.values[0]);
 		Assertions.assertEquals(false, root.values[1]);
@@ -261,12 +273,16 @@ public class ExmlTestIntrospectionBoolean {
 		elem.setValues(new Boolean[] { false, false, true, false, true });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"false;false;true;false;true\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayBooleanFunc values=\"false;false;true;false;true\"/>", dataTest);
 		
-		final TestArrayBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayBooleanFunc.class, ExmlTestIntrospectionBoolean.NODE_NAME));
+		final TestArrayBooleanFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayBooleanFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals(false, root.getValues()[0]);
 		Assertions.assertEquals(false, root.getValues()[1]);
@@ -281,19 +297,23 @@ public class ExmlTestIntrospectionBoolean {
 		elem.values = new Boolean[] { false, false, true, false, true };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeBoolean>
 					<values>false</values>
 					<values>false</values>
 					<values>true</values>
 					<values>false</values>
 					<values>true</values>
-				</elem>""", dataTest);
+				</TestArrayNodeBoolean>""", dataTest);
 		
-		final TestArrayNodeBoolean root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeBoolean.class, ExmlTestIntrospectionBoolean.NODE_NAME));
+		final TestArrayNodeBoolean root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeBoolean.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(false, root.values[0]);
 		Assertions.assertEquals(false, root.values[1]);
@@ -308,19 +328,23 @@ public class ExmlTestIntrospectionBoolean {
 		elem.setValues(new Boolean[] { false, false, true, false, true });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeBooleanFunc>
 					<values>false</values>
 					<values>false</values>
 					<values>true</values>
 					<values>false</values>
 					<values>true</values>
-				</elem>""", dataTest);
+				</TestArrayNodeBooleanFunc>""", dataTest);
 		
-		final TestArrayNodeBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeBooleanFunc.class, ExmlTestIntrospectionBoolean.NODE_NAME));
+		final TestArrayNodeBooleanFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeBooleanFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals(false, root.getValues()[0]);
 		Assertions.assertEquals(false, root.getValues()[1]);
@@ -337,12 +361,16 @@ public class ExmlTestIntrospectionBoolean {
 		elem.valueNull = null;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"false\" valueB=\"true\"/>", dataTest);
+		Assertions.assertEquals("<TestBoolean valueA=\"false\" valueB=\"true\"/>", dataTest);
 		
-		final TestBoolean root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestBoolean.class, ExmlTestIntrospectionBoolean.NODE_NAME));
+		final TestBoolean root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestBoolean.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(false, root.valueA);
 		Assertions.assertEquals(true, root.valueB);
 		Assertions.assertEquals(null, root.valueNull);
@@ -356,12 +384,16 @@ public class ExmlTestIntrospectionBoolean {
 		elem.setValueNull(null);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"false\" valueB=\"true\"/>", dataTest);
+		Assertions.assertEquals("<TestBooleanFunc valueA=\"false\" valueB=\"true\"/>", dataTest);
 		
-		final TestBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestBooleanFunc.class, ExmlTestIntrospectionBoolean.NODE_NAME));
+		final TestBooleanFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestBooleanFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(false, root.isValueA());
 		Assertions.assertEquals(true, root.isValueB());
 		Assertions.assertEquals(null, root.isValueNull());
@@ -373,12 +405,16 @@ public class ExmlTestIntrospectionBoolean {
 		elem.values = List.of(false, false, true, false, true);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"false;false;true;false;true\"/>", dataTest);
+		Assertions.assertEquals("<TestListBoolean values=\"false;false;true;false;true\"/>", dataTest);
 		
-		final TestListBoolean root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListBoolean.class, ExmlTestIntrospectionBoolean.NODE_NAME));
+		final TestListBoolean root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListBoolean.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.size());
 		Assertions.assertEquals(false, root.values.get(0));
 		Assertions.assertEquals(false, root.values.get(1));
@@ -393,12 +429,16 @@ public class ExmlTestIntrospectionBoolean {
 		elem.setValues(List.of(false, false, true, false, true));
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"false;false;true;false;true\"/>", dataTest);
+		Assertions.assertEquals("<TestListBooleanFunc values=\"false;false;true;false;true\"/>", dataTest);
 		
-		final TestListBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListBooleanFunc.class, ExmlTestIntrospectionBoolean.NODE_NAME));
+		final TestListBooleanFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListBooleanFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().size());
 		Assertions.assertEquals(false, root.getValues().get(0));
 		Assertions.assertEquals(false, root.getValues().get(1));
@@ -413,19 +453,23 @@ public class ExmlTestIntrospectionBoolean {
 		elem.values = List.of(false, false, true, false, true);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeBoolean>
 					<values>false</values>
 					<values>false</values>
 					<values>true</values>
 					<values>false</values>
 					<values>true</values>
-				</elem>""", dataTest);
+				</TestListNodeBoolean>""", dataTest);
 		
-		final TestListNodeBoolean root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeBoolean.class, ExmlTestIntrospectionBoolean.NODE_NAME));
+		final TestListNodeBoolean root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeBoolean.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.size());
 		Assertions.assertEquals(false, root.values.get(0));
 		Assertions.assertEquals(false, root.values.get(1));
@@ -440,19 +484,23 @@ public class ExmlTestIntrospectionBoolean {
 		elem.setValues(List.of(false, false, true, false, true));
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeBooleanFunc>
 					<values>false</values>
 					<values>false</values>
 					<values>true</values>
 					<values>false</values>
 					<values>true</values>
-				</elem>""", dataTest);
+				</TestListNodeBooleanFunc>""", dataTest);
 		
-		final TestListNodeBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeBooleanFunc.class, ExmlTestIntrospectionBoolean.NODE_NAME));
+		final TestListNodeBooleanFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeBooleanFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().size());
 		Assertions.assertEquals(false, root.getValues().get(0));
 		Assertions.assertEquals(false, root.getValues().get(1));
@@ -469,16 +517,20 @@ public class ExmlTestIntrospectionBoolean {
 		elem.valueNull = null;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeBoolean>
 					<valueA>false</valueA>
 					<valueB>true</valueB>
-				</elem>""", dataTest);
+				</TestNodeBoolean>""", dataTest);
 		
-		final TestNodeBoolean root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeBoolean.class, ExmlTestIntrospectionBoolean.NODE_NAME));
+		final TestNodeBoolean root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeBoolean.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(false, root.valueA);
 		Assertions.assertEquals(true, root.valueB);
 		Assertions.assertEquals(null, root.valueNull);
@@ -492,16 +544,20 @@ public class ExmlTestIntrospectionBoolean {
 		elem.setValueNull(null);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeBooleanFunc>
 					<valueA>false</valueA>
 					<valueB>true</valueB>
-				</elem>""", dataTest);
+				</TestNodeBooleanFunc>""", dataTest);
 		
-		final TestNodeBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeBooleanFunc.class, ExmlTestIntrospectionBoolean.NODE_NAME));
+		final TestNodeBooleanFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeBooleanFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(false, root.isValueA());
 		Assertions.assertEquals(true, root.isValueB());
 		Assertions.assertEquals(null, root.isValueNull());

test/src/test/atriasoft/exml/ExmlTestIntrospectionBooleanNative.java

@@ -5,9 +5,9 @@
  */
 package test.atriasoft.exml;
 
-import org.atriasoft.aknot.annotation.AknotList;
 import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
-import org.atriasoft.exml.Exml;
+import org.atriasoft.aknot.annotation.AknotList;
+import org.atriasoft.exml.XmlMapper;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -121,11 +121,11 @@ public class ExmlTestIntrospectionBooleanNative {
 		elem.values = new boolean[] { false, false, true, false, true };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeBooleanNativeStructured>
 					<values>
 						<elem>false</elem>
 						<elem>false</elem>
@@ -133,16 +133,20 @@ public class ExmlTestIntrospectionBooleanNative {
 						<elem>false</elem>
 						<elem>true</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestArrayNodeBooleanNativeStructured>""", dataTest);
 		
-		final TestArrayNodeBooleanNativeStructured root = Assertions
-				.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeBooleanNativeStructured.class, ExmlTestIntrospectionBoolean.NODE_NAME));
+		final TestArrayNodeBooleanNativeStructured root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeBooleanNativeStructured.class);
+		});
+		Assertions.assertNotNull(root);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(false, root.values[0]);
 		Assertions.assertEquals(false, root.values[1]);
 		Assertions.assertEquals(true, root.values[2]);
 		Assertions.assertEquals(false, root.values[3]);
 		Assertions.assertEquals(true, root.values[4]);
+		
 	}
 	
 	@Test
@@ -151,12 +155,16 @@ public class ExmlTestIntrospectionBooleanNative {
 		elem.setValues(new boolean[] { false, false, true, false, true });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"false;false;true;false;true\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayBooleanFunc values=\"false;false;true;false;true\"/>", dataTest);
 		
-		final TestArrayBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayBooleanFunc.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
+		final TestArrayBooleanFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayBooleanFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals(false, root.getValues()[0]);
 		Assertions.assertEquals(false, root.getValues()[1]);
@@ -171,12 +179,16 @@ public class ExmlTestIntrospectionBooleanNative {
 		elem.values = new boolean[] { false, false, true, false, true };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"false;false;true;false;true\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayBooleanNative values=\"false;false;true;false;true\"/>", dataTest);
 		
-		final TestArrayBooleanNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayBooleanNative.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
+		final TestArrayBooleanNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayBooleanNative.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(false, root.values[0]);
 		Assertions.assertEquals(false, root.values[1]);
@@ -191,19 +203,23 @@ public class ExmlTestIntrospectionBooleanNative {
 		elem.setValues(new boolean[] { false, false, true, false, true });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeBooleanFunc>
 					<values>false</values>
 					<values>false</values>
 					<values>true</values>
 					<values>false</values>
 					<values>true</values>
-				</elem>""", dataTest);
+				</TestArrayNodeBooleanFunc>""", dataTest);
 		
-		final TestArrayNodeBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeBooleanFunc.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
+		final TestArrayNodeBooleanFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeBooleanFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals(false, root.getValues()[0]);
 		Assertions.assertEquals(false, root.getValues()[1]);
@@ -218,19 +234,23 @@ public class ExmlTestIntrospectionBooleanNative {
 		elem.values = new boolean[] { false, false, true, false, true };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeBooleanNative>
 					<values>false</values>
 					<values>false</values>
 					<values>true</values>
 					<values>false</values>
 					<values>true</values>
-				</elem>""", dataTest);
+				</TestArrayNodeBooleanNative>""", dataTest);
 		
-		final TestArrayNodeBooleanNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeBooleanNative.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
+		final TestArrayNodeBooleanNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeBooleanNative.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(false, root.values[0]);
 		Assertions.assertEquals(false, root.values[1]);
@@ -246,12 +266,16 @@ public class ExmlTestIntrospectionBooleanNative {
 		elem.setValueB(true);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"false\" valueB=\"true\"/>", dataTest);
+		Assertions.assertEquals("<TestBooleanFunc valueA=\"false\" valueB=\"true\"/>", dataTest);
 		
-		final TestBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestBooleanFunc.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
+		final TestBooleanFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestBooleanFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(false, root.isValueA());
 		Assertions.assertEquals(true, root.isValueB());
 	}
@@ -263,12 +287,16 @@ public class ExmlTestIntrospectionBooleanNative {
 		elem.valueB = true;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"false\" valueB=\"true\"/>", dataTest);
+		Assertions.assertEquals("<TestBooleanNative valueA=\"false\" valueB=\"true\"/>", dataTest);
 		
-		final TestBooleanNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestBooleanNative.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
+		final TestBooleanNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestBooleanNative.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(false, root.valueA);
 		Assertions.assertEquals(true, root.valueB);
 	}
@@ -280,16 +308,20 @@ public class ExmlTestIntrospectionBooleanNative {
 		elem.setValueB(true);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeBooleanFunc>
 					<valueA>false</valueA>
 					<valueB>true</valueB>
-				</elem>""", dataTest);
+				</TestNodeBooleanFunc>""", dataTest);
 		
-		final TestNodeBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeBooleanFunc.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
+		final TestNodeBooleanFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeBooleanFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(false, root.isValueA());
 		Assertions.assertEquals(true, root.isValueB());
 	}
@@ -301,16 +333,20 @@ public class ExmlTestIntrospectionBooleanNative {
 		elem.valueB = true;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeBooleanNative>
 					<valueA>false</valueA>
 					<valueB>true</valueB>
-				</elem>""", dataTest);
+				</TestNodeBooleanNative>""", dataTest);
 		
-		final TestNodeBooleanNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeBooleanNative.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
+		final TestNodeBooleanNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeBooleanNative.class);
+		});
+		Assertions.assertNotNull(root);
 		Assertions.assertEquals(false, root.valueA);
 		Assertions.assertEquals(true, root.valueB);
 	}

test/src/test/atriasoft/exml/ExmlTestIntrospectionByte.java

@@ -7,9 +7,9 @@ package test.atriasoft.exml;
 
 import java.util.List;
 
-import org.atriasoft.aknot.annotation.AknotList;
 import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
-import org.atriasoft.exml.Exml;
+import org.atriasoft.aknot.annotation.AknotList;
+import org.atriasoft.exml.XmlMapper;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -209,11 +209,11 @@ public class ExmlTestIntrospectionByte {
 		elem.values = new Byte[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeByteStructured>
 					<values>
 						<elem>12</elem>
 						<elem>-13</elem>
@@ -221,9 +221,13 @@ public class ExmlTestIntrospectionByte {
 						<elem>78</elem>
 						<elem>-127</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestArrayNodeByteStructured>""", dataTest);
 		
-		final TestArrayNodeByteStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeByteStructured.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestArrayNodeByteStructured root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeByteStructured.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals((byte) 12, root.values[0]);
 		Assertions.assertEquals((byte) -13, root.values[1]);
@@ -238,11 +242,11 @@ public class ExmlTestIntrospectionByte {
 		elem.setValues(new Byte[] { 12, -13, 33, 78, -127 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeByteStructuredFunc>
 					<values>
 						<elem>12</elem>
 						<elem>-13</elem>
@@ -250,9 +254,13 @@ public class ExmlTestIntrospectionByte {
 						<elem>78</elem>
 						<elem>-127</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestArrayNodeByteStructuredFunc>""", dataTest);
 		
-		final TestArrayNodeByteStructuredFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeByteStructuredFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestArrayNodeByteStructuredFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeByteStructuredFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals((byte) 12, root.getValues()[0]);
 		Assertions.assertEquals((byte) -13, root.getValues()[1]);
@@ -267,11 +275,11 @@ public class ExmlTestIntrospectionByte {
 		elem.values = List.of((byte) 12, (byte) -13, (byte) 33, (byte) 78, (byte) -127);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeByteStructured>
 					<values>
 						<elem>12</elem>
 						<elem>-13</elem>
@@ -279,9 +287,13 @@ public class ExmlTestIntrospectionByte {
 						<elem>78</elem>
 						<elem>-127</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestListNodeByteStructured>""", dataTest);
 		
-		final TestListNodeByteStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeByteStructured.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestListNodeByteStructured root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeByteStructured.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.size());
 		Assertions.assertEquals((byte) 12, root.values.get(0));
 		Assertions.assertEquals((byte) -13, root.values.get(1));
@@ -296,11 +308,11 @@ public class ExmlTestIntrospectionByte {
 		elem.setValues(List.of((byte) 12, (byte) -13, (byte) 33, (byte) 78, (byte) -127));
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeByteStructuredFunc>
 					<values>
 						<elem>12</elem>
 						<elem>-13</elem>
@@ -308,9 +320,13 @@ public class ExmlTestIntrospectionByte {
 						<elem>78</elem>
 						<elem>-127</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestListNodeByteStructuredFunc>""", dataTest);
 		
-		final TestListNodeByteStructuredFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeByteStructuredFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestListNodeByteStructuredFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeByteStructuredFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().size());
 		Assertions.assertEquals((byte) 12, root.getValues().get(0));
 		Assertions.assertEquals((byte) -13, root.getValues().get(1));
@@ -325,12 +341,16 @@ public class ExmlTestIntrospectionByte {
 		elem.values = new Byte[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayByte values=\"12;-13;33;78;-127\"/>", dataTest);
 		
-		final TestArrayByte root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayByte.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestArrayByte root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayByte.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals((byte) 12, root.values[0]);
 		Assertions.assertEquals((byte) -13, root.values[1]);
@@ -345,12 +365,16 @@ public class ExmlTestIntrospectionByte {
 		elem.setValues(new Byte[] { 12, -13, 33, 78, -127 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayByteFunc values=\"12;-13;33;78;-127\"/>", dataTest);
 		
-		final TestArrayByteFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayByteFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestArrayByteFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayByteFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals((byte) 12, root.getValues()[0]);
 		Assertions.assertEquals((byte) -13, root.getValues()[1]);
@@ -365,19 +389,23 @@ public class ExmlTestIntrospectionByte {
 		elem.values = new Byte[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeByte>
 					<values>12</values>
 					<values>-13</values>
 					<values>33</values>
 					<values>78</values>
 					<values>-127</values>
-				</elem>""", dataTest);
+				</TestArrayNodeByte>""", dataTest);
 		
-		final TestArrayNodeByte root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeByte.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestArrayNodeByte root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeByte.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals((byte) 12, root.values[0]);
 		Assertions.assertEquals((byte) -13, root.values[1]);
@@ -392,19 +420,23 @@ public class ExmlTestIntrospectionByte {
 		elem.setValues(new Byte[] { 12, -13, 33, 78, -127 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeByteFunc>
 					<values>12</values>
 					<values>-13</values>
 					<values>33</values>
 					<values>78</values>
 					<values>-127</values>
-				</elem>""", dataTest);
+				</TestArrayNodeByteFunc>""", dataTest);
 		
-		final TestArrayNodeByteFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeByteFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestArrayNodeByteFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeByteFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals((byte) 12, root.getValues()[0]);
 		Assertions.assertEquals((byte) -13, root.getValues()[1]);
@@ -421,12 +453,16 @@ public class ExmlTestIntrospectionByte {
 		elem.valueNull = null;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"12\" valueB=\"-13\"/>", dataTest);
+		Assertions.assertEquals("<TestByte valueA=\"12\" valueB=\"-13\"/>", dataTest);
 		
-		final TestByte root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestByte.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestByte root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestByte.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals((byte) 12, root.valueA);
 		Assertions.assertEquals((byte) -13, root.valueB);
 		Assertions.assertEquals(null, root.valueNull);
@@ -440,12 +476,16 @@ public class ExmlTestIntrospectionByte {
 		elem.setValueNull(null);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"-55\" valueB=\"57\"/>", dataTest);
+		Assertions.assertEquals("<TestByteFunc valueA=\"-55\" valueB=\"57\"/>", dataTest);
 		
-		final TestByteFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestByteFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestByteFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestByteFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals((byte) -55, root.getValueA());
 		Assertions.assertEquals((byte) 57, root.getValueB());
 		Assertions.assertEquals(null, root.getValueNull());
@@ -457,12 +497,16 @@ public class ExmlTestIntrospectionByte {
 		elem.values = List.of((byte) 12, (byte) -13, (byte) 33, (byte) 78, (byte) -127);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
+		Assertions.assertEquals("<TestListByte values=\"12;-13;33;78;-127\"/>", dataTest);
 		
-		final TestListByte root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListByte.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestListByte root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListByte.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.size());
 		Assertions.assertEquals((byte) 12, root.values.get(0));
 		Assertions.assertEquals((byte) -13, root.values.get(1));
@@ -477,12 +521,16 @@ public class ExmlTestIntrospectionByte {
 		elem.setValues(List.of((byte) 12, (byte) -13, (byte) 33, (byte) 78, (byte) -127));
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
+		Assertions.assertEquals("<TestListByteFunc values=\"12;-13;33;78;-127\"/>", dataTest);
 		
-		final TestListByteFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListByteFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestListByteFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListByteFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().size());
 		Assertions.assertEquals((byte) 12, root.getValues().get(0));
 		Assertions.assertEquals((byte) -13, root.getValues().get(1));
@@ -497,19 +545,23 @@ public class ExmlTestIntrospectionByte {
 		elem.values = List.of((byte) 12, (byte) -13, (byte) 33, (byte) 78, (byte) -127);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeByte>
 					<values>12</values>
 					<values>-13</values>
 					<values>33</values>
 					<values>78</values>
 					<values>-127</values>
-				</elem>""", dataTest);
+				</TestListNodeByte>""", dataTest);
 		
-		final TestListNodeByte root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeByte.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestListNodeByte root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeByte.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.size());
 		Assertions.assertEquals((byte) 12, root.values.get(0));
 		Assertions.assertEquals((byte) -13, root.values.get(1));
@@ -524,19 +576,25 @@ public class ExmlTestIntrospectionByte {
 		elem.setValues(List.of((byte) 12, (byte) -13, (byte) 33, (byte) 78, (byte) -127));
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("""
-				<elem>
+		final String dataGenerated = """
+				<TestListNodeByteFunc>
 					<values>12</values>
 					<values>-13</values>
 					<values>33</values>
 					<values>78</values>
 					<values>-127</values>
-				</elem>""", dataTest);
+				</TestListNodeByteFunc>""";
+		Log.warning("compared with: " + dataGenerated);
+		Assertions.assertEquals(dataGenerated, dataTest);
 		
-		final TestListNodeByteFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeByteFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestListNodeByteFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeByteFunc.class);
+		});
+		Assertions.assertNotNull(root);
 		Assertions.assertEquals(5, root.getValues().size());
 		Assertions.assertEquals((byte) 12, root.getValues().get(0));
 		Assertions.assertEquals((byte) -13, root.getValues().get(1));
@@ -553,16 +611,20 @@ public class ExmlTestIntrospectionByte {
 		elem.valueNull = null;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeByte>
 					<valueA>11</valueA>
 					<valueB>-120</valueB>
-				</elem>""", dataTest);
+				</TestNodeByte>""", dataTest);
 		
-		final TestNodeByte root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeByte.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestNodeByte root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeByte.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals((byte) 11, root.valueA);
 		Assertions.assertEquals((byte) -120, root.valueB);
 		Assertions.assertEquals(null, root.valueNull);
@@ -576,16 +638,20 @@ public class ExmlTestIntrospectionByte {
 		elem.setValueNull(null);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeByteFunc>
 					<valueA>54</valueA>
 					<valueB>-68</valueB>
-				</elem>""", dataTest);
+				</TestNodeByteFunc>""", dataTest);
 		
-		final TestNodeByteFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeByteFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestNodeByteFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeByteFunc.class);
+		});
+		Assertions.assertNotNull(root);
 		Assertions.assertEquals((byte) 54, root.getValueA());
 		Assertions.assertEquals((byte) -68, root.getValueB());
 		Assertions.assertEquals(null, root.getValueNull());

test/src/test/atriasoft/exml/ExmlTestIntrospectionByteNative.java

@@ -5,9 +5,9 @@
  */
 package test.atriasoft.exml;
 
-import org.atriasoft.aknot.annotation.AknotList;
 import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
-import org.atriasoft.exml.Exml;
+import org.atriasoft.aknot.annotation.AknotList;
+import org.atriasoft.exml.XmlMapper;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -134,11 +134,11 @@ public class ExmlTestIntrospectionByteNative {
 		elem.values = new byte[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeByteNativeStructured>
 					<values>
 						<elem>12</elem>
 						<elem>-13</elem>
@@ -146,9 +146,13 @@ public class ExmlTestIntrospectionByteNative {
 						<elem>78</elem>
 						<elem>-127</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestArrayNodeByteNativeStructured>""", dataTest);
 		
-		final TestArrayNodeByteNativeStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeByteNativeStructured.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestArrayNodeByteNativeStructured root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeByteNativeStructured.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals((byte) 12, root.values[0]);
 		Assertions.assertEquals((byte) -13, root.values[1]);
@@ -163,11 +167,11 @@ public class ExmlTestIntrospectionByteNative {
 		elem.setValues(new byte[] { 12, -13, 33, 78, -127 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeByteNativeStructuredFunc>
 					<values>
 						<elem>12</elem>
 						<elem>-13</elem>
@@ -175,16 +179,20 @@ public class ExmlTestIntrospectionByteNative {
 						<elem>78</elem>
 						<elem>-127</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestArrayNodeByteNativeStructuredFunc>""", dataTest);
 		
-		final TestArrayNodeByteNativeStructuredFunc root = Assertions
-				.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeByteNativeStructuredFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestArrayNodeByteNativeStructuredFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeByteNativeStructuredFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals((byte) 12, root.getValues()[0]);
 		Assertions.assertEquals((byte) -13, root.getValues()[1]);
 		Assertions.assertEquals((byte) 33, root.getValues()[2]);
 		Assertions.assertEquals((byte) 78, root.getValues()[3]);
 		Assertions.assertEquals((byte) -127, root.getValues()[4]);
+		
 	}
 	
 	@Test
@@ -193,12 +201,16 @@ public class ExmlTestIntrospectionByteNative {
 		elem.setValues(new byte[] { 12, -13, 33, 78, -127 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayByteFunc values=\"12;-13;33;78;-127\"/>", dataTest);
 		
-		final TestArrayByteFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayByteFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestArrayByteFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayByteFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals((byte) 12, root.getValues()[0]);
 		Assertions.assertEquals((byte) -13, root.getValues()[1]);
@@ -213,12 +225,16 @@ public class ExmlTestIntrospectionByteNative {
 		elem.values = new byte[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayByteNative values=\"12;-13;33;78;-127\"/>", dataTest);
 		
-		final TestArrayByteNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayByteNative.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestArrayByteNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayByteNative.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals((byte) 12, root.values[0]);
 		Assertions.assertEquals((byte) -13, root.values[1]);
@@ -233,19 +249,23 @@ public class ExmlTestIntrospectionByteNative {
 		elem.setValues(new byte[] { 12, -13, 33, 78, -127 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeByteFunc>
 					<values>12</values>
 					<values>-13</values>
 					<values>33</values>
 					<values>78</values>
 					<values>-127</values>
-				</elem>""", dataTest);
+				</TestArrayNodeByteFunc>""", dataTest);
 		
-		final TestArrayNodeByteFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeByteFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestArrayNodeByteFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeByteFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals((byte) 12, root.getValues()[0]);
 		Assertions.assertEquals((byte) -13, root.getValues()[1]);
@@ -260,19 +280,23 @@ public class ExmlTestIntrospectionByteNative {
 		elem.values = new byte[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeByteNative>
 					<values>12</values>
 					<values>-13</values>
 					<values>33</values>
 					<values>78</values>
 					<values>-127</values>
-				</elem>""", dataTest);
+				</TestArrayNodeByteNative>""", dataTest);
 		
-		final TestArrayNodeByteNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeByteNative.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestArrayNodeByteNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeByteNative.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals((byte) 12, root.values[0]);
 		Assertions.assertEquals((byte) -13, root.values[1]);
@@ -288,12 +312,16 @@ public class ExmlTestIntrospectionByteNative {
 		elem.setValueB((byte) 57);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"-55\" valueB=\"57\"/>", dataTest);
+		Assertions.assertEquals("<TestbyteFunc valueA=\"-55\" valueB=\"57\"/>", dataTest);
 		
-		final TestbyteFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestbyteFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestbyteFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestbyteFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals((byte) -55, root.getValueA());
 		Assertions.assertEquals((byte) 57, root.getValueB());
 	}
@@ -305,12 +333,16 @@ public class ExmlTestIntrospectionByteNative {
 		elem.valueB = (byte) -13;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"12\" valueB=\"-13\"/>", dataTest);
+		Assertions.assertEquals("<TestByteNative valueA=\"12\" valueB=\"-13\"/>", dataTest);
 		
-		final TestByteNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestByteNative.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestByteNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestByteNative.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals((byte) 12, root.valueA);
 		Assertions.assertEquals((byte) -13, root.valueB);
 	}
@@ -322,16 +354,20 @@ public class ExmlTestIntrospectionByteNative {
 		elem.setValueB((byte) -68);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodebyteFunc>
 					<valueA>54</valueA>
 					<valueB>-68</valueB>
-				</elem>""", dataTest);
+				</TestNodebyteFunc>""", dataTest);
 		
-		final TestNodebyteFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodebyteFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestNodebyteFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodebyteFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals((byte) 54, root.getValueA());
 		Assertions.assertEquals((byte) -68, root.getValueB());
 	}
@@ -343,16 +379,20 @@ public class ExmlTestIntrospectionByteNative {
 		elem.valueB = (byte) -120;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeByteNative>
 					<valueA>11</valueA>
 					<valueB>-120</valueB>
-				</elem>""", dataTest);
+				</TestNodeByteNative>""", dataTest);
 		
-		final TestNodeByteNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeByteNative.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestNodeByteNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeByteNative.class);
+		});
+		Assertions.assertNotNull(root);
 		Assertions.assertEquals((byte) 11, root.valueA);
 		Assertions.assertEquals((byte) -120, root.valueB);
 	}

test/src/test/atriasoft/exml/ExmlTestIntrospectionDecoratorAttribute.java

@@ -5,10 +5,10 @@
  */
 package test.atriasoft.exml;
 
-import org.atriasoft.aknot.annotation.AknotName;
 import org.atriasoft.aknot.annotation.AknotAttribute;
 import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
-import org.atriasoft.exml.Exml;
+import org.atriasoft.aknot.annotation.AknotName;
+import org.atriasoft.exml.XmlMapper;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -55,7 +55,8 @@ public class ExmlTestIntrospectionDecoratorAttribute {
 		@AknotName({ "finalValueM", "finalValueN", "finalValueO", "finalValueP", "finalValueQ", "finalValueR", "finalValueS", "finalValueT", "pFinalValueQ", "pFinalValueR", "pFinalValueS",
 				"pFinalValueT" })
 		public TestNodeObject(final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueP, final int finalValueQ, @AknotAttribute final int finalValueR,
-				@AknotAttribute(true) final int finalValueS, @AknotAttribute(false) final int finalValueT, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS, final int pFinalValueT) {
+				@AknotAttribute(true) final int finalValueS, @AknotAttribute(false) final int finalValueT, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS,
+				final int pFinalValueT) {
 			this.finalValueM = finalValueM;
 			this.finalValueN = finalValueN;
 			this.finalValueO = finalValueO;
@@ -193,7 +194,8 @@ public class ExmlTestIntrospectionDecoratorAttribute {
 		@AknotName({ "finalValueM", "finalValueN", "finalValueO", "finalValueP", "finalValueQ", "finalValueR", "finalValueS", "finalValueT", "pFinalValueQ", "pFinalValueR", "pFinalValueS",
 				"pFinalValueT" })
 		public TestNodeObjectFalse(final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueP, final int finalValueQ, @AknotAttribute final int finalValueR,
-				@AknotAttribute(true) final int finalValueS, @AknotAttribute(false) final int finalValueT, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS, final int pFinalValueT) {
+				@AknotAttribute(true) final int finalValueS, @AknotAttribute(false) final int finalValueT, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS,
+				final int pFinalValueT) {
 			this.finalValueM = finalValueM;
 			this.finalValueN = finalValueN;
 			this.finalValueO = finalValueO;
@@ -331,7 +333,8 @@ public class ExmlTestIntrospectionDecoratorAttribute {
 		@AknotName({ "finalValueM", "finalValueN", "finalValueO", "finalValueP", "finalValueQ", "finalValueR", "finalValueS", "finalValueT", "pFinalValueQ", "pFinalValueR", "pFinalValueS",
 				"pFinalValueT" })
 		public TestNodeObjectTrue(final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueP, final int finalValueQ, @AknotAttribute final int finalValueR,
-				@AknotAttribute(true) final int finalValueS, @AknotAttribute(false) final int finalValueT, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS, final int pFinalValueT) {
+				@AknotAttribute(true) final int finalValueS, @AknotAttribute(false) final int finalValueT, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS,
+				final int pFinalValueT) {
 			this.finalValueM = finalValueM;
 			this.finalValueN = finalValueN;
 			this.finalValueO = finalValueO;
@@ -455,22 +458,26 @@ public class ExmlTestIntrospectionDecoratorAttribute {
 		elem.setValueK(885522);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + dataTest);
 		Assertions.assertEquals(
 				"""
-						<elem finalValueM="321" finalValueN="654" finalValueO="987" finalValueQ="267" finalValueR="264" finalValueS="1524" pFinalValueQ="-552" pFinalValueR="-965" pFinalValueS="-98885" valueA="55" valueB="78" valueC="51" valueE="651" valueF="654" valueG="8552" valueH="9531" valueI="87465">
+						<TestNodeObject finalValueM="321" finalValueN="654" finalValueO="987" finalValueQ="267" finalValueR="264" finalValueS="1524" pFinalValueQ="-552" pFinalValueR="-965" pFinalValueS="-98885" valueA="55" valueB="78" valueC="51" valueE="651" valueF="654" valueG="8552" valueH="9531" valueI="87465">
 							<finalValueP>159</finalValueP>
 							<finalValueT>182445</finalValueT>
 							<pFinalValueT>-8754</pFinalValueT>
 							<valueD>24</valueD>
 							<valueJ>8247</valueJ>
 							<valueK>885522</valueK>
-						</elem>""",
+						</TestNodeObject>""",
 				dataTest);
 		
-		final TestNodeObject root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObject.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestNodeObject root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeObject.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(55, root.valueA);
 		Assertions.assertEquals(78, root.valueB);
 		Assertions.assertEquals(51, root.valueC);
@@ -512,12 +519,12 @@ public class ExmlTestIntrospectionDecoratorAttribute {
 		elem.setValueK(885522);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals(
 				"""
-						<elem finalValueN="654" finalValueO="987" finalValueR="264" finalValueS="1524" pFinalValueR="-965" pFinalValueS="-98885" valueB="78" valueC="51" valueF="654" valueG="8552" valueH="9531" valueI="87465">
+						<TestNodeObjectFalse finalValueN="654" finalValueO="987" finalValueR="264" finalValueS="1524" pFinalValueR="-965" pFinalValueS="-98885" valueB="78" valueC="51" valueF="654" valueG="8552" valueH="9531" valueI="87465">
 							<finalValueM>321</finalValueM>
 							<finalValueP>159</finalValueP>
 							<finalValueQ>267</finalValueQ>
@@ -529,10 +536,14 @@ public class ExmlTestIntrospectionDecoratorAttribute {
 							<valueE>651</valueE>
 							<valueJ>8247</valueJ>
 							<valueK>885522</valueK>
-						</elem>""",
+						</TestNodeObjectFalse>""",
 				dataTest);
 		
-		final TestNodeObjectFalse root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObjectFalse.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestNodeObjectFalse root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeObjectFalse.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(55, root.valueA);
 		Assertions.assertEquals(78, root.valueB);
 		Assertions.assertEquals(51, root.valueC);
@@ -574,22 +585,26 @@ public class ExmlTestIntrospectionDecoratorAttribute {
 		elem.setValueK(885522);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals(
 				"""
-						<elem finalValueM="321" finalValueN="654" finalValueO="987" finalValueQ="267" finalValueR="264" finalValueS="1524" pFinalValueQ="-552" pFinalValueR="-965" pFinalValueS="-98885" valueA="55" valueB="78" valueC="51" valueE="651" valueF="654" valueG="8552" valueH="9531" valueI="87465">
+						<TestNodeObjectTrue finalValueM="321" finalValueN="654" finalValueO="987" finalValueQ="267" finalValueR="264" finalValueS="1524" pFinalValueQ="-552" pFinalValueR="-965" pFinalValueS="-98885" valueA="55" valueB="78" valueC="51" valueE="651" valueF="654" valueG="8552" valueH="9531" valueI="87465">
 							<finalValueP>159</finalValueP>
 							<finalValueT>182445</finalValueT>
 							<pFinalValueT>-8754</pFinalValueT>
 							<valueD>24</valueD>
 							<valueJ>8247</valueJ>
 							<valueK>885522</valueK>
-						</elem>""",
+						</TestNodeObjectTrue>""",
 				dataTest);
 		
-		final TestNodeObjectTrue root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObjectTrue.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestNodeObjectTrue root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeObjectTrue.class);
+		});
+		Assertions.assertNotNull(root);
 		Assertions.assertEquals(55, root.valueA);
 		Assertions.assertEquals(78, root.valueB);
 		Assertions.assertEquals(51, root.valueC);

test/src/test/atriasoft/exml/ExmlTestIntrospectionDecoratorCaseSensitive.java

@@ -6,10 +6,10 @@
 package test.atriasoft.exml;
 
 import org.atriasoft.aknot.annotation.AknotCaseSensitive;
+import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
 import org.atriasoft.aknot.annotation.AknotDefaultCaseSensitive;
 import org.atriasoft.aknot.annotation.AknotName;
-import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
-import org.atriasoft.exml.Exml;
+import org.atriasoft.exml.XmlMapper;
 import org.atriasoft.exml.exception.ExmlAttributeDoesNotExist;
 import org.atriasoft.exml.exception.ExmlNodeDoesNotExist;
 import org.junit.jupiter.api.Assertions;
@@ -882,27 +882,67 @@ public class ExmlTestIntrospectionDecoratorCaseSensitive {
 		elem.setValueK(885522);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + dataTest);
 		
-		final String[] testThatWork = {
-				"<elem>\n" + "	<finalValueM>321</finalValueM>\n" + "	<finalValueN>654</finalValueN>\n" + "	<finalValueO>987</finalValueO>\n" + "	<finalValueP>159</finalValueP>\n"
-						+ "	<finalValueQ>267</finalValueQ>\n" + "	<finalValueR>264</finalValueR>\n" + "	<finalValueS>1524</finalValueS>\n" + "	<finalValueT>182445</finalValueT>\n"
-						+ "	<pFinalValueQ>-552</pFinalValueQ>\n" + "	<pFinalValueR>-965</pFinalValueR>\n" + "	<pFinalValueS>-98885</pFinalValueS>\n" + "	<pFinalValueT>-8754</pFinalValueT>\n"
-						+ "	<valueA>55</valueA>\n" + "	<valueB>78</valueB>\n" + "	<valueC>51</valueC>\n" + "	<valueD>24</valueD>\n" + "	<valueE>651</valueE>\n" + "	<valueF>654</valueF>\n"
-						+ "	<valueG>8552</valueG>\n" + "	<valueH>9531</valueH>\n" + "	<valueI>87465</valueI>\n" + "	<valueJ>8247</valueJ>\n" + "	<valueK>885522</valueK>\n" + "</elem>",
-				"<elem>\n" + "	<finalValueM>321</finalValueM>\n" + "	<finalValueN>654</finalValueN>\n" + "	<finalValueO>987</finalValueO>\n" + "	<FINALVALUEP>159</FINALVALUEP>\n"
-						+ "	<finalValueQ>267</finalValueQ>\n" + "	<finalValueR>264</finalValueR>\n" + "	<finalValueS>1524</finalValueS>\n" + "	<FINALVALUET>182445</FINALVALUET>\n"
-						+ "	<pFinalValueQ>-552</pFinalValueQ>\n" + "	<pFinalValueR>-965</pFinalValueR>\n" + "	<pFinalValueS>-98885</pFinalValueS>\n" + "	<PFINALVALUET>-8754</PFINALVALUET>\n"
-						+ "	<valueA>55</valueA>\n" + "	<valueB>78</valueB>\n" + "	<valueC>51</valueC>\n" + "	<VALUED>24</VALUED>\n" + "	<valueE>651</valueE>\n" + "	<valueF>654</valueF>\n"
-						+ "	<valueG>8552</valueG>\n" + "	<valueH>9531</valueH>\n" + "	<valueI>87465</valueI>\n" + "	<VALUEJ>8247</VALUEJ>\n" + "	<VALUEK>885522</VALUEK>\n" + "</elem>" };
+		final String[] testThatWork = { """
+				<TestNodeObject>
+					<finalValueM>321</finalValueM>
+					<finalValueN>654</finalValueN>
+					<finalValueO>987</finalValueO>
+					<finalValueP>159</finalValueP>
+					<finalValueQ>267</finalValueQ>
+					<finalValueR>264</finalValueR>
+					<finalValueS>1524</finalValueS>
+					<finalValueT>182445</finalValueT>
+					<pFinalValueQ>-552</pFinalValueQ>
+					<pFinalValueR>-965</pFinalValueR>
+					<pFinalValueS>-98885</pFinalValueS>
+					<pFinalValueT>-8754</pFinalValueT>
+					<valueA>55</valueA>
+					<valueB>78</valueB>
+					<valueC>51</valueC>
+					<valueD>24</valueD>
+					<valueE>651</valueE>
+					<valueF>654</valueF>
+					<valueG>8552</valueG>
+					<valueH>9531</valueH>
+					<valueI>87465</valueI>
+					<valueJ>8247</valueJ>
+					<valueK>885522</valueK>
+				</TestNodeObject>""", """
+				<TestNodeObject>
+					<finalValueM>321</finalValueM>
+					<finalValueN>654</finalValueN>
+					<finalValueO>987</finalValueO>
+					<FINALVALUEP>159</FINALVALUEP>
+					<finalValueQ>267</finalValueQ>
+					<finalValueR>264</finalValueR>
+					<finalValueS>1524</finalValueS>
+					<FINALVALUET>182445</FINALVALUET>
+					<pFinalValueQ>-552</pFinalValueQ>
+					<pFinalValueR>-965</pFinalValueR>
+					<pFinalValueS>-98885</pFinalValueS>
+					<PFINALVALUET>-8754</PFINALVALUET>
+					<valueA>55</valueA>
+					<valueB>78</valueB>
+					<valueC>51</valueC>
+					<VALUED>24</VALUED>
+					<valueE>651</valueE>
+					<valueF>654</valueF>
+					<valueG>8552</valueG>
+					<valueH>9531</valueH>
+					<valueI>87465</valueI>
+					<VALUEJ>8247</VALUEJ>
+					<VALUEK>885522</VALUEK>
+				</TestNodeObject>""" };
 		
 		Assertions.assertEquals(testThatWork[0], dataTest);
 		
 		for (int iii = 0; iii < testThatWork.length; iii++) {
 			final int jjj = iii;
-			final TestNodeObject root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(testThatWork[jjj], elem.getClass(), ExmlTestIntrospectionObject.NODE_NAME));
+			final TestNodeObject root = Assertions.assertDoesNotThrow(() -> (new XmlMapper()).parse(testThatWork[jjj], elem.getClass()));
 			Assertions.assertEquals(55, root.valueA);
 			Assertions.assertEquals(78, root.valueB);
 			Assertions.assertEquals(51, root.valueC);
@@ -928,17 +968,63 @@ public class ExmlTestIntrospectionDecoratorCaseSensitive {
 			Assertions.assertEquals(-8754, root.getPFinalValueT());
 		}
 		
-		final String[] testThatNotWork = { "<elem>\n" + "	<FINALVALUEM>321</FINALVALUEM>\n" + "</elem>", "<elem>\n" + "	<FINALVALUEN>654</FINALVALUEN>\n" + "</elem>",
-				"<elem>\n" + "	<FINALVALUEO>987</FINALVALUEO>\n" + "</elem>", "<elem>\n" + "	<FINALVALUEQ>267</FINALVALUEQ>\n" + "</elem>",
-				"<elem>\n" + "	<FINALVALUER>264</FINALVALUER>\n" + "</elem>", "<elem>\n" + "	<FINALVALUES>1524</FINALVALUES>\n" + "</elem>",
-				"<elem>\n" + "	<PFINALVALUEQ>-552</PFINALVALUEQ>\n" + "</elem>", "<elem>\n" + "	<PFINALVALUER>-965</PFINALVALUER>\n" + "</elem>",
-				"<elem>\n" + "	<PFINALVALUES>-98885</PFINALVALUES>\n" + "</elem>", "<elem>\n" + "	<VALUEA>55</VALUEA>\n" + "</elem>", "<elem>\n" + "	<VALUEB>78</VALUEB>\n" + "</elem>",
-				"<elem>\n" + "	<VALUEC>51</VALUEC>\n" + "</elem>", "<elem>\n" + "	<VALUEE>651</VALUEE>\n" + "</elem>", "<elem>\n" + "	<VALUEF>654</VALUEF>\n" + "</elem>",
-				"<elem>\n" + "	<VALUEG>8552</VALUEG>\n" + "</elem>", "<elem>\n" + "	<VALUEH>9531</VALUEH>\n" + "</elem>", "<elem>\n" + "	<VALUEI>87465</VALUEI>\n" + "</elem>" };
+		final String[] testThatNotWork = { """
+				<TestNodeObject>
+					<FINALVALUEM>321</FINALVALUEM>
+				</TestNodeObject>""", """
+				<TestNodeObject>
+					<FINALVALUEN>654</FINALVALUEN>
+				</TestNodeObject>""", """
+				<TestNodeObject>
+					<FINALVALUEO>987</FINALVALUEO>
+				</TestNodeObject>""", """
+				<TestNodeObject>
+					<FINALVALUEQ>267</FINALVALUEQ>
+				</TestNodeObject>""", """
+				<TestNodeObject>
+					<FINALVALUER>264</FINALVALUER>
+				</TestNodeObject>""", """
+				<TestNodeObject>
+					<FINALVALUES>1524</FINALVALUES>
+				</TestNodeObject>""", """
+				<TestNodeObject>
+					<PFINALVALUEQ>-552</PFINALVALUEQ>
+				</TestNodeObject>""", """
+				<TestNodeObject>
+					<PFINALVALUER>-965</PFINALVALUER>
+				</TestNodeObject>""", """
+				<TestNodeObject>
+					<PFINALVALUES>-98885</PFINALVALUES>
+				</TestNodeObject>""", """
+				<TestNodeObject>
+					<VALUEA>55</VALUEA>
+				</TestNodeObject>""", """
+				<TestNodeObject>
+					<VALUEB>78</VALUEB>
+				</TestNodeObject>""", """
+				<TestNodeObject>
+					<VALUEC>51</VALUEC>
+				</TestNodeObject>""", """
+				<TestNodeObject>
+					<VALUEE>651</VALUEE>
+				</TestNodeObject>""", """
+				<TestNodeObject>
+					<VALUEF>654</VALUEF>
+				</TestNodeObject>""", """
+				<TestNodeObject>
+					<VALUEG>8552</VALUEG>
+				</TestNodeObject>""", """
+				<TestNodeObject>
+					<VALUEH>9531</VALUEH>
+				</TestNodeObject>""", """
+				<TestNodeObject>
+					<VALUEI>87465</VALUEI>
+				</TestNodeObject>""" };
 		for (int iii = 0; iii < testThatNotWork.length; iii++) {
 			final int jjj = iii;
-			Assertions.assertThrows(ExmlNodeDoesNotExist.class, () -> Exml.parseOne(testThatNotWork[jjj], elem.getClass(), ExmlTestIntrospectionObject.NODE_NAME));
+			Assertions.assertThrows(ExmlNodeDoesNotExist.class, () -> (new XmlMapper()).parse(testThatNotWork[jjj], elem.getClass()));
 		}
+		
 	}
 	
 	@Test
@@ -957,19 +1043,21 @@ public class ExmlTestIntrospectionDecoratorCaseSensitive {
 		elem.setValueK(885522);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + dataTest);
 		
 		final String[] testThatWork = {
-				"<elem finalValueM=\"321\" finalValueN=\"654\" finalValueO=\"987\" finalValueP=\"159\" finalValueQ=\"267\" finalValueR=\"264\" finalValueS=\"1524\" finalValueT=\"182445\" pFinalValueQ=\"-552\" pFinalValueR=\"-965\" pFinalValueS=\"-98885\" pFinalValueT=\"-8754\" valueA=\"55\" valueB=\"78\" valueC=\"51\" valueD=\"24\" valueE=\"651\" valueF=\"654\" valueG=\"8552\" valueH=\"9531\" valueI=\"87465\" valueJ=\"8247\" valueK=\"885522\"/>",
-				"<elem finalValueM=\"321\" finalValueN=\"654\" finalValueO=\"987\" FINALVALUEP=\"159\" finalValueQ=\"267\" finalValueR=\"264\" finalValueS=\"1524\" FINALVALUET=\"182445\" pFinalValueQ=\"-552\" pFinalValueR=\"-965\" pFinalValueS=\"-98885\" PFINALVALUET=\"-8754\" valueA=\"55\" valueB=\"78\" valueC=\"51\" VALUED=\"24\" valueE=\"651\" valueF=\"654\" valueG=\"8552\" valueH=\"9531\" valueI=\"87465\" VALUEJ=\"8247\" VALUEK=\"885522\"/>", };
+				"""
+						<TestAttributeObject finalValueM="321" finalValueN="654" finalValueO="987" finalValueP="159" finalValueQ="267" finalValueR="264" finalValueS="1524" finalValueT="182445" pFinalValueQ="-552" pFinalValueR="-965" pFinalValueS="-98885" pFinalValueT="-8754" valueA="55" valueB="78" valueC="51" valueD="24" valueE="651" valueF="654" valueG="8552" valueH="9531" valueI="87465" valueJ="8247" valueK="885522"/>""",
+				"""
+						<TestAttributeObject finalValueM="321" finalValueN="654" finalValueO="987" FINALVALUEP="159" finalValueQ="267" finalValueR="264" finalValueS="1524" FINALVALUET="182445" pFinalValueQ="-552" pFinalValueR="-965" pFinalValueS="-98885" PFINALVALUET="-8754" valueA="55" valueB="78" valueC="51" VALUED="24" valueE="651" valueF="654" valueG="8552" valueH="9531" valueI="87465" VALUEJ="8247" VALUEK="885522"/>""", };
 		
 		Assertions.assertEquals(testThatWork[0], dataTest);
 		
 		for (int iii = 0; iii < testThatWork.length; iii++) {
 			final int jjj = iii;
-			final TestAttributeObject root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(testThatWork[jjj], elem.getClass(), ExmlTestIntrospectionObject.NODE_NAME));
+			final TestAttributeObject root = Assertions.assertDoesNotThrow(() -> (new XmlMapper()).parse(testThatWork[jjj], elem.getClass()));
 			Assertions.assertEquals(55, root.valueA);
 			Assertions.assertEquals(78, root.valueB);
 			Assertions.assertEquals(51, root.valueC);
@@ -995,12 +1083,27 @@ public class ExmlTestIntrospectionDecoratorCaseSensitive {
 			Assertions.assertEquals(-8754, root.getPFinalValueT());
 		}
 		
-		final String[] testThatNotWork = { "<elem FINALVALUEM=\"321\"/>", "<elem FINALVALUEN=\"654\"/>", "<elem FINALVALUEO=\"987\"/>", "<elem FINALVALUEQ=\"267\"/>", "<elem FINALVALUER=\"264\"/>",
-				"<elem FINALVALUES=\"1524\"/>", "<elem PFINALVALUEQ=\"-552\"/>", "<elem PFINALVALUER=\"-965\"/>", "<elem PFINALVALUES=\"-98885\"/>", "<elem VALUEA=\"55\"/>", "<elem VALUEB=\"78\"/>",
-				"<elem VALUEC=\"51\"/>", "<elem VALUEE=\"651\"/>", "<elem VALUEF=\"654\"/>", "<elem VALUEG=\"8552\"/>", "<elem VALUEH=\"9531\"/>", "<elem VALUEI=\"87465\"/>" };
+		final String[] testThatNotWork = { """
+				<TestAttributeObject FINALVALUEM="321"/>""", """
+				<TestAttributeObject FINALVALUEN="654"/>""", """
+				<TestAttributeObject FINALVALUEO="987"/>""", """
+				<TestAttributeObject FINALVALUEQ="267"/>""", """
+				<TestAttributeObject FINALVALUER="264"/>""", """
+				<TestAttributeObject FINALVALUES="1524"/>""", """
+				<TestAttributeObject PFINALVALUEQ="-552"/>""", """
+				<TestAttributeObject PFINALVALUER="-965"/>""", """
+				<TestAttributeObject PFINALVALUES="-98885"/>""", """
+				<TestAttributeObject VALUEA="55"/>""", """
+				<TestAttributeObject VALUEB="78"/>""", """
+				<TestAttributeObject VALUEC="51"/>""", """
+				<TestAttributeObject VALUEE="651"/>""", """
+				<TestAttributeObject VALUEF="654"/>""", """
+				<TestAttributeObject VALUEG="8552"/>""", """
+				<TestAttributeObject VALUEH="9531"/>""", """
+				<TestAttributeObject VALUEI="87465"/>""" };
 		for (int iii = 0; iii < testThatNotWork.length; iii++) {
 			final int jjj = iii;
-			Assertions.assertThrows(ExmlAttributeDoesNotExist.class, () -> Exml.parseOne(testThatNotWork[jjj], elem.getClass(), ExmlTestIntrospectionObject.NODE_NAME));
+			Assertions.assertThrows(ExmlAttributeDoesNotExist.class, () -> (new XmlMapper()).parse(testThatNotWork[jjj], elem.getClass()));
 		}
 	}
 	
@@ -1020,27 +1123,67 @@ public class ExmlTestIntrospectionDecoratorCaseSensitive {
 		elem.setValueK(885522);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		
-		final String[] testThatWork = {
-				"<elem>\n" + "	<finalValueM>321</finalValueM>\n" + "	<finalValueN>654</finalValueN>\n" + "	<finalValueO>987</finalValueO>\n" + "	<finalValueP>159</finalValueP>\n"
-						+ "	<finalValueQ>267</finalValueQ>\n" + "	<finalValueR>264</finalValueR>\n" + "	<finalValueS>1524</finalValueS>\n" + "	<finalValueT>182445</finalValueT>\n"
-						+ "	<pFinalValueQ>-552</pFinalValueQ>\n" + "	<pFinalValueR>-965</pFinalValueR>\n" + "	<pFinalValueS>-98885</pFinalValueS>\n" + "	<pFinalValueT>-8754</pFinalValueT>\n"
-						+ "	<valueA>55</valueA>\n" + "	<valueB>78</valueB>\n" + "	<valueC>51</valueC>\n" + "	<valueD>24</valueD>\n" + "	<valueE>651</valueE>\n" + "	<valueF>654</valueF>\n"
-						+ "	<valueG>8552</valueG>\n" + "	<valueH>9531</valueH>\n" + "	<valueI>87465</valueI>\n" + "	<valueJ>8247</valueJ>\n" + "	<valueK>885522</valueK>\n" + "</elem>",
-				"<elem>\n" + "	<FINALVALUEM>321</FINALVALUEM>\n" + "	<finalValueN>654</finalValueN>\n" + "	<finalValueO>987</finalValueO>\n" + "	<FINALVALUEP>159</FINALVALUEP>\n"
-						+ "	<FINALVALUEQ>267</FINALVALUEQ>\n" + "	<finalValueR>264</finalValueR>\n" + "	<finalValueS>1524</finalValueS>\n" + "	<FINALVALUET>182445</FINALVALUET>\n"
-						+ "	<PFINALVALUEQ>-552</PFINALVALUEQ>\n" + "	<pFinalValueR>-965</pFinalValueR>\n" + "	<pFinalValueS>-98885</pFinalValueS>\n" + "	<PFINALVALUET>-8754</PFINALVALUET>\n"
-						+ "	<VALUEA>55</VALUEA>\n" + "	<valueB>78</valueB>\n" + "	<valueC>51</valueC>\n" + "	<VALUED>24</VALUED>\n" + "	<VALUEE>651</VALUEE>\n" + "	<valueF>654</valueF>\n"
-						+ "	<valueG>8552</valueG>\n" + "	<valueH>9531</valueH>\n" + "	<valueI>87465</valueI>\n" + "	<VALUEJ>8247</VALUEJ>\n" + "	<VALUEK>885522</VALUEK>\n" + "</elem>" };
+		final String[] testThatWork = { """
+				<TestNodeObjectFalse>
+					<finalValueM>321</finalValueM>
+					<finalValueN>654</finalValueN>
+					<finalValueO>987</finalValueO>
+					<finalValueP>159</finalValueP>
+					<finalValueQ>267</finalValueQ>
+					<finalValueR>264</finalValueR>
+					<finalValueS>1524</finalValueS>
+					<finalValueT>182445</finalValueT>
+					<pFinalValueQ>-552</pFinalValueQ>
+					<pFinalValueR>-965</pFinalValueR>
+					<pFinalValueS>-98885</pFinalValueS>
+					<pFinalValueT>-8754</pFinalValueT>
+					<valueA>55</valueA>
+					<valueB>78</valueB>
+					<valueC>51</valueC>
+					<valueD>24</valueD>
+					<valueE>651</valueE>
+					<valueF>654</valueF>
+					<valueG>8552</valueG>
+					<valueH>9531</valueH>
+					<valueI>87465</valueI>
+					<valueJ>8247</valueJ>
+					<valueK>885522</valueK>
+				</TestNodeObjectFalse>""", """
+				<TestNodeObjectFalse>
+					<FINALVALUEM>321</FINALVALUEM>
+					<finalValueN>654</finalValueN>
+					<finalValueO>987</finalValueO>
+					<FINALVALUEP>159</FINALVALUEP>
+					<FINALVALUEQ>267</FINALVALUEQ>
+					<finalValueR>264</finalValueR>
+					<finalValueS>1524</finalValueS>
+					<FINALVALUET>182445</FINALVALUET>
+					<PFINALVALUEQ>-552</PFINALVALUEQ>
+					<pFinalValueR>-965</pFinalValueR>
+					<pFinalValueS>-98885</pFinalValueS>
+					<PFINALVALUET>-8754</PFINALVALUET>
+					<VALUEA>55</VALUEA>
+					<valueB>78</valueB>
+					<valueC>51</valueC>
+					<VALUED>24</VALUED>
+					<VALUEE>651</VALUEE>
+					<valueF>654</valueF>
+					<valueG>8552</valueG>
+					<valueH>9531</valueH>
+					<valueI>87465</valueI>
+					<VALUEJ>8247</VALUEJ>
+					<VALUEK>885522</VALUEK>
+				</TestNodeObjectFalse>""" };
 		
 		Assertions.assertEquals(testThatWork[0], dataTest);
 		
 		for (int iii = 0; iii < testThatWork.length; iii++) {
 			final int jjj = iii;
-			final TestNodeObjectFalse root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(testThatWork[jjj], elem.getClass(), ExmlTestIntrospectionObject.NODE_NAME));
+			final TestNodeObjectFalse root = Assertions.assertDoesNotThrow(() -> (new XmlMapper()).parse(testThatWork[jjj], elem.getClass()));
 			Assertions.assertEquals(55, root.valueA);
 			Assertions.assertEquals(78, root.valueB);
 			Assertions.assertEquals(51, root.valueC);
@@ -1065,14 +1208,46 @@ public class ExmlTestIntrospectionDecoratorCaseSensitive {
 			Assertions.assertEquals(-98885, root.getPFinalValueS());
 			Assertions.assertEquals(-8754, root.getPFinalValueT());
 		}
-		final String[] testThatNotWork = { "<elem>\n" + "	<FINALVALUEN>654</FINALVALUEN>\n" + "</elem>", "<elem>\n" + "	<FINALVALUEO>987</FINALVALUEO>\n" + "</elem>",
-				"<elem>\n" + "	<FINALVALUER>264</FINALVALUER>\n" + "</elem>", "<elem>\n" + "	<FINALVALUES>1524</FINALVALUES>\n" + "</elem>",
-				"<elem>\n" + "	<PFINALVALUER>-965</PFINALVALUER>\n" + "</elem>", "<elem>\n" + "	<PFINALVALUES>-98885</PFINALVALUES>\n" + "</elem>",
-				"<elem>\n" + "	<VALUEB>78</VALUEB>\n" + "</elem>", "<elem>\n" + "	<VALUEC>51</VALUEC>\n" + "</elem>", "<elem>\n" + "	<VALUEF>654</VALUEF>\n" + "</elem>",
-				"<elem>\n" + "	<VALUEG>8552</VALUEG>\n" + "</elem>", "<elem>\n" + "	<VALUEH>9531</VALUEH>\n" + "</elem>", "<elem>\n" + "	<VALUEI>87465</VALUEI>\n" + "</elem>" };
+		final String[] testThatNotWork = { """
+				<TestNodeObjectFalse>
+					<FINALVALUEN>654</FINALVALUEN>
+				</TestNodeObjectFalse>""", """
+				<TestNodeObjectFalse>
+					<FINALVALUEO>987</FINALVALUEO>
+				</TestNodeObjectFalse>""", """
+				<TestNodeObjectFalse>
+					<FINALVALUER>264</FINALVALUER>
+				</TestNodeObjectFalse>""", """
+				<TestNodeObjectFalse>
+					<FINALVALUES>1524</FINALVALUES>
+				</TestNodeObjectFalse>""", """
+				<TestNodeObjectFalse>
+					<PFINALVALUER>-965</PFINALVALUER>
+				</TestNodeObjectFalse>""", """
+				<TestNodeObjectFalse>
+					<PFINALVALUES>-98885</PFINALVALUES>
+				</TestNodeObjectFalse>""", """
+				<TestNodeObjectFalse>
+					<VALUEB>78</VALUEB>
+				</TestNodeObjectFalse>""", """
+				<TestNodeObjectFalse>
+					<VALUEC>51</VALUEC>
+				</TestNodeObjectFalse>""", """
+				<TestNodeObjectFalse>
+					<VALUEF>654</VALUEF>
+				</TestNodeObjectFalse>""", """
+				<TestNodeObjectFalse>
+					<VALUEG>8552</VALUEG>
+				</TestNodeObjectFalse>""", """
+				<TestNodeObjectFalse>
+					<VALUEH>9531</VALUEH>
+				</TestNodeObjectFalse>""", """
+				<TestNodeObjectFalse>
+					<VALUEI>87465</VALUEI>
+				</TestNodeObjectFalse>""" };
 		for (int iii = 0; iii < testThatNotWork.length; iii++) {
 			final int jjj = iii;
-			Assertions.assertThrows(ExmlNodeDoesNotExist.class, () -> Exml.parseOne(testThatNotWork[jjj], elem.getClass(), ExmlTestIntrospectionObject.NODE_NAME));
+			Assertions.assertThrows(ExmlNodeDoesNotExist.class, () -> (new XmlMapper()).parse(testThatNotWork[jjj], elem.getClass()));
 		}
 	}
 	
@@ -1092,19 +1267,21 @@ public class ExmlTestIntrospectionDecoratorCaseSensitive {
 		elem.setValueK(885522);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		
 		final String[] testThatWork = {
-				"<elem finalValueM=\"321\" finalValueN=\"654\" finalValueO=\"987\" finalValueP=\"159\" finalValueQ=\"267\" finalValueR=\"264\" finalValueS=\"1524\" finalValueT=\"182445\" pFinalValueQ=\"-552\" pFinalValueR=\"-965\" pFinalValueS=\"-98885\" pFinalValueT=\"-8754\" valueA=\"55\" valueB=\"78\" valueC=\"51\" valueD=\"24\" valueE=\"651\" valueF=\"654\" valueG=\"8552\" valueH=\"9531\" valueI=\"87465\" valueJ=\"8247\" valueK=\"885522\"/>",
-				"<elem FINALVALUEM=\"321\" finalValueN=\"654\" finalValueO=\"987\" FINALVALUEP=\"159\" FINALVALUEQ=\"267\" finalValueR=\"264\" finalValueS=\"1524\" FINALVALUET=\"182445\" PFINALVALUEQ=\"-552\" pFinalValueR=\"-965\" pFinalValueS=\"-98885\" PFINALVALUET=\"-8754\" VALUEA=\"55\" valueB=\"78\" valueC=\"51\" VALUED=\"24\" VALUEE=\"651\" valueF=\"654\" valueG=\"8552\" valueH=\"9531\" valueI=\"87465\" VALUEJ=\"8247\" VALUEK=\"885522\"/>", };
+				"""
+						<TestAttributeObjectFalse finalValueM="321" finalValueN="654" finalValueO="987" finalValueP="159" finalValueQ="267" finalValueR="264" finalValueS="1524" finalValueT="182445" pFinalValueQ="-552" pFinalValueR="-965" pFinalValueS="-98885" pFinalValueT="-8754" valueA="55" valueB="78" valueC="51" valueD="24" valueE="651" valueF="654" valueG="8552" valueH="9531" valueI="87465" valueJ="8247" valueK="885522"/>""",
+				"""
+						<TestAttributeObjectFalse FINALVALUEM="321" finalValueN="654" finalValueO="987" FINALVALUEP="159" FINALVALUEQ="267" finalValueR="264" finalValueS="1524" FINALVALUET="182445" PFINALVALUEQ="-552" pFinalValueR="-965" pFinalValueS="-98885" PFINALVALUET="-8754" VALUEA="55" valueB="78" valueC="51" VALUED="24" VALUEE="651" valueF="654" valueG="8552" valueH="9531" valueI="87465" VALUEJ="8247" VALUEK="885522"/>""", };
 		
 		Assertions.assertEquals(testThatWork[0], dataTest);
 		
 		for (int iii = 0; iii < testThatWork.length; iii++) {
 			final int jjj = iii;
-			final TestAttributeObjectFalse root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(testThatWork[jjj], elem.getClass(), ExmlTestIntrospectionObject.NODE_NAME));
+			final TestAttributeObjectFalse root = Assertions.assertDoesNotThrow(() -> (new XmlMapper()).parse(testThatWork[jjj], elem.getClass()));
 			Assertions.assertEquals(55, root.valueA);
 			Assertions.assertEquals(78, root.valueB);
 			Assertions.assertEquals(51, root.valueC);
@@ -1129,12 +1306,22 @@ public class ExmlTestIntrospectionDecoratorCaseSensitive {
 			Assertions.assertEquals(-98885, root.getPFinalValueS());
 			Assertions.assertEquals(-8754, root.getPFinalValueT());
 		}
-		final String[] testThatNotWork = { "<elem FINALVALUEN=\"654\"/>", "<elem FINALVALUEO=\"987\"/>", "<elem FINALVALUER=\"264\"/>", "<elem FINALVALUES=\"1524\"/>", "<elem PFINALVALUER=\"-965\"/>",
-				"<elem PFINALVALUES=\"-98885\"/>", "<elem VALUEB=\"78\"/>", "<elem VALUEC=\"51\"/>", "<elem VALUEF=\"654\"/>", "<elem VALUEG=\"8552\"/>", "<elem VALUEH=\"9531\"/>",
-				"<elem VALUEI=\"87465\"/>", };
+		final String[] testThatNotWork = { """
+				<TestAttributeObjectFalse FINALVALUEN="654"/>""", """
+				<TestAttributeObjectFalse FINALVALUEO="987"/>""", """
+				<TestAttributeObjectFalse FINALVALUER="264"/>""", """
+				<TestAttributeObjectFalse FINALVALUES="1524"/>""", """
+				<TestAttributeObjectFalse PFINALVALUER="-965"/>""", """
+				<TestAttributeObjectFalse PFINALVALUES="-98885"/>""", """
+				<TestAttributeObjectFalse VALUEB="78"/>""", """
+				<TestAttributeObjectFalse VALUEC="51"/>""", """
+				<TestAttributeObjectFalse VALUEF="654"/>""", """
+				<TestAttributeObjectFalse VALUEG="8552"/>""", """
+				<TestAttributeObjectFalse VALUEH="9531"/>""", """
+				<TestAttributeObjectFalse VALUEI="87465"/>""" };
 		for (int iii = 0; iii < testThatNotWork.length; iii++) {
 			final int jjj = iii;
-			Assertions.assertThrows(ExmlAttributeDoesNotExist.class, () -> Exml.parseOne(testThatNotWork[jjj], elem.getClass(), ExmlTestIntrospectionObject.NODE_NAME));
+			Assertions.assertThrows(ExmlAttributeDoesNotExist.class, () -> (new XmlMapper()).parse(testThatNotWork[jjj], elem.getClass()));
 		}
 	}
 	
@@ -1154,27 +1341,67 @@ public class ExmlTestIntrospectionDecoratorCaseSensitive {
 		elem.setValueK(885522);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		
-		final String[] testThatWork = {
-				"<elem>\n" + "	<finalValueM>321</finalValueM>\n" + "	<finalValueN>654</finalValueN>\n" + "	<finalValueO>987</finalValueO>\n" + "	<finalValueP>159</finalValueP>\n"
-						+ "	<finalValueQ>267</finalValueQ>\n" + "	<finalValueR>264</finalValueR>\n" + "	<finalValueS>1524</finalValueS>\n" + "	<finalValueT>182445</finalValueT>\n"
-						+ "	<pFinalValueQ>-552</pFinalValueQ>\n" + "	<pFinalValueR>-965</pFinalValueR>\n" + "	<pFinalValueS>-98885</pFinalValueS>\n" + "	<pFinalValueT>-8754</pFinalValueT>\n"
-						+ "	<valueA>55</valueA>\n" + "	<valueB>78</valueB>\n" + "	<valueC>51</valueC>\n" + "	<valueD>24</valueD>\n" + "	<valueE>651</valueE>\n" + "	<valueF>654</valueF>\n"
-						+ "	<valueG>8552</valueG>\n" + "	<valueH>9531</valueH>\n" + "	<valueI>87465</valueI>\n" + "	<valueJ>8247</valueJ>\n" + "	<valueK>885522</valueK>\n" + "</elem>",
-				"<elem>\n" + "	<finalValueM>321</finalValueM>\n" + "	<finalValueN>654</finalValueN>\n" + "	<finalValueO>987</finalValueO>\n" + "	<FINALVALUEP>159</FINALVALUEP>\n"
-						+ "	<finalValueQ>267</finalValueQ>\n" + "	<finalValueR>264</finalValueR>\n" + "	<finalValueS>1524</finalValueS>\n" + "	<FINALVALUET>182445</FINALVALUET>\n"
-						+ "	<pFinalValueQ>-552</pFinalValueQ>\n" + "	<pFinalValueR>-965</pFinalValueR>\n" + "	<pFinalValueS>-98885</pFinalValueS>\n" + "	<PFINALVALUET>-8754</PFINALVALUET>\n"
-						+ "	<valueA>55</valueA>\n" + "	<valueB>78</valueB>\n" + "	<valueC>51</valueC>\n" + "	<VALUED>24</VALUED>\n" + "	<valueE>651</valueE>\n" + "	<valueF>654</valueF>\n"
-						+ "	<valueG>8552</valueG>\n" + "	<valueH>9531</valueH>\n" + "	<valueI>87465</valueI>\n" + "	<VALUEJ>8247</VALUEJ>\n" + "	<VALUEK>885522</VALUEK>\n" + "</elem>" };
+		final String[] testThatWork = { """
+				<TestNodeObjectTrue>
+					<finalValueM>321</finalValueM>
+					<finalValueN>654</finalValueN>
+					<finalValueO>987</finalValueO>
+					<finalValueP>159</finalValueP>
+					<finalValueQ>267</finalValueQ>
+					<finalValueR>264</finalValueR>
+					<finalValueS>1524</finalValueS>
+					<finalValueT>182445</finalValueT>
+					<pFinalValueQ>-552</pFinalValueQ>
+					<pFinalValueR>-965</pFinalValueR>
+					<pFinalValueS>-98885</pFinalValueS>
+					<pFinalValueT>-8754</pFinalValueT>
+					<valueA>55</valueA>
+					<valueB>78</valueB>
+					<valueC>51</valueC>
+					<valueD>24</valueD>
+					<valueE>651</valueE>
+					<valueF>654</valueF>
+					<valueG>8552</valueG>
+					<valueH>9531</valueH>
+					<valueI>87465</valueI>
+					<valueJ>8247</valueJ>
+					<valueK>885522</valueK>
+				</TestNodeObjectTrue>""", """
+				<TestNodeObjectTrue>
+					<finalValueM>321</finalValueM>
+					<finalValueN>654</finalValueN>
+					<finalValueO>987</finalValueO>
+					<FINALVALUEP>159</FINALVALUEP>
+					<finalValueQ>267</finalValueQ>
+					<finalValueR>264</finalValueR>
+					<finalValueS>1524</finalValueS>
+					<FINALVALUET>182445</FINALVALUET>
+					<pFinalValueQ>-552</pFinalValueQ>
+					<pFinalValueR>-965</pFinalValueR>
+					<pFinalValueS>-98885</pFinalValueS>
+					<PFINALVALUET>-8754</PFINALVALUET>
+					<valueA>55</valueA>
+					<valueB>78</valueB>
+					<valueC>51</valueC>
+					<VALUED>24</VALUED>
+					<valueE>651</valueE>
+					<valueF>654</valueF>
+					<valueG>8552</valueG>
+					<valueH>9531</valueH>
+					<valueI>87465</valueI>
+					<VALUEJ>8247</VALUEJ>
+					<VALUEK>885522</VALUEK>
+				</TestNodeObjectTrue>""" };
 		
 		Assertions.assertEquals(testThatWork[0], dataTest);
 		
 		for (int iii = 0; iii < testThatWork.length; iii++) {
 			final int jjj = iii;
-			final TestNodeObjectTrue root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(testThatWork[jjj], elem.getClass(), ExmlTestIntrospectionObject.NODE_NAME));
+			final TestNodeObjectTrue root = Assertions.assertDoesNotThrow(() -> (new XmlMapper()).parse(testThatWork[jjj], elem.getClass()));
 			Assertions.assertEquals(55, root.valueA);
 			Assertions.assertEquals(78, root.valueB);
 			Assertions.assertEquals(51, root.valueC);
@@ -1199,16 +1426,61 @@ public class ExmlTestIntrospectionDecoratorCaseSensitive {
 			Assertions.assertEquals(-98885, root.getPFinalValueS());
 			Assertions.assertEquals(-8754, root.getPFinalValueT());
 		}
-		final String[] testThatNotWork = { "<elem>\n" + "	<FINALVALUEM>321</FINALVALUEM>\n" + "</elem>", "<elem>\n" + "	<FINALVALUEN>654</FINALVALUEN>\n" + "</elem>",
-				"<elem>\n" + "	<FINALVALUEO>987</FINALVALUEO>\n" + "</elem>", "<elem>\n" + "	<FINALVALUEQ>267</FINALVALUEQ>\n" + "</elem>",
-				"<elem>\n" + "	<FINALVALUER>264</FINALVALUER>\n" + "</elem>", "<elem>\n" + "	<FINALVALUES>1524</FINALVALUES>\n" + "</elem>",
-				"<elem>\n" + "	<PFINALVALUEQ>-552</PFINALVALUEQ>\n" + "</elem>", "<elem>\n" + "	<PFINALVALUER>-965</PFINALVALUER>\n" + "</elem>",
-				"<elem>\n" + "	<PFINALVALUES>-98885</PFINALVALUES>\n" + "</elem>", "<elem>\n" + "	<VALUEA>55</VALUEA>\n" + "</elem>", "<elem>\n" + "	<VALUEB>78</VALUEB>\n" + "</elem>",
-				"<elem>\n" + "	<VALUEC>51</VALUEC>\n" + "</elem>", "<elem>\n" + "	<VALUEE>651</VALUEE>\n" + "</elem>", "<elem>\n" + "	<VALUEF>654</VALUEF>\n" + "</elem>",
-				"<elem>\n" + "	<VALUEG>8552</VALUEG>\n" + "</elem>", "<elem>\n" + "	<VALUEH>9531</VALUEH>\n" + "</elem>", "<elem>\n" + "	<VALUEI>87465</VALUEI>\n" + "</elem>" };
+		final String[] testThatNotWork = { """
+				<TestNodeObjectTrue>
+					<FINALVALUEM>321</FINALVALUEM>
+				</TestNodeObjectTrue>""", """
+				<TestNodeObjectTrue>
+					<FINALVALUEN>654</FINALVALUEN>
+				</TestNodeObjectTrue>""", """
+				<TestNodeObjectTrue>
+					<FINALVALUEO>987</FINALVALUEO>
+				</TestNodeObjectTrue>""", """
+				<TestNodeObjectTrue>
+					<FINALVALUEQ>267</FINALVALUEQ>
+				</TestNodeObjectTrue>""", """
+				<TestNodeObjectTrue>
+					<FINALVALUER>264</FINALVALUER>
+				</TestNodeObjectTrue>""", """
+				<TestNodeObjectTrue>
+					<FINALVALUES>1524</FINALVALUES>
+				</TestNodeObjectTrue>""", """
+				<TestNodeObjectTrue>
+					<PFINALVALUEQ>-552</PFINALVALUEQ>
+				</TestNodeObjectTrue>""", """
+				<TestNodeObjectTrue>
+					<PFINALVALUER>-965</PFINALVALUER>
+				</TestNodeObjectTrue>""", """
+				<TestNodeObjectTrue>
+					<PFINALVALUES>-98885</PFINALVALUES>
+				</TestNodeObjectTrue>""", """
+				<TestNodeObjectTrue>
+					<VALUEA>55</VALUEA>
+				</TestNodeObjectTrue>""", """
+				<TestNodeObjectTrue>
+					<VALUEB>78</VALUEB>
+				</TestNodeObjectTrue>""", """
+				<TestNodeObjectTrue>
+					<VALUEC>51</VALUEC>
+				</TestNodeObjectTrue>""", """
+				<TestNodeObjectTrue>
+					<VALUEE>651</VALUEE>
+				</TestNodeObjectTrue>""", """
+				<TestNodeObjectTrue>
+					<VALUEF>654</VALUEF>
+				</TestNodeObjectTrue>""", """
+				<TestNodeObjectTrue>
+					<VALUEG>8552</VALUEG>
+				</TestNodeObjectTrue>""", """
+				<TestNodeObjectTrue>
+					<VALUEH>9531</VALUEH>
+				</TestNodeObjectTrue>""", """
+				<TestNodeObjectTrue>
+					<VALUEI>87465</VALUEI>
+				</TestNodeObjectTrue>""" };
 		for (int iii = 0; iii < testThatNotWork.length; iii++) {
 			final int jjj = iii;
-			Assertions.assertThrows(ExmlNodeDoesNotExist.class, () -> Exml.parseOne(testThatNotWork[jjj], elem.getClass(), ExmlTestIntrospectionObject.NODE_NAME));
+			Assertions.assertThrows(ExmlNodeDoesNotExist.class, () -> (new XmlMapper()).parse(testThatNotWork[jjj], elem.getClass()));
 		}
 	}
 	
@@ -1228,19 +1500,21 @@ public class ExmlTestIntrospectionDecoratorCaseSensitive {
 		elem.setValueK(885522);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		
 		final String[] testThatWork = {
-				"<elem finalValueM=\"321\" finalValueN=\"654\" finalValueO=\"987\" finalValueP=\"159\" finalValueQ=\"267\" finalValueR=\"264\" finalValueS=\"1524\" finalValueT=\"182445\" pFinalValueQ=\"-552\" pFinalValueR=\"-965\" pFinalValueS=\"-98885\" pFinalValueT=\"-8754\" valueA=\"55\" valueB=\"78\" valueC=\"51\" valueD=\"24\" valueE=\"651\" valueF=\"654\" valueG=\"8552\" valueH=\"9531\" valueI=\"87465\" valueJ=\"8247\" valueK=\"885522\"/>",
-				"<elem finalValueM=\"321\" finalValueN=\"654\" finalValueO=\"987\" FINALVALUEP=\"159\" finalValueQ=\"267\" finalValueR=\"264\" finalValueS=\"1524\" FINALVALUET=\"182445\" pFinalValueQ=\"-552\" pFinalValueR=\"-965\" pFinalValueS=\"-98885\" PFINALVALUET=\"-8754\" valueA=\"55\" valueB=\"78\" valueC=\"51\" VALUED=\"24\" valueE=\"651\" valueF=\"654\" valueG=\"8552\" valueH=\"9531\" valueI=\"87465\" VALUEJ=\"8247\" VALUEK=\"885522\"/>", };
+				"""
+						<TestAttributeObjectTrue finalValueM="321" finalValueN="654" finalValueO="987" finalValueP="159" finalValueQ="267" finalValueR="264" finalValueS="1524" finalValueT="182445" pFinalValueQ="-552" pFinalValueR="-965" pFinalValueS="-98885" pFinalValueT="-8754" valueA="55" valueB="78" valueC="51" valueD="24" valueE="651" valueF="654" valueG="8552" valueH="9531" valueI="87465" valueJ="8247" valueK="885522"/>""",
+				"""
+						<TestAttributeObjectTrue finalValueM="321" finalValueN="654" finalValueO="987" FINALVALUEP="159" finalValueQ="267" finalValueR="264" finalValueS="1524" FINALVALUET="182445" pFinalValueQ="-552" pFinalValueR="-965" pFinalValueS="-98885" PFINALVALUET="-8754" valueA="55" valueB="78" valueC="51" VALUED="24" valueE="651" valueF="654" valueG="8552" valueH="9531" valueI="87465" VALUEJ="8247" VALUEK="885522"/>""", };
 		
 		Assertions.assertEquals(testThatWork[0], dataTest);
 		
 		for (int iii = 0; iii < testThatWork.length; iii++) {
 			final int jjj = iii;
-			final TestAttributeObjectTrue root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(testThatWork[jjj], elem.getClass(), ExmlTestIntrospectionObject.NODE_NAME));
+			final TestAttributeObjectTrue root = Assertions.assertDoesNotThrow(() -> (new XmlMapper()).parse(testThatWork[jjj], elem.getClass()));
 			Assertions.assertEquals(55, root.valueA);
 			Assertions.assertEquals(78, root.valueB);
 			Assertions.assertEquals(51, root.valueC);
@@ -1265,12 +1539,27 @@ public class ExmlTestIntrospectionDecoratorCaseSensitive {
 			Assertions.assertEquals(-98885, root.getPFinalValueS());
 			Assertions.assertEquals(-8754, root.getPFinalValueT());
 		}
-		final String[] testThatNotWork = { "<elem FINALVALUEM=\"321\"/>", "<elem FINALVALUEN=\"654\"/>", "<elem FINALVALUEO=\"987\"/>", "<elem FINALVALUEQ=\"267\"/>", "<elem FINALVALUER=\"264\"/>",
-				"<elem FINALVALUES=\"1524\"/>", "<elem PFINALVALUEQ=\"-552\"/>", "<elem PFINALVALUER=\"-965\"/>", "<elem PFINALVALUES=\"-98885\"/>", "<elem VALUEA=\"55\"/>", "<elem VALUEB=\"78\"/>",
-				"<elem VALUEC=\"51\"/>", "<elem VALUEE=\"651\"/>", "<elem VALUEF=\"654\"/>", "<elem VALUEG=\"8552\"/>", "<elem VALUEH=\"9531\"/>", "<elem VALUEI=\"87465\"/>" };
+		final String[] testThatNotWork = { """
+				<TestAttributeObjectTrue FINALVALUEM="321"/>""", """
+				<TestAttributeObjectTrue FINALVALUEN="654"/>""", """
+				<TestAttributeObjectTrue FINALVALUEO="987"/>""", """
+				<TestAttributeObjectTrue FINALVALUEQ="267"/>""", """
+				<TestAttributeObjectTrue FINALVALUER="264"/>""", """
+				<TestAttributeObjectTrue FINALVALUES="1524"/>""", """
+				<TestAttributeObjectTrue PFINALVALUEQ="-552"/>""", """
+				<TestAttributeObjectTrue PFINALVALUER="-965"/>""", """
+				<TestAttributeObjectTrue PFINALVALUES="-98885"/>""", """
+				<TestAttributeObjectTrue VALUEA="55"/>""", """
+				<TestAttributeObjectTrue VALUEB="78"/>""", """
+				<TestAttributeObjectTrue VALUEC="51"/>""", """
+				<TestAttributeObjectTrue VALUEE="651"/>""", """
+				<TestAttributeObjectTrue VALUEF="654"/>""", """
+				<TestAttributeObjectTrue VALUEG="8552"/>""", """
+				<TestAttributeObjectTrue VALUEH="9531"/>""", """
+				<TestAttributeObjectTrue VALUEI="87465"/>""" };
 		for (int iii = 0; iii < testThatNotWork.length; iii++) {
 			final int jjj = iii;
-			Assertions.assertThrows(ExmlAttributeDoesNotExist.class, () -> Exml.parseOne(testThatNotWork[jjj], elem.getClass(), ExmlTestIntrospectionObject.NODE_NAME));
+			Assertions.assertThrows(ExmlAttributeDoesNotExist.class, () -> (new XmlMapper()).parse(testThatNotWork[jjj], elem.getClass()));
 		}
 	}
 }

test/src/test/atriasoft/exml/ExmlTestIntrospectionDecoratorManaged.java

@@ -8,7 +8,7 @@ package test.atriasoft.exml;
 import org.atriasoft.aknot.annotation.AknotDefaultManaged;
 import org.atriasoft.aknot.annotation.AknotManaged;
 import org.atriasoft.aknot.annotation.AknotName;
-import org.atriasoft.exml.Exml;
+import org.atriasoft.exml.XmlMapper;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -16,22 +16,21 @@ import org.junit.jupiter.api.Test;
 public class ExmlTestIntrospectionDecoratorManaged {
 	@AknotDefaultManaged
 	public class TestNodeObject {
-		
 		public int valueA;
 		@AknotManaged
 		public int valueB;
 		@AknotManaged(true)
 		public int valueC;
 		@AknotManaged(false)
-		public int valueD;
+		public int valueD = 8542;
 		
 		private int valueE;
 		private int valueF;
 		private int valueG;
 		private int valueH;
 		private int valueI;
-		private int valueJ;
-		private int valueK;
+		private int valueJ = 879454;
+		private int valueK = 74564;
 		
 		public final int finalValueM;
 		@AknotManaged
@@ -41,35 +40,32 @@ public class ExmlTestIntrospectionDecoratorManaged {
 		@AknotManaged(false)
 		public final int finalValueP;
 		
+		// special case for bijectivity with records
+		public final int finalValueQ;
+		public final int finalValueR;
+		public final int finalValueS;
+		public final int finalValueT;
+		
 		private final int pFinalValueQ;
 		private final int pFinalValueR;
 		private final int pFinalValueS;
 		private final int pFinalValueT;
 		
-		@AknotName({ "finalValueM", "finalValueN", "finalValueO", "pFinalValueQ", "pFinalValueR", "pFinalValueS" })
-		public TestNodeObject(final int finalValueM, final int finalValueN, final int finalValueO, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS) {
+		@AknotName({ "finalValueM", "finalValueN", "finalValueO", "finalValueQ", "finalValueR", "finalValueS", "pFinalValueQ", "pFinalValueR", "pFinalValueS", "finalValueT" })
+		public TestNodeObject(final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueQ, @AknotManaged final int finalValueR,
+				@AknotManaged(true) final int finalValueS, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS, final int finalValueT) {
 			this.finalValueM = finalValueM;
 			this.finalValueN = finalValueN;
 			this.finalValueO = finalValueO;
-			this.finalValueP = -555556;
+			this.finalValueP = 9988;
+			this.finalValueQ = finalValueQ;
+			this.finalValueR = finalValueR;
+			this.finalValueS = finalValueS;
+			this.finalValueT = 8454;
 			this.pFinalValueQ = pFinalValueQ;
 			this.pFinalValueR = pFinalValueR;
 			this.pFinalValueS = pFinalValueS;
-			this.pFinalValueT = -555557;
-		}
-		
-		// note: this constructor is not managed by the system ==> some field can not be instantiate (unmanaged ...)
-		@AknotName({ "finalValueM", "finalValueN", "finalValueO", "finalValueP", "pFinalValueQ", "pFinalValueR", "pFinalValueS", "pFinalValueT" })
-		public TestNodeObject(final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueP, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS,
-				final int pFinalValueT) {
-			this.finalValueM = finalValueM;
-			this.finalValueN = finalValueN;
-			this.finalValueO = finalValueO;
-			this.finalValueP = finalValueP;
-			this.pFinalValueQ = pFinalValueQ;
-			this.pFinalValueR = pFinalValueR;
-			this.pFinalValueS = pFinalValueS;
-			this.pFinalValueT = pFinalValueT;
+			this.pFinalValueT = finalValueT;
 		}
 		
 		public int getPFinalValueQ() {
@@ -165,13 +161,13 @@ public class ExmlTestIntrospectionDecoratorManaged {
 		@AknotManaged(false)
 		public int valueD;
 		
-		private int valueE;
-		private int valueF;
-		private int valueG;
-		private int valueH;
-		private int valueI;
-		private int valueJ;
-		private int valueK;
+		private int valueE = 564;
+		private int valueF = 655;
+		private int valueG = 852;
+		private int valueH = 566;
+		private int valueI = 456;
+		private int valueJ = 857;
+		private int valueK = 9875;
 		
 		public final int finalValueM;
 		@AknotManaged
@@ -190,10 +186,45 @@ public class ExmlTestIntrospectionDecoratorManaged {
 		private final int pFinalValueQ;
 		private final int pFinalValueR;
 		private final int pFinalValueS;
-		private final int pFinalValueT;
+		private final int pFinalValueT; // Note that element can be never defined outside the constructor static values
+		
+		@AknotManaged(false)
+		public TestNodeObjectFalse() {
+			this.finalValueM = 45646;
+			this.finalValueN = 789645363;
+			this.finalValueO = 7894;
+			this.finalValueP = 45646;
+			this.finalValueQ = 45646;
+			this.finalValueR = 45645;
+			this.finalValueS = 1231;
+			this.finalValueT = 8976545;
+			this.pFinalValueQ = 7;
+			this.pFinalValueR = 456456;
+			this.pFinalValueS = 4564;
+			this.pFinalValueT = 1;
+		}
+		
+		@AknotName({ "finalValueN", "finalValueO", "finalValueR", "finalValueS", "pFinalValueR", "pFinalValueS" })
+		@AknotManaged
+		public TestNodeObjectFalse(final int finalValueN, final int finalValueO, @AknotManaged final int finalValueR, @AknotManaged(true) final int finalValueS, final int pFinalValueR,
+				final int pFinalValueS) {
+			this.finalValueM = 987;
+			this.finalValueN = finalValueN;
+			this.finalValueO = finalValueO;
+			this.finalValueP = 852;
+			this.finalValueQ = 951;
+			this.finalValueR = finalValueR;
+			this.finalValueS = finalValueS;
+			this.finalValueT = 9999;
+			this.pFinalValueQ = 7523;
+			this.pFinalValueR = pFinalValueR;
+			this.pFinalValueS = pFinalValueS;
+			this.pFinalValueT = 753;
+			this.valueA = 99;
+			this.valueD = 9845;
+			
+		}
 		
-		@AknotName({ "finalValueM", "finalValueN", "finalValueO", "finalValueP", "finalValueQ", "finalValueR", "finalValueS", "finalValueT", "pFinalValueQ", "pFinalValueR", "pFinalValueS",
-				"pFinalValueT" })
 		public TestNodeObjectFalse(final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueP, final int finalValueQ, @AknotManaged final int finalValueR,
 				@AknotManaged(true) final int finalValueS, @AknotManaged(false) final int finalValueT, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS, final int pFinalValueT) {
 			this.finalValueM = finalValueM;
@@ -301,15 +332,15 @@ public class ExmlTestIntrospectionDecoratorManaged {
 		@AknotManaged(true)
 		public int valueC;
 		@AknotManaged(false)
-		public int valueD;
+		public int valueD = 8542;
 		
 		private int valueE;
 		private int valueF;
 		private int valueG;
 		private int valueH;
 		private int valueI;
-		private int valueJ;
-		private int valueK;
+		private int valueJ = 879454;
+		private int valueK = 74564;
 		
 		public final int finalValueM;
 		@AknotManaged
@@ -330,22 +361,21 @@ public class ExmlTestIntrospectionDecoratorManaged {
 		private final int pFinalValueS;
 		private final int pFinalValueT;
 		
-		@AknotName({ "finalValueM", "finalValueN", "finalValueO", "finalValueP", "finalValueQ", "finalValueR", "finalValueS", "finalValueT", "pFinalValueQ", "pFinalValueR", "pFinalValueS",
-				"pFinalValueT" })
-		public TestNodeObjectTrue(final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueP, final int finalValueQ, @AknotManaged final int finalValueR,
-				@AknotManaged(true) final int finalValueS, @AknotManaged(false) final int finalValueT, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS, final int pFinalValueT) {
+		@AknotName({ "finalValueM", "finalValueN", "finalValueO", "finalValueQ", "finalValueR", "finalValueS", "pFinalValueQ", "pFinalValueR", "pFinalValueS", "finalValueT" })
+		public TestNodeObjectTrue(final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueQ, @AknotManaged final int finalValueR,
+				@AknotManaged(true) final int finalValueS, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS, final int finalValueT) {
 			this.finalValueM = finalValueM;
 			this.finalValueN = finalValueN;
 			this.finalValueO = finalValueO;
-			this.finalValueP = finalValueP;
+			this.finalValueP = 9988;
 			this.finalValueQ = finalValueQ;
 			this.finalValueR = finalValueR;
 			this.finalValueS = finalValueS;
-			this.finalValueT = finalValueT;
+			this.finalValueT = 8454;
 			this.pFinalValueQ = pFinalValueQ;
 			this.pFinalValueR = pFinalValueR;
 			this.pFinalValueS = pFinalValueS;
-			this.pFinalValueT = pFinalValueT;
+			this.pFinalValueT = finalValueT;
 		}
 		
 		public int getPFinalValueQ() {
@@ -443,7 +473,7 @@ public class ExmlTestIntrospectionDecoratorManaged {
 	// ************************************************************
 	@Test
 	public void testDefaultManaged() {
-		final TestNodeObject elem = new TestNodeObject(321, 654, 987, 159, -552, -965, -98885, -8754);
+		final TestNodeObject elem = new TestNodeObject(321, 654, 987, 267, 264, 1524, -552, -965, -98885, 8452);
 		elem.valueA = 55;
 		elem.valueB = 78;
 		elem.valueC = 51;
@@ -457,14 +487,18 @@ public class ExmlTestIntrospectionDecoratorManaged {
 		elem.setValueK(885522);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
-		Log.warning("data generated: " + dataTest);
+		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeObject>
 					<finalValueM>321</finalValueM>
 					<finalValueN>654</finalValueN>
 					<finalValueO>987</finalValueO>
+					<finalValueQ>267</finalValueQ>
+					<finalValueR>264</finalValueR>
+					<finalValueS>1524</finalValueS>
+					<finalValueT>8454</finalValueT>
 					<pFinalValueQ>-552</pFinalValueQ>
 					<pFinalValueR>-965</pFinalValueR>
 					<pFinalValueS>-98885</pFinalValueS>
@@ -476,28 +510,36 @@ public class ExmlTestIntrospectionDecoratorManaged {
 					<valueG>8552</valueG>
 					<valueH>9531</valueH>
 					<valueI>87465</valueI>
-				</elem>""", dataTest);
+				</TestNodeObject>""", dataTest);
 		
-		final TestNodeObject root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObject.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestNodeObject root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeObject.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(55, root.valueA);
 		Assertions.assertEquals(78, root.valueB);
 		Assertions.assertEquals(51, root.valueC);
-		Assertions.assertEquals(24, root.valueD);
+		Assertions.assertEquals(8542, root.valueD);
 		Assertions.assertEquals(651, root.getValueE());
 		Assertions.assertEquals(654, root.getValueF());
 		Assertions.assertEquals(8552, root.getValueG());
 		Assertions.assertEquals(9531, root.getValueH());
 		Assertions.assertEquals(87465, root.getValueI());
-		Assertions.assertEquals(8247, root.getValueJ());
-		Assertions.assertEquals(885522, root.getValueK());
+		Assertions.assertEquals(879454, root.getValueJ());
+		Assertions.assertEquals(74564, root.getValueK());
 		Assertions.assertEquals(321, root.finalValueM);
 		Assertions.assertEquals(654, root.finalValueN);
 		Assertions.assertEquals(987, root.finalValueO);
-		Assertions.assertEquals(-555556, root.finalValueP);
+		Assertions.assertEquals(9988, root.finalValueP);
+		Assertions.assertEquals(267, root.finalValueQ);
+		Assertions.assertEquals(264, root.finalValueR);
+		Assertions.assertEquals(1524, root.finalValueS);
+		Assertions.assertEquals(8454, root.finalValueT);
 		Assertions.assertEquals(-552, root.getPFinalValueQ());
 		Assertions.assertEquals(-965, root.getPFinalValueR());
 		Assertions.assertEquals(-98885, root.getPFinalValueS());
-		Assertions.assertEquals(-555557, root.getPFinalValueT());
+		Assertions.assertEquals(8454, root.getPFinalValueT());
 	}
 	
 	@Test
@@ -516,55 +558,58 @@ public class ExmlTestIntrospectionDecoratorManaged {
 		elem.setValueK(885522);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals(
-				"""
-						<elem finalValueN="654" finalValueO="987" finalValueR="264" finalValueS="1524" pFinalValueR="-965" pFinalValueS="-98885" valueB="78" valueC="51" valueF="654" valueG="8552" valueH="9531" valueI="87465">
-							<finalValueM>321</finalValueM>
-							<finalValueP>159</finalValueP>
-							<finalValueQ>267</finalValueQ>
-							<finalValueT>182445</finalValueT>
-							<pFinalValueQ>-552</pFinalValueQ>
-							<pFinalValueT>-8754</pFinalValueT>
-							<valueA>55</valueA>
-							<valueD>24</valueD>
-							<valueE>651</valueE>
-							<valueJ>8247</valueJ>
-							<valueK>885522</valueK>
-						</elem>""",
-				dataTest);
+		Assertions.assertEquals("""
+				<TestNodeObjectFalse>
+					<finalValueN>654</finalValueN>
+					<finalValueO>987</finalValueO>
+					<finalValueR>264</finalValueR>
+					<finalValueS>1524</finalValueS>
+					<pFinalValueR>-965</pFinalValueR>
+					<pFinalValueS>-98885</pFinalValueS>
+					<valueB>78</valueB>
+					<valueC>51</valueC>
+					<valueF>654</valueF>
+					<valueG>8552</valueG>
+					<valueH>9531</valueH>
+					<valueI>87465</valueI>
+				</TestNodeObjectFalse>""", dataTest);
 		
-		final TestNodeObjectFalse root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObjectFalse.class, ExmlTestIntrospectionObject.NODE_NAME));
-		Assertions.assertEquals(55, root.valueA);
+		final TestNodeObjectFalse root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeObjectFalse.class);
+		});
+		Assertions.assertNotNull(root);
+		Assertions.assertEquals(99, root.valueA);
 		Assertions.assertEquals(78, root.valueB);
 		Assertions.assertEquals(51, root.valueC);
-		Assertions.assertEquals(24, root.valueD);
-		Assertions.assertEquals(651, root.getValueE());
+		Assertions.assertEquals(9845, root.valueD);
+		Assertions.assertEquals(564, root.getValueE());
 		Assertions.assertEquals(654, root.getValueF());
 		Assertions.assertEquals(8552, root.getValueG());
 		Assertions.assertEquals(9531, root.getValueH());
 		Assertions.assertEquals(87465, root.getValueI());
-		Assertions.assertEquals(8247, root.getValueJ());
-		Assertions.assertEquals(885522, root.getValueK());
-		Assertions.assertEquals(321, root.finalValueM);
+		Assertions.assertEquals(857, root.getValueJ());
+		Assertions.assertEquals(9875, root.getValueK());
+		Assertions.assertEquals(987, root.finalValueM);
 		Assertions.assertEquals(654, root.finalValueN);
 		Assertions.assertEquals(987, root.finalValueO);
-		Assertions.assertEquals(159, root.finalValueP);
-		Assertions.assertEquals(267, root.finalValueQ);
+		Assertions.assertEquals(852, root.finalValueP);
+		Assertions.assertEquals(951, root.finalValueQ);
 		Assertions.assertEquals(264, root.finalValueR);
 		Assertions.assertEquals(1524, root.finalValueS);
-		Assertions.assertEquals(182445, root.finalValueT);
-		Assertions.assertEquals(-552, root.getPFinalValueQ());
+		Assertions.assertEquals(9999, root.finalValueT);
+		Assertions.assertEquals(7523, root.getPFinalValueQ());
 		Assertions.assertEquals(-965, root.getPFinalValueR());
 		Assertions.assertEquals(-98885, root.getPFinalValueS());
-		Assertions.assertEquals(-8754, root.getPFinalValueT());
+		Assertions.assertEquals(753, root.getPFinalValueT());
 	}
 	
 	@Test
 	public void testDefaultManagedTrue() {
-		final TestNodeObjectTrue elem = new TestNodeObjectTrue(321, 654, 987, 159, 267, 264, 1524, 182445, -552, -965, -98885, -8754);
+		final TestNodeObjectTrue elem = new TestNodeObjectTrue(321, 654, 987, 267, 264, 1524, -552, -965, -98885, 8452);
 		elem.valueA = 55;
 		elem.valueB = 78;
 		elem.valueC = 51;
@@ -578,45 +623,59 @@ public class ExmlTestIntrospectionDecoratorManaged {
 		elem.setValueK(885522);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals(
-				"""
-						<elem finalValueM="321" finalValueN="654" finalValueO="987" finalValueQ="267" finalValueR="264" finalValueS="1524" pFinalValueQ="-552" pFinalValueR="-965" pFinalValueS="-98885" valueA="55" valueB="78" valueC="51" valueE="651" valueF="654" valueG="8552" valueH="9531" valueI="87465">
-							<finalValueP>159</finalValueP>
-							<finalValueT>182445</finalValueT>
-							<pFinalValueT>-8754</pFinalValueT>
-							<valueD>24</valueD>
-							<valueJ>8247</valueJ>
-							<valueK>885522</valueK>
-						</elem>""",
-				dataTest);
+		Assertions.assertEquals("""
+				<TestNodeObjectTrue>
+					<finalValueM>321</finalValueM>
+					<finalValueN>654</finalValueN>
+					<finalValueO>987</finalValueO>
+					<finalValueQ>267</finalValueQ>
+					<finalValueR>264</finalValueR>
+					<finalValueS>1524</finalValueS>
+					<finalValueT>8454</finalValueT>
+					<pFinalValueQ>-552</pFinalValueQ>
+					<pFinalValueR>-965</pFinalValueR>
+					<pFinalValueS>-98885</pFinalValueS>
+					<valueA>55</valueA>
+					<valueB>78</valueB>
+					<valueC>51</valueC>
+					<valueE>651</valueE>
+					<valueF>654</valueF>
+					<valueG>8552</valueG>
+					<valueH>9531</valueH>
+					<valueI>87465</valueI>
+				</TestNodeObjectTrue>""", dataTest);
 		
-		final TestNodeObjectTrue root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObjectTrue.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestNodeObjectTrue root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeObjectTrue.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(55, root.valueA);
 		Assertions.assertEquals(78, root.valueB);
 		Assertions.assertEquals(51, root.valueC);
-		Assertions.assertEquals(24, root.valueD);
+		Assertions.assertEquals(8542, root.valueD);
 		Assertions.assertEquals(651, root.getValueE());
 		Assertions.assertEquals(654, root.getValueF());
 		Assertions.assertEquals(8552, root.getValueG());
 		Assertions.assertEquals(9531, root.getValueH());
 		Assertions.assertEquals(87465, root.getValueI());
-		Assertions.assertEquals(8247, root.getValueJ());
-		Assertions.assertEquals(885522, root.getValueK());
+		Assertions.assertEquals(879454, root.getValueJ());
+		Assertions.assertEquals(74564, root.getValueK());
 		Assertions.assertEquals(321, root.finalValueM);
 		Assertions.assertEquals(654, root.finalValueN);
 		Assertions.assertEquals(987, root.finalValueO);
-		Assertions.assertEquals(159, root.finalValueP);
+		Assertions.assertEquals(9988, root.finalValueP);
 		Assertions.assertEquals(267, root.finalValueQ);
 		Assertions.assertEquals(264, root.finalValueR);
 		Assertions.assertEquals(1524, root.finalValueS);
-		Assertions.assertEquals(182445, root.finalValueT);
+		Assertions.assertEquals(8454, root.finalValueT);
 		Assertions.assertEquals(-552, root.getPFinalValueQ());
 		Assertions.assertEquals(-965, root.getPFinalValueR());
 		Assertions.assertEquals(-98885, root.getPFinalValueS());
-		Assertions.assertEquals(-8754, root.getPFinalValueT());
+		Assertions.assertEquals(8454, root.getPFinalValueT());
 	}
 	
 }

test/src/test/atriasoft/exml/ExmlTestIntrospectionDecoratorNames.java

@@ -5,10 +5,10 @@
  */
 package test.atriasoft.exml;
 
-import org.atriasoft.aknot.annotation.AknotName;
 import org.atriasoft.aknot.annotation.AknotAttribute;
 import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
-import org.atriasoft.exml.Exml;
+import org.atriasoft.aknot.annotation.AknotName;
+import org.atriasoft.exml.XmlMapper;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -84,7 +84,8 @@ public class ExmlTestIntrospectionDecoratorNames {
 		@AknotName({ "finalValueM", "finalValueN", "finalValueO", "finalValueP", "finalValueQ", "finalValueR", "finalValueS", "finalValueT", "pFinalValueQ", "pFinalValueR", "pFinalValueS",
 				"pFinalValueT" })
 		public TestNodeObject(final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueP, final int finalValueQ, @AknotAttribute final int finalValueR,
-				@AknotAttribute(true) final int finalValueS, @AknotAttribute(false) final int finalValueT, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS, final int pFinalValueT) {
+				@AknotAttribute(true) final int finalValueS, @AknotAttribute(false) final int finalValueT, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS,
+				final int pFinalValueT) {
 			this.finalValueM = finalValueM;
 			this.finalValueN = finalValueN;
 			this.finalValueO = finalValueO;
@@ -222,7 +223,8 @@ public class ExmlTestIntrospectionDecoratorNames {
 		@AknotName({ "finalValueM", "finalValueN", "finalValueO", "finalValueP", "finalValueQ", "finalValueR", "finalValueS", "finalValueT", "pFinalValueQ", "pFinalValueR", "pFinalValueS",
 				"pFinalValueT" })
 		public TestNodeObjectFalse(final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueP, final int finalValueQ, @AknotAttribute final int finalValueR,
-				@AknotAttribute(true) final int finalValueS, @AknotAttribute(false) final int finalValueT, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS, final int pFinalValueT) {
+				@AknotAttribute(true) final int finalValueS, @AknotAttribute(false) final int finalValueT, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS,
+				final int pFinalValueT) {
 			this.finalValueM = finalValueM;
 			this.finalValueN = finalValueN;
 			this.finalValueO = finalValueO;
@@ -360,7 +362,8 @@ public class ExmlTestIntrospectionDecoratorNames {
 		@AknotName({ "finalValueM", "finalValueN", "finalValueO", "finalValueP", "finalValueQ", "finalValueR", "finalValueS", "finalValueT", "pFinalValueQ", "pFinalValueR", "pFinalValueS",
 				"pFinalValueT" })
 		public TestNodeObjectTrue(final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueP, final int finalValueQ, @AknotAttribute final int finalValueR,
-				@AknotAttribute(true) final int finalValueS, @AknotAttribute(false) final int finalValueT, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS, final int pFinalValueT) {
+				@AknotAttribute(true) final int finalValueS, @AknotAttribute(false) final int finalValueT, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS,
+				final int pFinalValueT) {
 			this.finalValueM = finalValueM;
 			this.finalValueN = finalValueN;
 			this.finalValueO = finalValueO;
@@ -477,16 +480,20 @@ public class ExmlTestIntrospectionDecoratorNames {
 		elem.setValue3RataPlouf("24");
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem value3="24" value4="78">
+				<ChangingNames value3="24" value4="78">
 					<value1>51</value1>
 					<value2>55</value2>
-				</elem>""", dataTest);
+				</ChangingNames>""", dataTest);
 		
-		final ChangingNames root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, ChangingNames.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final ChangingNames root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, ChangingNames.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals("55", root.value2Ballet);
 		Assertions.assertEquals("78", root.value4Ballet);
 		Assertions.assertEquals("51", root.getValue1RataPlouf());
@@ -509,22 +516,26 @@ public class ExmlTestIntrospectionDecoratorNames {
 		elem.setValueK(885522);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + dataTest);
 		Assertions.assertEquals(
 				"""
-						<elem finalValueM="321" finalValueN="654" finalValueO="987" finalValueQ="267" finalValueR="264" finalValueS="1524" pFinalValueQ="-552" pFinalValueR="-965" pFinalValueS="-98885" valueA="55" valueB="78" valueC="51" valueE="651" valueF="654" valueG="8552" valueH="9531" valueI="87465">
+						<TestNodeObject finalValueM="321" finalValueN="654" finalValueO="987" finalValueQ="267" finalValueR="264" finalValueS="1524" pFinalValueQ="-552" pFinalValueR="-965" pFinalValueS="-98885" valueA="55" valueB="78" valueC="51" valueE="651" valueF="654" valueG="8552" valueH="9531" valueI="87465">
 							<finalValueP>159</finalValueP>
 							<finalValueT>182445</finalValueT>
 							<pFinalValueT>-8754</pFinalValueT>
 							<valueD>24</valueD>
 							<valueJ>8247</valueJ>
 							<valueK>885522</valueK>
-						</elem>""",
+						</TestNodeObject>""",
 				dataTest);
 		
-		final TestNodeObject root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObject.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestNodeObject root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeObject.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(55, root.valueA);
 		Assertions.assertEquals(78, root.valueB);
 		Assertions.assertEquals(51, root.valueC);
@@ -566,12 +577,12 @@ public class ExmlTestIntrospectionDecoratorNames {
 		elem.setValueK(885522);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals(
 				"""
-						<elem finalValueN="654" finalValueO="987" finalValueR="264" finalValueS="1524" pFinalValueR="-965" pFinalValueS="-98885" valueB="78" valueC="51" valueF="654" valueG="8552" valueH="9531" valueI="87465">
+						<TestNodeObjectFalse finalValueN="654" finalValueO="987" finalValueR="264" finalValueS="1524" pFinalValueR="-965" pFinalValueS="-98885" valueB="78" valueC="51" valueF="654" valueG="8552" valueH="9531" valueI="87465">
 							<finalValueM>321</finalValueM>
 							<finalValueP>159</finalValueP>
 							<finalValueQ>267</finalValueQ>
@@ -583,10 +594,14 @@ public class ExmlTestIntrospectionDecoratorNames {
 							<valueE>651</valueE>
 							<valueJ>8247</valueJ>
 							<valueK>885522</valueK>
-						</elem>""",
+						</TestNodeObjectFalse>""",
 				dataTest);
 		
-		final TestNodeObjectFalse root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObjectFalse.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestNodeObjectFalse root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeObjectFalse.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(55, root.valueA);
 		Assertions.assertEquals(78, root.valueB);
 		Assertions.assertEquals(51, root.valueC);
@@ -628,22 +643,26 @@ public class ExmlTestIntrospectionDecoratorNames {
 		elem.setValueK(885522);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals(
 				"""
-						<elem finalValueM="321" finalValueN="654" finalValueO="987" finalValueQ="267" finalValueR="264" finalValueS="1524" pFinalValueQ="-552" pFinalValueR="-965" pFinalValueS="-98885" valueA="55" valueB="78" valueC="51" valueE="651" valueF="654" valueG="8552" valueH="9531" valueI="87465">
+						<TestNodeObjectTrue finalValueM="321" finalValueN="654" finalValueO="987" finalValueQ="267" finalValueR="264" finalValueS="1524" pFinalValueQ="-552" pFinalValueR="-965" pFinalValueS="-98885" valueA="55" valueB="78" valueC="51" valueE="651" valueF="654" valueG="8552" valueH="9531" valueI="87465">
 							<finalValueP>159</finalValueP>
 							<finalValueT>182445</finalValueT>
 							<pFinalValueT>-8754</pFinalValueT>
 							<valueD>24</valueD>
 							<valueJ>8247</valueJ>
 							<valueK>885522</valueK>
-						</elem>""",
+						</TestNodeObjectTrue>""",
 				dataTest);
 		
-		final TestNodeObjectTrue root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObjectTrue.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestNodeObjectTrue root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeObjectTrue.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(55, root.valueA);
 		Assertions.assertEquals(78, root.valueB);
 		Assertions.assertEquals(51, root.valueC);

test/src/test/atriasoft/exml/ExmlTestIntrospectionDecoratorOptionnal.java

@@ -8,7 +8,7 @@ package test.atriasoft.exml;
 import org.atriasoft.aknot.annotation.AknotDefaultOptional;
 import org.atriasoft.aknot.annotation.AknotName;
 import org.atriasoft.aknot.annotation.AknotOptional;
-import org.atriasoft.exml.Exml;
+import org.atriasoft.exml.XmlMapper;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -458,22 +458,41 @@ public class ExmlTestIntrospectionDecoratorOptionnal {
 		elem.setValueK(885522);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + dataTest);
-		Assertions.assertEquals(
-				"""
-						<elem finalValueM="321" finalValueN="654" finalValueO="987" finalValueQ="267" finalValueR="264" finalValueS="1524" pFinalValueQ="-552" pFinalValueR="-965" pFinalValueS="-98885" valueA="55" valueB="78" valueC="51" valueE="651" valueF="654" valueG="8552" valueH="9531" valueI="87465">
+		Assertions.assertEquals("""
+				<TestNodeObject>
+					<finalValueM>321</finalValueM>
+					<finalValueN>654</finalValueN>
+					<finalValueO>987</finalValueO>
 					<finalValueP>159</finalValueP>
+					<finalValueQ>267</finalValueQ>
+					<finalValueR>264</finalValueR>
+					<finalValueS>1524</finalValueS>
 					<finalValueT>182445</finalValueT>
+					<pFinalValueQ>-552</pFinalValueQ>
+					<pFinalValueR>-965</pFinalValueR>
+					<pFinalValueS>-98885</pFinalValueS>
 					<pFinalValueT>-8754</pFinalValueT>
+					<valueA>55</valueA>
+					<valueB>78</valueB>
+					<valueC>51</valueC>
 					<valueD>24</valueD>
+					<valueE>651</valueE>
+					<valueF>654</valueF>
+					<valueG>8552</valueG>
+					<valueH>9531</valueH>
+					<valueI>87465</valueI>
 					<valueJ>8247</valueJ>
 					<valueK>885522</valueK>
-						</elem>""",
-				dataTest);
+				</TestNodeObject>""", dataTest);
 		
-		final TestNodeObject root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObject.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestNodeObject root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeObject.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(55, root.valueA);
 		Assertions.assertEquals(78, root.valueB);
 		Assertions.assertEquals(51, root.valueC);
@@ -515,27 +534,41 @@ public class ExmlTestIntrospectionDecoratorOptionnal {
 		elem.setValueK(885522);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals(
-				"""
-						<elem finalValueN="654" finalValueO="987" finalValueR="264" finalValueS="1524" pFinalValueR="-965" pFinalValueS="-98885" valueB="78" valueC="51" valueF="654" valueG="8552" valueH="9531" valueI="87465">
+		Assertions.assertEquals("""
+				<TestNodeObjectFalse>
 					<finalValueM>321</finalValueM>
+					<finalValueN>654</finalValueN>
+					<finalValueO>987</finalValueO>
 					<finalValueP>159</finalValueP>
 					<finalValueQ>267</finalValueQ>
+					<finalValueR>264</finalValueR>
+					<finalValueS>1524</finalValueS>
 					<finalValueT>182445</finalValueT>
 					<pFinalValueQ>-552</pFinalValueQ>
+					<pFinalValueR>-965</pFinalValueR>
+					<pFinalValueS>-98885</pFinalValueS>
 					<pFinalValueT>-8754</pFinalValueT>
 					<valueA>55</valueA>
+					<valueB>78</valueB>
+					<valueC>51</valueC>
 					<valueD>24</valueD>
 					<valueE>651</valueE>
+					<valueF>654</valueF>
+					<valueG>8552</valueG>
+					<valueH>9531</valueH>
+					<valueI>87465</valueI>
 					<valueJ>8247</valueJ>
 					<valueK>885522</valueK>
-						</elem>""",
-				dataTest);
+				</TestNodeObjectFalse>""", dataTest);
 		
-		final TestNodeObjectFalse root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObjectFalse.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestNodeObjectFalse root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeObjectFalse.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(55, root.valueA);
 		Assertions.assertEquals(78, root.valueB);
 		Assertions.assertEquals(51, root.valueC);
@@ -577,22 +610,41 @@ public class ExmlTestIntrospectionDecoratorOptionnal {
 		elem.setValueK(885522);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals(
-				"""
-						<elem finalValueM="321" finalValueN="654" finalValueO="987" finalValueQ="267" finalValueR="264" finalValueS="1524" pFinalValueQ="-552" pFinalValueR="-965" pFinalValueS="-98885" valueA="55" valueB="78" valueC="51" valueE="651" valueF="654" valueG="8552" valueH="9531" valueI="87465">
+		Assertions.assertEquals("""
+				<TestNodeObjectTrue>
+					<finalValueM>321</finalValueM>
+					<finalValueN>654</finalValueN>
+					<finalValueO>987</finalValueO>
 					<finalValueP>159</finalValueP>
+					<finalValueQ>267</finalValueQ>
+					<finalValueR>264</finalValueR>
+					<finalValueS>1524</finalValueS>
 					<finalValueT>182445</finalValueT>
+					<pFinalValueQ>-552</pFinalValueQ>
+					<pFinalValueR>-965</pFinalValueR>
+					<pFinalValueS>-98885</pFinalValueS>
 					<pFinalValueT>-8754</pFinalValueT>
+					<valueA>55</valueA>
+					<valueB>78</valueB>
+					<valueC>51</valueC>
 					<valueD>24</valueD>
+					<valueE>651</valueE>
+					<valueF>654</valueF>
+					<valueG>8552</valueG>
+					<valueH>9531</valueH>
+					<valueI>87465</valueI>
 					<valueJ>8247</valueJ>
 					<valueK>885522</valueK>
-						</elem>""",
-				dataTest);
+				</TestNodeObjectTrue>""", dataTest);
 		
-		final TestNodeObjectTrue root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObjectTrue.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestNodeObjectTrue root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeObjectTrue.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(55, root.valueA);
 		Assertions.assertEquals(78, root.valueB);
 		Assertions.assertEquals(51, root.valueC);

test/src/test/atriasoft/exml/ExmlTestIntrospectionDouble.java

@@ -7,9 +7,9 @@ package test.atriasoft.exml;
 
 import java.util.List;
 
-import org.atriasoft.aknot.annotation.AknotList;
 import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
-import org.atriasoft.exml.Exml;
+import org.atriasoft.aknot.annotation.AknotList;
+import org.atriasoft.exml.XmlMapper;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -183,11 +183,11 @@ public class ExmlTestIntrospectionDouble {
 		elem.values = new Double[] { (double) 12, (double) -13, (double) 33, (double) 78, (double) -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeDoubleStructured>
 					<values>
 						<elem>12.0</elem>
 						<elem>-13.0</elem>
@@ -195,9 +195,13 @@ public class ExmlTestIntrospectionDouble {
 						<elem>78.0</elem>
 						<elem>-127.0</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestArrayNodeDoubleStructured>""", dataTest);
 		
-		final TestArrayNodeDoubleStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeDoubleStructured.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestArrayNodeDoubleStructured root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeDoubleStructured.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals((double) 5, root.values.length);
 		Assertions.assertEquals(12, root.values[0]);
 		Assertions.assertEquals(-13, root.values[1]);
@@ -212,11 +216,11 @@ public class ExmlTestIntrospectionDouble {
 		elem.values = List.of((double) 12, (double) -13, (double) 33, (double) 78, (double) -127);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeDoubleStructured>
 					<values>
 						<elem>12.0</elem>
 						<elem>-13.0</elem>
@@ -224,9 +228,13 @@ public class ExmlTestIntrospectionDouble {
 						<elem>78.0</elem>
 						<elem>-127.0</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestListNodeDoubleStructured>""", dataTest);
 		
-		final TestListNodeDoubleStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeDoubleStructured.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestListNodeDoubleStructured root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeDoubleStructured.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.size());
 		Assertions.assertEquals(12, root.values.get(0));
 		Assertions.assertEquals(-13, root.values.get(1));
@@ -241,12 +249,16 @@ public class ExmlTestIntrospectionDouble {
 		elem.values = new Double[] { (double) 12, (double) -13, (double) 33, (double) 78, (double) -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayDouble values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
 		
-		final TestArrayDouble root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayDouble.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestArrayDouble root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayDouble.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(12, root.values[0]);
 		Assertions.assertEquals(-13, root.values[1]);
@@ -261,12 +273,16 @@ public class ExmlTestIntrospectionDouble {
 		elem.setValues(new Double[] { (double) 12, (double) -13, (double) 33, (double) 78, (double) -127 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayDoubleFunc values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
 		
-		final TestArrayDoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayDoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestArrayDoubleFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayDoubleFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals(12, root.getValues()[0]);
 		Assertions.assertEquals(-13, root.getValues()[1]);
@@ -281,19 +297,23 @@ public class ExmlTestIntrospectionDouble {
 		elem.values = new Double[] { (double) 12, (double) -13, (double) 33, (double) 78, (double) -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeDouble>
 					<values>12.0</values>
 					<values>-13.0</values>
 					<values>33.0</values>
 					<values>78.0</values>
 					<values>-127.0</values>
-				</elem>""", dataTest);
+				</TestArrayNodeDouble>""", dataTest);
 		
-		final TestArrayNodeDouble root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeDouble.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestArrayNodeDouble root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeDouble.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(12, root.values[0]);
 		Assertions.assertEquals(-13, root.values[1]);
@@ -308,19 +328,23 @@ public class ExmlTestIntrospectionDouble {
 		elem.setValues(new Double[] { (double) 12, (double) -13, (double) 33, (double) 78, (double) -127 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeDoubleFunc>
 					<values>12.0</values>
 					<values>-13.0</values>
 					<values>33.0</values>
 					<values>78.0</values>
 					<values>-127.0</values>
-				</elem>""", dataTest);
+				</TestArrayNodeDoubleFunc>""", dataTest);
 		
-		final TestArrayNodeDoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeDoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestArrayNodeDoubleFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeDoubleFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals(12, root.getValues()[0]);
 		Assertions.assertEquals(-13, root.getValues()[1]);
@@ -337,12 +361,16 @@ public class ExmlTestIntrospectionDouble {
 		elem.valueNull = null;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"12.0\" valueB=\"-13.0\"/>", dataTest);
+		Assertions.assertEquals("<TestDouble valueA=\"12.0\" valueB=\"-13.0\"/>", dataTest);
 		
-		final TestDouble root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestDouble.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestDouble root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestDouble.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(12, root.valueA);
 		Assertions.assertEquals(-13, root.valueB);
 		Assertions.assertEquals(null, root.valueNull);
@@ -356,12 +384,16 @@ public class ExmlTestIntrospectionDouble {
 		elem.setValueNull(null);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"-55.0\" valueB=\"57.0\"/>", dataTest);
+		Assertions.assertEquals("<TestDoubleFunc valueA=\"-55.0\" valueB=\"57.0\"/>", dataTest);
 		
-		final TestDoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestDoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestDoubleFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestDoubleFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(-55, root.getValueA());
 		Assertions.assertEquals(57, root.getValueB());
 		Assertions.assertEquals(null, root.getValueNull());
@@ -373,12 +405,16 @@ public class ExmlTestIntrospectionDouble {
 		elem.values = List.of((double) 12, (double) -13, (double) 33, (double) 78, (double) -127);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
+		Assertions.assertEquals("<TestListDouble values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
 		
-		final TestListDouble root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListDouble.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestListDouble root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListDouble.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.size());
 		Assertions.assertEquals(12, root.values.get(0));
 		Assertions.assertEquals(-13, root.values.get(1));
@@ -393,12 +429,16 @@ public class ExmlTestIntrospectionDouble {
 		elem.setValues(List.of((double) 12, (double) -13, (double) 33, (double) 78, (double) -127));
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
+		Assertions.assertEquals("<TestListDoubleFunc values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
 		
-		final TestListDoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListDoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestListDoubleFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListDoubleFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().size());
 		Assertions.assertEquals(12, root.getValues().get(0));
 		Assertions.assertEquals(-13, root.getValues().get(1));
@@ -413,19 +453,23 @@ public class ExmlTestIntrospectionDouble {
 		elem.values = List.of((double) 12, (double) -13, (double) 33, (double) 78, (double) -127);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeDouble>
 					<values>12.0</values>
 					<values>-13.0</values>
 					<values>33.0</values>
 					<values>78.0</values>
 					<values>-127.0</values>
-				</elem>""", dataTest);
+				</TestListNodeDouble>""", dataTest);
 		
-		final TestListNodeDouble root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeDouble.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestListNodeDouble root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeDouble.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.size());
 		Assertions.assertEquals(12, root.values.get(0));
 		Assertions.assertEquals(-13, root.values.get(1));
@@ -440,19 +484,23 @@ public class ExmlTestIntrospectionDouble {
 		elem.setValues(List.of((double) 12, (double) -13, (double) 33, (double) 78, (double) -127));
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeDoubleFunc>
 					<values>12.0</values>
 					<values>-13.0</values>
 					<values>33.0</values>
 					<values>78.0</values>
 					<values>-127.0</values>
-				</elem>""", dataTest);
+				</TestListNodeDoubleFunc>""", dataTest);
 		
-		final TestListNodeDoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeDoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestListNodeDoubleFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeDoubleFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().size());
 		Assertions.assertEquals(12, root.getValues().get(0));
 		Assertions.assertEquals(-13, root.getValues().get(1));
@@ -469,16 +517,20 @@ public class ExmlTestIntrospectionDouble {
 		elem.valueNull = null;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeDouble>
 					<valueA>11.0</valueA>
 					<valueB>-120.0</valueB>
-				</elem>""", dataTest);
+				</TestNodeDouble>""", dataTest);
 		
-		final TestNodeDouble root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeDouble.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestNodeDouble root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeDouble.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(11, root.valueA);
 		Assertions.assertEquals(-120, root.valueB);
 		Assertions.assertEquals(null, root.valueNull);
@@ -492,16 +544,20 @@ public class ExmlTestIntrospectionDouble {
 		elem.setValueNull(null);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeDoubleFunc>
 					<valueA>54.0</valueA>
 					<valueB>-68.0</valueB>
-				</elem>""", dataTest);
+				</TestNodeDoubleFunc>""", dataTest);
 		
-		final TestNodeDoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeDoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestNodeDoubleFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeDoubleFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(54, root.getValueA());
 		Assertions.assertEquals(-68, root.getValueB());
 		Assertions.assertEquals(null, root.getValueNull());

test/src/test/atriasoft/exml/ExmlTestIntrospectionDoubleNative.java

@@ -5,9 +5,9 @@
  */
 package test.atriasoft.exml;
 
-import org.atriasoft.aknot.annotation.AknotList;
 import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
-import org.atriasoft.exml.Exml;
+import org.atriasoft.aknot.annotation.AknotList;
+import org.atriasoft.exml.XmlMapper;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -121,11 +121,11 @@ public class ExmlTestIntrospectionDoubleNative {
 		elem.values = new double[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeDoubleNativeStructured>
 					<values>
 						<elem>12.0</elem>
 						<elem>-13.0</elem>
@@ -133,9 +133,13 @@ public class ExmlTestIntrospectionDoubleNative {
 						<elem>78.0</elem>
 						<elem>-127.0</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestArrayNodeDoubleNativeStructured>""", dataTest);
 		
-		final TestArrayNodeDoubleNativeStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeDoubleNativeStructured.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestArrayNodeDoubleNativeStructured root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeDoubleNativeStructured.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(12, root.values[0]);
 		Assertions.assertEquals(-13, root.values[1]);
@@ -150,12 +154,16 @@ public class ExmlTestIntrospectionDoubleNative {
 		elem.setValues(new double[] { 12, -13, 33, 78, -127 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayDoubleFunc values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
 		
-		final TestArrayDoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayDoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestArrayDoubleFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayDoubleFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals(12, root.getValues()[0]);
 		Assertions.assertEquals(-13, root.getValues()[1]);
@@ -170,12 +178,16 @@ public class ExmlTestIntrospectionDoubleNative {
 		elem.values = new double[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayDoubleNative values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
 		
-		final TestArrayDoubleNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayDoubleNative.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestArrayDoubleNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayDoubleNative.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(12, root.values[0]);
 		Assertions.assertEquals(-13, root.values[1]);
@@ -190,19 +202,23 @@ public class ExmlTestIntrospectionDoubleNative {
 		elem.setValues(new double[] { 12, -13, 33, 78, -127 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeDoubleFunc>
 					<values>12.0</values>
 					<values>-13.0</values>
 					<values>33.0</values>
 					<values>78.0</values>
 					<values>-127.0</values>
-				</elem>""", dataTest);
+				</TestArrayNodeDoubleFunc>""", dataTest);
 		
-		final TestArrayNodeDoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeDoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestArrayNodeDoubleFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeDoubleFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals(12, root.getValues()[0]);
 		Assertions.assertEquals(-13, root.getValues()[1]);
@@ -217,19 +233,23 @@ public class ExmlTestIntrospectionDoubleNative {
 		elem.values = new double[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeDoubleNative>
 					<values>12.0</values>
 					<values>-13.0</values>
 					<values>33.0</values>
 					<values>78.0</values>
 					<values>-127.0</values>
-				</elem>""", dataTest);
+				</TestArrayNodeDoubleNative>""", dataTest);
 		
-		final TestArrayNodeDoubleNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeDoubleNative.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestArrayNodeDoubleNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeDoubleNative.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(12, root.values[0]);
 		Assertions.assertEquals(-13, root.values[1]);
@@ -245,12 +265,16 @@ public class ExmlTestIntrospectionDoubleNative {
 		elem.setValueB(57);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"-55.0\" valueB=\"57.0\"/>", dataTest);
+		Assertions.assertEquals("<TestdoubleFunc valueA=\"-55.0\" valueB=\"57.0\"/>", dataTest);
 		
-		final TestdoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestdoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestdoubleFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestdoubleFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(-55, root.getValueA());
 		Assertions.assertEquals(57, root.getValueB());
 	}
@@ -262,12 +286,16 @@ public class ExmlTestIntrospectionDoubleNative {
 		elem.valueB = -13;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"12.0\" valueB=\"-13.0\"/>", dataTest);
+		Assertions.assertEquals("<TestDoubleNative valueA=\"12.0\" valueB=\"-13.0\"/>", dataTest);
 		
-		final TestDoubleNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestDoubleNative.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestDoubleNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestDoubleNative.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(12, root.valueA);
 		Assertions.assertEquals(-13, root.valueB);
 	}
@@ -279,16 +307,20 @@ public class ExmlTestIntrospectionDoubleNative {
 		elem.setValueB(-68);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodedoubleFunc>
 					<valueA>54.0</valueA>
 					<valueB>-68.0</valueB>
-				</elem>""", dataTest);
+				</TestNodedoubleFunc>""", dataTest);
 		
-		final TestNodedoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodedoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestNodedoubleFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodedoubleFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(54, root.getValueA());
 		Assertions.assertEquals(-68, root.getValueB());
 	}
@@ -300,16 +332,20 @@ public class ExmlTestIntrospectionDoubleNative {
 		elem.valueB = -120;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeDoubleNative>
 					<valueA>11.0</valueA>
 					<valueB>-120.0</valueB>
-				</elem>""", dataTest);
+				</TestNodeDoubleNative>""", dataTest);
 		
-		final TestNodeDoubleNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeDoubleNative.class, ExmlTestIntrospectionDouble.NODE_NAME));
+		final TestNodeDoubleNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeDoubleNative.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(11, root.valueA);
 		Assertions.assertEquals(-120, root.valueB);
 	}

test/src/test/atriasoft/exml/ExmlTestIntrospectionEnum.java

@@ -7,9 +7,9 @@ package test.atriasoft.exml;
 
 import java.util.List;
 
-import org.atriasoft.aknot.annotation.AknotList;
 import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
-import org.atriasoft.exml.Exml;
+import org.atriasoft.aknot.annotation.AknotList;
+import org.atriasoft.exml.XmlMapper;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -167,11 +167,11 @@ public class ExmlTestIntrospectionEnum {
 		elem.values = new TestEnumVal[] { TestEnumVal.VALUE_1, TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeEnumStructured>
 					<values>
 						<elem>VALUE_1</elem>
 						<elem>VALUE_2</elem>
@@ -179,9 +179,13 @@ public class ExmlTestIntrospectionEnum {
 						<elem>VALUE_1</elem>
 						<elem>VALUE_2</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestArrayNodeEnumStructured>""", dataTest);
 		
-		final TestArrayNodeEnumStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeEnumStructured.class, ExmlTestIntrospectionEnum.NODE_NAME));
+		final TestArrayNodeEnumStructured root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeEnumStructured.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(TestEnumVal.VALUE_1, root.values[0]);
 		Assertions.assertEquals(TestEnumVal.VALUE_2, root.values[1]);
@@ -196,11 +200,11 @@ public class ExmlTestIntrospectionEnum {
 		elem.values = List.of(TestEnumVal.VALUE_1, TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeEnumStructured>
 					<values>
 						<elem>VALUE_1</elem>
 						<elem>VALUE_2</elem>
@@ -208,9 +212,13 @@ public class ExmlTestIntrospectionEnum {
 						<elem>VALUE_1</elem>
 						<elem>VALUE_2</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestListNodeEnumStructured>""", dataTest);
 		
-		final TestListNodeEnumStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeEnumStructured.class, ExmlTestIntrospectionEnum.NODE_NAME));
+		final TestListNodeEnumStructured root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeEnumStructured.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.size());
 		Assertions.assertEquals(TestEnumVal.VALUE_1, root.values.get(0));
 		Assertions.assertEquals(TestEnumVal.VALUE_2, root.values.get(1));
@@ -225,12 +233,16 @@ public class ExmlTestIntrospectionEnum {
 		elem.values = new TestEnumVal[] { TestEnumVal.VALUE_1, TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"VALUE_1;VALUE_2;VALUE_3;VALUE_1;VALUE_2\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayEnum values=\"VALUE_1;VALUE_2;VALUE_3;VALUE_1;VALUE_2\"/>", dataTest);
 		
-		final TestArrayEnum root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayEnum.class, ExmlTestIntrospectionEnum.NODE_NAME));
+		final TestArrayEnum root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayEnum.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(TestEnumVal.VALUE_1, root.values[0]);
 		Assertions.assertEquals(TestEnumVal.VALUE_2, root.values[1]);
@@ -245,12 +257,16 @@ public class ExmlTestIntrospectionEnum {
 		elem.setValues(new TestEnumVal[] { TestEnumVal.VALUE_1, TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"VALUE_1;VALUE_2;VALUE_3;VALUE_1;VALUE_2\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayEnumFunc values=\"VALUE_1;VALUE_2;VALUE_3;VALUE_1;VALUE_2\"/>", dataTest);
 		
-		final TestArrayEnumFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayEnumFunc.class, ExmlTestIntrospectionEnum.NODE_NAME));
+		final TestArrayEnumFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayEnumFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals(TestEnumVal.VALUE_1, root.getValues()[0]);
 		Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValues()[1]);
@@ -265,19 +281,23 @@ public class ExmlTestIntrospectionEnum {
 		elem.values = new TestEnumVal[] { TestEnumVal.VALUE_1, TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeEnum>
 					<values>VALUE_1</values>
 					<values>VALUE_2</values>
 					<values>VALUE_3</values>
 					<values>VALUE_1</values>
 					<values>VALUE_2</values>
-				</elem>""", dataTest);
+				</TestArrayNodeEnum>""", dataTest);
 		
-		final TestArrayNodeEnum root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeEnum.class, ExmlTestIntrospectionEnum.NODE_NAME));
+		final TestArrayNodeEnum root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeEnum.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(TestEnumVal.VALUE_1, root.values[0]);
 		Assertions.assertEquals(TestEnumVal.VALUE_2, root.values[1]);
@@ -292,19 +312,23 @@ public class ExmlTestIntrospectionEnum {
 		elem.setValues(new TestEnumVal[] { TestEnumVal.VALUE_1, TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeEnumFunc>
 					<values>VALUE_1</values>
 					<values>VALUE_2</values>
 					<values>VALUE_3</values>
 					<values>VALUE_1</values>
 					<values>VALUE_2</values>
-				</elem>""", dataTest);
+				</TestArrayNodeEnumFunc>""", dataTest);
 		
-		final TestArrayNodeEnumFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeEnumFunc.class, ExmlTestIntrospectionEnum.NODE_NAME));
+		final TestArrayNodeEnumFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeEnumFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals(TestEnumVal.VALUE_1, root.getValues()[0]);
 		Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValues()[1]);
@@ -320,12 +344,16 @@ public class ExmlTestIntrospectionEnum {
 		elem.valueB = TestEnumVal.VALUE_3;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"VALUE_1\" valueB=\"VALUE_3\"/>", dataTest);
+		Assertions.assertEquals("<TestEnum valueA=\"VALUE_1\" valueB=\"VALUE_3\"/>", dataTest);
 		
-		final TestEnum root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestEnum.class, ExmlTestIntrospectionEnum.NODE_NAME));
+		final TestEnum root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestEnum.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(TestEnumVal.VALUE_1, root.valueA);
 		Assertions.assertEquals(TestEnumVal.VALUE_3, root.valueB);
 	}
@@ -337,12 +365,16 @@ public class ExmlTestIntrospectionEnum {
 		elem.setValueB(TestEnumVal.VALUE_2);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"VALUE_1\" valueB=\"VALUE_2\"/>", dataTest);
+		Assertions.assertEquals("<TestEnumFunc valueA=\"VALUE_1\" valueB=\"VALUE_2\"/>", dataTest);
 		
-		final TestEnumFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestEnumFunc.class, ExmlTestIntrospectionEnum.NODE_NAME));
+		final TestEnumFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestEnumFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(TestEnumVal.VALUE_1, root.getValueA());
 		Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValueB());
 	}
@@ -353,12 +385,16 @@ public class ExmlTestIntrospectionEnum {
 		elem.values = List.of(TestEnumVal.VALUE_1, TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"VALUE_1;VALUE_2;VALUE_3;VALUE_1;VALUE_2\"/>", dataTest);
+		Assertions.assertEquals("<TestListEnum values=\"VALUE_1;VALUE_2;VALUE_3;VALUE_1;VALUE_2\"/>", dataTest);
 		
-		final TestListEnum root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListEnum.class, ExmlTestIntrospectionEnum.NODE_NAME));
+		final TestListEnum root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListEnum.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.size());
 		Assertions.assertEquals(TestEnumVal.VALUE_1, root.values.get(0));
 		Assertions.assertEquals(TestEnumVal.VALUE_2, root.values.get(1));
@@ -373,12 +409,16 @@ public class ExmlTestIntrospectionEnum {
 		elem.setValues(List.of(TestEnumVal.VALUE_1, TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2));
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"VALUE_1;VALUE_2;VALUE_3;VALUE_1;VALUE_2\"/>", dataTest);
+		Assertions.assertEquals("<TestListEnumFunc values=\"VALUE_1;VALUE_2;VALUE_3;VALUE_1;VALUE_2\"/>", dataTest);
 		
-		final TestListEnumFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListEnumFunc.class, ExmlTestIntrospectionEnum.NODE_NAME));
+		final TestListEnumFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListEnumFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().size());
 		Assertions.assertEquals(TestEnumVal.VALUE_1, root.getValues().get(0));
 		Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValues().get(1));
@@ -393,19 +433,23 @@ public class ExmlTestIntrospectionEnum {
 		elem.values = List.of(TestEnumVal.VALUE_1, TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeEnum>
 					<values>VALUE_1</values>
 					<values>VALUE_2</values>
 					<values>VALUE_3</values>
 					<values>VALUE_1</values>
 					<values>VALUE_2</values>
-				</elem>""", dataTest);
+				</TestListNodeEnum>""", dataTest);
 		
-		final TestListNodeEnum root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeEnum.class, ExmlTestIntrospectionEnum.NODE_NAME));
+		final TestListNodeEnum root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeEnum.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.size());
 		Assertions.assertEquals(TestEnumVal.VALUE_1, root.values.get(0));
 		Assertions.assertEquals(TestEnumVal.VALUE_2, root.values.get(1));
@@ -420,19 +464,23 @@ public class ExmlTestIntrospectionEnum {
 		elem.setValues(List.of(TestEnumVal.VALUE_1, TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2));
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeEnumFunc>
 					<values>VALUE_1</values>
 					<values>VALUE_2</values>
 					<values>VALUE_3</values>
 					<values>VALUE_1</values>
 					<values>VALUE_2</values>
-				</elem>""", dataTest);
+				</TestListNodeEnumFunc>""", dataTest);
 		
-		final TestListNodeEnumFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeEnumFunc.class, ExmlTestIntrospectionEnum.NODE_NAME));
+		final TestListNodeEnumFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeEnumFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().size());
 		Assertions.assertEquals(TestEnumVal.VALUE_1, root.getValues().get(0));
 		Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValues().get(1));
@@ -448,16 +496,20 @@ public class ExmlTestIntrospectionEnum {
 		elem.valueB = TestEnumVal.VALUE_1;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeEnum>
 					<valueA>VALUE_3</valueA>
 					<valueB>VALUE_1</valueB>
-				</elem>""", dataTest);
+				</TestNodeEnum>""", dataTest);
 		
-		final TestNodeEnum root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeEnum.class, ExmlTestIntrospectionEnum.NODE_NAME));
+		final TestNodeEnum root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeEnum.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(TestEnumVal.VALUE_3, root.valueA);
 		Assertions.assertEquals(TestEnumVal.VALUE_1, root.valueB);
 	}
@@ -469,16 +521,20 @@ public class ExmlTestIntrospectionEnum {
 		elem.setValueB(TestEnumVal.VALUE_3);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeEnumFunc>
 					<valueA>VALUE_2</valueA>
 					<valueB>VALUE_3</valueB>
-				</elem>""", dataTest);
+				</TestNodeEnumFunc>""", dataTest);
 		
-		final TestNodeEnumFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeEnumFunc.class, ExmlTestIntrospectionEnum.NODE_NAME));
+		final TestNodeEnumFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeEnumFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValueA());
 		Assertions.assertEquals(TestEnumVal.VALUE_3, root.getValueB());
 	}

test/src/test/atriasoft/exml/ExmlTestIntrospectionFloat.java

@@ -7,9 +7,9 @@ package test.atriasoft.exml;
 
 import java.util.List;
 
-import org.atriasoft.aknot.annotation.AknotList;
 import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
-import org.atriasoft.exml.Exml;
+import org.atriasoft.aknot.annotation.AknotList;
+import org.atriasoft.exml.XmlMapper;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -183,11 +183,11 @@ public class ExmlTestIntrospectionFloat {
 		elem.values = new Float[] { (float) 12, (float) -13, (float) 33, (float) 78, (float) -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeFloatStructured>
 					<values>
 						<elem>12.0</elem>
 						<elem>-13.0</elem>
@@ -195,9 +195,13 @@ public class ExmlTestIntrospectionFloat {
 						<elem>78.0</elem>
 						<elem>-127.0</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestArrayNodeFloatStructured>""", dataTest);
 		
-		final TestArrayNodeFloatStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeFloatStructured.class, ExmlTestIntrospectionFloat.NODE_NAME));
+		final TestArrayNodeFloatStructured root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeFloatStructured.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(12, root.values[0]);
 		Assertions.assertEquals(-13, root.values[1]);
@@ -212,11 +216,11 @@ public class ExmlTestIntrospectionFloat {
 		elem.values = List.of((float) 12, (float) -13, (float) 33, (float) 78, (float) -127);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeByteStructured>
 					<values>
 						<elem>12.0</elem>
 						<elem>-13.0</elem>
@@ -224,9 +228,13 @@ public class ExmlTestIntrospectionFloat {
 						<elem>78.0</elem>
 						<elem>-127.0</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestListNodeByteStructured>""", dataTest);
 		
-		final TestListNodeByteStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeByteStructured.class, ExmlTestIntrospectionByte.NODE_NAME));
+		final TestListNodeByteStructured root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeByteStructured.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.size());
 		Assertions.assertEquals(12, root.values.get(0));
 		Assertions.assertEquals(-13, root.values.get(1));
@@ -241,12 +249,16 @@ public class ExmlTestIntrospectionFloat {
 		elem.values = new Float[] { (float) 12, (float) -13, (float) 33, (float) 78, (float) -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayFloat values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
 		
-		final TestArrayFloat root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayFloat.class, ExmlTestIntrospectionFloat.NODE_NAME));
+		final TestArrayFloat root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayFloat.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(12, root.values[0]);
 		Assertions.assertEquals(-13, root.values[1]);
@@ -261,12 +273,16 @@ public class ExmlTestIntrospectionFloat {
 		elem.setValues(new Float[] { (float) 12, (float) -13, (float) 33, (float) 78, (float) -127 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayFloatFunc values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
 		
-		final TestArrayFloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayFloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
+		final TestArrayFloatFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayFloatFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals(12, root.getValues()[0]);
 		Assertions.assertEquals(-13, root.getValues()[1]);
@@ -281,19 +297,23 @@ public class ExmlTestIntrospectionFloat {
 		elem.values = new Float[] { (float) 12, (float) -13, (float) 33, (float) 78, (float) -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeFloat>
 					<values>12.0</values>
 					<values>-13.0</values>
 					<values>33.0</values>
 					<values>78.0</values>
 					<values>-127.0</values>
-				</elem>""", dataTest);
+				</TestArrayNodeFloat>""", dataTest);
 		
-		final TestArrayNodeFloat root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeFloat.class, ExmlTestIntrospectionFloat.NODE_NAME));
+		final TestArrayNodeFloat root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeFloat.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(12, root.values[0]);
 		Assertions.assertEquals(-13, root.values[1]);
@@ -308,19 +328,23 @@ public class ExmlTestIntrospectionFloat {
 		elem.setValues(new Float[] { (float) 12, (float) -13, (float) 33, (float) 78, (float) -127 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeFloatFunc>
 					<values>12.0</values>
 					<values>-13.0</values>
 					<values>33.0</values>
 					<values>78.0</values>
 					<values>-127.0</values>
-				</elem>""", dataTest);
+				</TestArrayNodeFloatFunc>""", dataTest);
 		
-		final TestArrayNodeFloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeFloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
+		final TestArrayNodeFloatFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeFloatFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals(12, root.getValues()[0]);
 		Assertions.assertEquals(-13, root.getValues()[1]);
@@ -337,12 +361,16 @@ public class ExmlTestIntrospectionFloat {
 		elem.valueNull = null;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"12.0\" valueB=\"-13.0\"/>", dataTest);
+		Assertions.assertEquals("<TestFloat valueA=\"12.0\" valueB=\"-13.0\"/>", dataTest);
 		
-		final TestFloat root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestFloat.class, ExmlTestIntrospectionFloat.NODE_NAME));
+		final TestFloat root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestFloat.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(12, root.valueA);
 		Assertions.assertEquals(-13, root.valueB);
 		Assertions.assertEquals(null, root.valueNull);
@@ -356,12 +384,16 @@ public class ExmlTestIntrospectionFloat {
 		elem.setValueNull(null);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"-55.0\" valueB=\"57.0\"/>", dataTest);
+		Assertions.assertEquals("<TestFloatFunc valueA=\"-55.0\" valueB=\"57.0\"/>", dataTest);
 		
-		final TestFloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestFloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
+		final TestFloatFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestFloatFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(-55, root.getValueA());
 		Assertions.assertEquals(57, root.getValueB());
 		Assertions.assertEquals(null, root.getValueNull());
@@ -373,12 +405,16 @@ public class ExmlTestIntrospectionFloat {
 		elem.values = List.of((float) 12, (float) -13, (float) 33, (float) 78, (float) -127);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
+		Assertions.assertEquals("<TestListFloat values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
 		
-		final TestListFloat root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListFloat.class, ExmlTestIntrospectionFloat.NODE_NAME));
+		final TestListFloat root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListFloat.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.size());
 		Assertions.assertEquals(12, root.values.get(0));
 		Assertions.assertEquals(-13, root.values.get(1));
@@ -393,12 +429,16 @@ public class ExmlTestIntrospectionFloat {
 		elem.setValues(List.of((float) 12, (float) -13, (float) 33, (float) 78, (float) -127));
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
+		Assertions.assertEquals("<TestListFloatFunc values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
 		
-		final TestListFloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListFloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
+		final TestListFloatFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListFloatFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().size());
 		Assertions.assertEquals(12, root.getValues().get(0));
 		Assertions.assertEquals(-13, root.getValues().get(1));
@@ -413,19 +453,23 @@ public class ExmlTestIntrospectionFloat {
 		elem.values = List.of((float) 12, (float) -13, (float) 33, (float) 78, (float) -127);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeFloat>
 					<values>12.0</values>
 					<values>-13.0</values>
 					<values>33.0</values>
 					<values>78.0</values>
 					<values>-127.0</values>
-				</elem>""", dataTest);
+				</TestListNodeFloat>""", dataTest);
 		
-		final TestListNodeFloat root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeFloat.class, ExmlTestIntrospectionFloat.NODE_NAME));
+		final TestListNodeFloat root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeFloat.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.size());
 		Assertions.assertEquals(12, root.values.get(0));
 		Assertions.assertEquals(-13, root.values.get(1));
@@ -440,19 +484,23 @@ public class ExmlTestIntrospectionFloat {
 		elem.setValues(List.of((float) 12, (float) -13, (float) 33, (float) 78, (float) -127));
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeFloatFunc>
 					<values>12.0</values>
 					<values>-13.0</values>
 					<values>33.0</values>
 					<values>78.0</values>
 					<values>-127.0</values>
-				</elem>""", dataTest);
+				</TestListNodeFloatFunc>""", dataTest);
 		
-		final TestListNodeFloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeFloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
+		final TestListNodeFloatFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeFloatFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().size());
 		Assertions.assertEquals(12, root.getValues().get(0));
 		Assertions.assertEquals(-13, root.getValues().get(1));
@@ -469,16 +517,20 @@ public class ExmlTestIntrospectionFloat {
 		elem.valueNull = null;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeFloat>
 					<valueA>11.0</valueA>
 					<valueB>-120.0</valueB>
-				</elem>""", dataTest);
+				</TestNodeFloat>""", dataTest);
 		
-		final TestNodeFloat root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeFloat.class, ExmlTestIntrospectionFloat.NODE_NAME));
+		final TestNodeFloat root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeFloat.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(11, root.valueA);
 		Assertions.assertEquals(-120, root.valueB);
 		Assertions.assertEquals(null, root.valueNull);
@@ -492,16 +544,20 @@ public class ExmlTestIntrospectionFloat {
 		elem.setValueNull(null);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeFloatFunc>
 					<valueA>54.0</valueA>
 					<valueB>-68.0</valueB>
-				</elem>""", dataTest);
+				</TestNodeFloatFunc>""", dataTest);
 		
-		final TestNodeFloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeFloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
+		final TestNodeFloatFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeFloatFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(54, root.getValueA());
 		Assertions.assertEquals(-68, root.getValueB());
 		Assertions.assertEquals(null, root.getValueNull());

test/src/test/atriasoft/exml/ExmlTestIntrospectionFloatNative.java

@@ -5,9 +5,9 @@
  */
 package test.atriasoft.exml;
 
-import org.atriasoft.aknot.annotation.AknotList;
 import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
-import org.atriasoft.exml.Exml;
+import org.atriasoft.aknot.annotation.AknotList;
+import org.atriasoft.exml.XmlMapper;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -121,11 +121,11 @@ public class ExmlTestIntrospectionFloatNative {
 		elem.values = new float[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeFloatNativeStructured>
 					<values>
 						<elem>12.0</elem>
 						<elem>-13.0</elem>
@@ -133,9 +133,13 @@ public class ExmlTestIntrospectionFloatNative {
 						<elem>78.0</elem>
 						<elem>-127.0</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestArrayNodeFloatNativeStructured>""", dataTest);
 		
-		final TestArrayNodeFloatNativeStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeFloatNativeStructured.class, ExmlTestIntrospectionFloat.NODE_NAME));
+		final TestArrayNodeFloatNativeStructured root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeFloatNativeStructured.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(12, root.values[0]);
 		Assertions.assertEquals(-13, root.values[1]);
@@ -150,12 +154,16 @@ public class ExmlTestIntrospectionFloatNative {
 		elem.setValues(new float[] { 12, -13, 33, 78, -127 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayFloatFunc values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
 		
-		final TestArrayFloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayFloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
+		final TestArrayFloatFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayFloatFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals(12, root.getValues()[0]);
 		Assertions.assertEquals(-13, root.getValues()[1]);
@@ -170,12 +178,16 @@ public class ExmlTestIntrospectionFloatNative {
 		elem.values = new float[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayFloatNative values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
 		
-		final TestArrayFloatNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayFloatNative.class, ExmlTestIntrospectionFloat.NODE_NAME));
+		final TestArrayFloatNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayFloatNative.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(12, root.values[0]);
 		Assertions.assertEquals(-13, root.values[1]);
@@ -190,19 +202,23 @@ public class ExmlTestIntrospectionFloatNative {
 		elem.setValues(new float[] { 12, -13, 33, 78, -127 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeFloatFunc>
 					<values>12.0</values>
 					<values>-13.0</values>
 					<values>33.0</values>
 					<values>78.0</values>
 					<values>-127.0</values>
-				</elem>""", dataTest);
+				</TestArrayNodeFloatFunc>""", dataTest);
 		
-		final TestArrayNodeFloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeFloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
+		final TestArrayNodeFloatFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeFloatFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals(12, root.getValues()[0]);
 		Assertions.assertEquals(-13, root.getValues()[1]);
@@ -217,19 +233,23 @@ public class ExmlTestIntrospectionFloatNative {
 		elem.values = new float[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeFloatNative>
 					<values>12.0</values>
 					<values>-13.0</values>
 					<values>33.0</values>
 					<values>78.0</values>
 					<values>-127.0</values>
-				</elem>""", dataTest);
+				</TestArrayNodeFloatNative>""", dataTest);
 		
-		final TestArrayNodeFloatNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeFloatNative.class, ExmlTestIntrospectionFloat.NODE_NAME));
+		final TestArrayNodeFloatNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeFloatNative.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(12, root.values[0]);
 		Assertions.assertEquals(-13, root.values[1]);
@@ -245,12 +265,16 @@ public class ExmlTestIntrospectionFloatNative {
 		elem.setValueB(57);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"-55.0\" valueB=\"57.0\"/>", dataTest);
+		Assertions.assertEquals("<TestfloatFunc valueA=\"-55.0\" valueB=\"57.0\"/>", dataTest);
 		
-		final TestfloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestfloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
+		final TestfloatFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestfloatFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(-55, root.getValueA());
 		Assertions.assertEquals(57, root.getValueB());
 	}
@@ -262,12 +286,16 @@ public class ExmlTestIntrospectionFloatNative {
 		elem.valueB = -13;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"12.0\" valueB=\"-13.0\"/>", dataTest);
+		Assertions.assertEquals("<TestFloatNative valueA=\"12.0\" valueB=\"-13.0\"/>", dataTest);
 		
-		final TestFloatNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestFloatNative.class, ExmlTestIntrospectionFloat.NODE_NAME));
+		final TestFloatNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestFloatNative.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(12, root.valueA);
 		Assertions.assertEquals(-13, root.valueB);
 	}
@@ -279,16 +307,20 @@ public class ExmlTestIntrospectionFloatNative {
 		elem.setValueB(-68);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodefloatFunc>
 					<valueA>54.0</valueA>
 					<valueB>-68.0</valueB>
-				</elem>""", dataTest);
+				</TestNodefloatFunc>""", dataTest);
 		
-		final TestNodefloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodefloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
+		final TestNodefloatFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodefloatFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(54, root.getValueA());
 		Assertions.assertEquals(-68, root.getValueB());
 	}
@@ -300,16 +332,20 @@ public class ExmlTestIntrospectionFloatNative {
 		elem.valueB = -120;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeFloatNative>
 					<valueA>11.0</valueA>
 					<valueB>-120.0</valueB>
-				</elem>""", dataTest);
+				</TestNodeFloatNative>""", dataTest);
 		
-		final TestNodeFloatNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeFloatNative.class, ExmlTestIntrospectionFloat.NODE_NAME));
+		final TestNodeFloatNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeFloatNative.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(11, root.valueA);
 		Assertions.assertEquals(-120, root.valueB);
 	}

test/src/test/atriasoft/exml/ExmlTestIntrospectionGenerate.java

@@ -5,10 +5,10 @@
  */
 package test.atriasoft.exml;
 
-import org.atriasoft.exml.Exml;
+import org.atriasoft.exml.XmlMapper;
 import org.atriasoft.exml.exception.ExmlException;
 import org.atriasoft.exml.exception.ExmlParserErrorMulti;
-
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 
@@ -18,6 +18,7 @@ import test.atriasoft.exml.introspection.ClassPublicMethodeNode;
 
 public class ExmlTestIntrospectionGenerate {
 	private static final String NODE_NAME = "elem";
+	
 	@BeforeAll
 	public static void beforeClass() {
 		Log.verbose("----------------------------------------------------------------");
@@ -25,7 +26,7 @@ public class ExmlTestIntrospectionGenerate {
 	
 	@Test
 	public void test1() throws ExmlParserErrorMulti, ExmlException {
-		ClassPublicMemberOnly elem = new ClassPublicMemberOnly();
+		final ClassPublicMemberOnly elem = new ClassPublicMemberOnly();
 		elem.memberArrayBoolean = new boolean[] { false, true };
 		elem.memberArrayBooleanClass = new Boolean[] { false, true, true };
 		elem.memberArrayByte = new byte[] { 21, 21, 58 };
@@ -48,14 +49,14 @@ public class ExmlTestIntrospectionGenerate {
 		elem.memberShortClass = -25212;
 		elem.memberStringClass = "lkjhlkjlkjlkj";
 		
-		StringBuilder builder = new StringBuilder();
-		Exml.generate(elem, "elem", builder);
+		final StringBuilder builder = new StringBuilder();
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		Log.warning("data generated: " + builder.toString());
 	}
 	
 	@Test
 	public void test2() throws ExmlParserErrorMulti, ExmlException {
-		ClassPublicMethodOnly elem = new ClassPublicMethodOnly();
+		final ClassPublicMethodOnly elem = new ClassPublicMethodOnly();
 		elem.setMemberArrayBoolean(new boolean[] { false, true });
 		elem.setMemberArrayBooleanClass(new Boolean[] { false, true, true });
 		elem.setMemberArrayByte(new byte[] { 21, 21, 58 });
@@ -78,15 +79,14 @@ public class ExmlTestIntrospectionGenerate {
 		elem.setMemberShortClass((short) -25212);
 		elem.setMemberStringClass("lkjhlkjlkjlkj");
 		
-		StringBuilder builder = new StringBuilder();
-		Exml.generate(elem, "elem", builder);
+		final StringBuilder builder = new StringBuilder();
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		Log.warning("data generated: " + builder.toString());
 	}
 	
-
 	@Test
 	public void test3() throws ExmlParserErrorMulti, ExmlException {
-		ClassPublicMethodeNode elem = new ClassPublicMethodeNode();
+		final ClassPublicMethodeNode elem = new ClassPublicMethodeNode();
 		elem.setMemberArrayBoolean(new boolean[] { false, true });
 		elem.setMemberArrayBooleanClass(new Boolean[] { false, true, true });
 		elem.setMemberArrayByte(new byte[] { 21, 21, 58 });
@@ -109,10 +109,9 @@ public class ExmlTestIntrospectionGenerate {
 		elem.setMemberShortClass((short) -25212);
 		elem.setMemberStringClass("lkjhlkjlkjlkj");
 		
-		StringBuilder builder = new StringBuilder();
-		Exml.generate(elem, "elem", builder);
+		final StringBuilder builder = new StringBuilder();
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		Log.warning("data generated: " + builder.toString());
 	}
 	
 }
-

test/src/test/atriasoft/exml/ExmlTestIntrospectionInteger.java

@@ -7,9 +7,9 @@ package test.atriasoft.exml;
 
 import java.util.List;
 
-import org.atriasoft.aknot.annotation.AknotList;
 import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
-import org.atriasoft.exml.Exml;
+import org.atriasoft.aknot.annotation.AknotList;
+import org.atriasoft.exml.XmlMapper;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -183,11 +183,11 @@ public class ExmlTestIntrospectionInteger {
 		elem.values = new Integer[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeIntegerStructured>
 					<values>
 						<elem>12</elem>
 						<elem>-13</elem>
@@ -195,9 +195,13 @@ public class ExmlTestIntrospectionInteger {
 						<elem>78</elem>
 						<elem>-127</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestArrayNodeIntegerStructured>""", dataTest);
 		
-		final TestArrayNodeIntegerStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeIntegerStructured.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestArrayNodeIntegerStructured root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeIntegerStructured.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(12, root.values[0]);
 		Assertions.assertEquals(-13, root.values[1]);
@@ -212,11 +216,11 @@ public class ExmlTestIntrospectionInteger {
 		elem.values = List.of(12, -13, 33, 78, -127);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeIntegerStructured>
 					<values>
 						<elem>12</elem>
 						<elem>-13</elem>
@@ -224,9 +228,13 @@ public class ExmlTestIntrospectionInteger {
 						<elem>78</elem>
 						<elem>-127</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestListNodeIntegerStructured>""", dataTest);
 		
-		final TestListNodeIntegerStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeIntegerStructured.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestListNodeIntegerStructured root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeIntegerStructured.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.size());
 		Assertions.assertEquals(12, root.values.get(0));
 		Assertions.assertEquals(-13, root.values.get(1));
@@ -241,12 +249,16 @@ public class ExmlTestIntrospectionInteger {
 		elem.values = new Integer[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayInteger values=\"12;-13;33;78;-127\"/>", dataTest);
 		
-		final TestArrayInteger root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayInteger.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestArrayInteger root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayInteger.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(12, root.values[0]);
 		Assertions.assertEquals(-13, root.values[1]);
@@ -261,12 +273,16 @@ public class ExmlTestIntrospectionInteger {
 		elem.setValues(new Integer[] { 12, -13, 33, 78, -127 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayIntegerFunc values=\"12;-13;33;78;-127\"/>", dataTest);
 		
-		final TestArrayIntegerFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayIntegerFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestArrayIntegerFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayIntegerFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals(12, root.getValues()[0]);
 		Assertions.assertEquals(-13, root.getValues()[1]);
@@ -281,19 +297,23 @@ public class ExmlTestIntrospectionInteger {
 		elem.values = new Integer[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeInteger>
 					<values>12</values>
 					<values>-13</values>
 					<values>33</values>
 					<values>78</values>
 					<values>-127</values>
-				</elem>""", dataTest);
+				</TestArrayNodeInteger>""", dataTest);
 		
-		final TestArrayNodeInteger root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeInteger.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestArrayNodeInteger root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeInteger.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(12, root.values[0]);
 		Assertions.assertEquals(-13, root.values[1]);
@@ -308,19 +328,23 @@ public class ExmlTestIntrospectionInteger {
 		elem.setValues(new Integer[] { 12, -13, 33, 78, -127 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeIntegerFunc>
 					<values>12</values>
 					<values>-13</values>
 					<values>33</values>
 					<values>78</values>
 					<values>-127</values>
-				</elem>""", dataTest);
+				</TestArrayNodeIntegerFunc>""", dataTest);
 		
-		final TestArrayNodeIntegerFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeIntegerFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestArrayNodeIntegerFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeIntegerFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals(12, root.getValues()[0]);
 		Assertions.assertEquals(-13, root.getValues()[1]);
@@ -337,12 +361,16 @@ public class ExmlTestIntrospectionInteger {
 		elem.valueNull = null;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"12\" valueB=\"-13\"/>", dataTest);
+		Assertions.assertEquals("<TestInteger valueA=\"12\" valueB=\"-13\"/>", dataTest);
 		
-		final TestInteger root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestInteger.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestInteger root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestInteger.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(12, root.valueA);
 		Assertions.assertEquals(-13, root.valueB);
 		Assertions.assertEquals(null, root.valueNull);
@@ -356,12 +384,16 @@ public class ExmlTestIntrospectionInteger {
 		elem.setValueNull(null);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"-55\" valueB=\"57\"/>", dataTest);
+		Assertions.assertEquals("<TestIntegerFunc valueA=\"-55\" valueB=\"57\"/>", dataTest);
 		
-		final TestIntegerFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestIntegerFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestIntegerFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestIntegerFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(-55, root.getValueA());
 		Assertions.assertEquals(57, root.getValueB());
 		Assertions.assertEquals(null, root.getValueNull());
@@ -373,12 +405,16 @@ public class ExmlTestIntrospectionInteger {
 		elem.values = List.of(12, -13, 33, 78, -127);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
+		Assertions.assertEquals("<TestListInteger values=\"12;-13;33;78;-127\"/>", dataTest);
 		
-		final TestListInteger root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListInteger.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestListInteger root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListInteger.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.size());
 		Assertions.assertEquals(12, root.values.get(0));
 		Assertions.assertEquals(-13, root.values.get(1));
@@ -393,12 +429,16 @@ public class ExmlTestIntrospectionInteger {
 		elem.setValues(List.of(12, -13, 33, 78, -127));
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
+		Assertions.assertEquals("<TestListIntegerFunc values=\"12;-13;33;78;-127\"/>", dataTest);
 		
-		final TestListIntegerFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListIntegerFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestListIntegerFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListIntegerFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().size());
 		Assertions.assertEquals(12, root.getValues().get(0));
 		Assertions.assertEquals(-13, root.getValues().get(1));
@@ -413,19 +453,23 @@ public class ExmlTestIntrospectionInteger {
 		elem.values = List.of(12, -13, 33, 78, -127);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeInteger>
 					<values>12</values>
 					<values>-13</values>
 					<values>33</values>
 					<values>78</values>
 					<values>-127</values>
-				</elem>""", dataTest);
+				</TestListNodeInteger>""", dataTest);
 		
-		final TestListNodeInteger root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeInteger.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestListNodeInteger root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeInteger.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.size());
 		Assertions.assertEquals(12, root.values.get(0));
 		Assertions.assertEquals(-13, root.values.get(1));
@@ -440,19 +484,23 @@ public class ExmlTestIntrospectionInteger {
 		elem.setValues(List.of(12, -13, 33, 78, -127));
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeIntegerFunc>
 					<values>12</values>
 					<values>-13</values>
 					<values>33</values>
 					<values>78</values>
 					<values>-127</values>
-				</elem>""", dataTest);
+				</TestListNodeIntegerFunc>""", dataTest);
 		
-		final TestListNodeIntegerFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeIntegerFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestListNodeIntegerFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeIntegerFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().size());
 		Assertions.assertEquals(12, root.getValues().get(0));
 		Assertions.assertEquals(-13, root.getValues().get(1));
@@ -469,16 +517,20 @@ public class ExmlTestIntrospectionInteger {
 		elem.valueNull = null;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeInteger>
 					<valueA>11</valueA>
 					<valueB>-120</valueB>
-				</elem>""", dataTest);
+				</TestNodeInteger>""", dataTest);
 		
-		final TestNodeInteger root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeInteger.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestNodeInteger root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeInteger.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(11, root.valueA);
 		Assertions.assertEquals(-120, root.valueB);
 		Assertions.assertEquals(null, root.valueNull);
@@ -492,16 +544,20 @@ public class ExmlTestIntrospectionInteger {
 		elem.setValueNull(null);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeIntegerFunc>
 					<valueA>54</valueA>
 					<valueB>-68</valueB>
-				</elem>""", dataTest);
+				</TestNodeIntegerFunc>""", dataTest);
 		
-		final TestNodeIntegerFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeIntegerFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestNodeIntegerFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeIntegerFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(54, root.getValueA());
 		Assertions.assertEquals(-68, root.getValueB());
 		Assertions.assertEquals(null, root.getValueNull());

test/src/test/atriasoft/exml/ExmlTestIntrospectionIntegerNative.java

@@ -5,9 +5,9 @@
  */
 package test.atriasoft.exml;
 
-import org.atriasoft.aknot.annotation.AknotList;
 import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
-import org.atriasoft.exml.Exml;
+import org.atriasoft.aknot.annotation.AknotList;
+import org.atriasoft.exml.XmlMapper;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -121,11 +121,11 @@ public class ExmlTestIntrospectionIntegerNative {
 		elem.values = new byte[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeIntegerNativeStructured>
 					<values>
 						<elem>12</elem>
 						<elem>-13</elem>
@@ -133,16 +133,20 @@ public class ExmlTestIntrospectionIntegerNative {
 						<elem>78</elem>
 						<elem>-127</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestArrayNodeIntegerNativeStructured>""", dataTest);
 		
-		final TestArrayNodeIntegerNativeStructured root = Assertions
-				.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeIntegerNativeStructured.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestArrayNodeIntegerNativeStructured root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeIntegerNativeStructured.class);
+		});
+		Assertions.assertNotNull(root);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals((byte) 12, root.values[0]);
 		Assertions.assertEquals((byte) -13, root.values[1]);
 		Assertions.assertEquals((byte) 33, root.values[2]);
 		Assertions.assertEquals((byte) 78, root.values[3]);
 		Assertions.assertEquals((byte) -127, root.values[4]);
+		
 	}
 	
 	@Test
@@ -151,12 +155,16 @@ public class ExmlTestIntrospectionIntegerNative {
 		elem.setValues(new int[] { 12, -13, 33, 78, -127 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayIntegerFunc values=\"12;-13;33;78;-127\"/>", dataTest);
 		
-		final TestArrayIntegerFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayIntegerFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestArrayIntegerFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayIntegerFunc.class);
+		});
+		Assertions.assertNotNull(root);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals(12, root.getValues()[0]);
 		Assertions.assertEquals(-13, root.getValues()[1]);
@@ -171,12 +179,16 @@ public class ExmlTestIntrospectionIntegerNative {
 		elem.values = new int[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayIntegerNative values=\"12;-13;33;78;-127\"/>", dataTest);
 		
-		final TestArrayIntegerNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayIntegerNative.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestArrayIntegerNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayIntegerNative.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(12, root.values[0]);
 		Assertions.assertEquals(-13, root.values[1]);
@@ -191,19 +203,23 @@ public class ExmlTestIntrospectionIntegerNative {
 		elem.setValues(new int[] { 12, -13, 33, 78, -127 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeIntegerFunc>
 					<values>12</values>
 					<values>-13</values>
 					<values>33</values>
 					<values>78</values>
 					<values>-127</values>
-				</elem>""", dataTest);
+				</TestArrayNodeIntegerFunc>""", dataTest);
 		
-		final TestArrayNodeIntegerFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeIntegerFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestArrayNodeIntegerFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeIntegerFunc.class);
+		});
+		Assertions.assertNotNull(root);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals(12, root.getValues()[0]);
 		Assertions.assertEquals(-13, root.getValues()[1]);
@@ -218,19 +234,23 @@ public class ExmlTestIntrospectionIntegerNative {
 		elem.values = new int[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeIntegerNative>
 					<values>12</values>
 					<values>-13</values>
 					<values>33</values>
 					<values>78</values>
 					<values>-127</values>
-				</elem>""", dataTest);
+				</TestArrayNodeIntegerNative>""", dataTest);
 		
-		final TestArrayNodeIntegerNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeIntegerNative.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestArrayNodeIntegerNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeIntegerNative.class);
+		});
+		Assertions.assertNotNull(root);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals(12, root.values[0]);
 		Assertions.assertEquals(-13, root.values[1]);
@@ -246,12 +266,16 @@ public class ExmlTestIntrospectionIntegerNative {
 		elem.setValueB(57);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"-55\" valueB=\"57\"/>", dataTest);
+		Assertions.assertEquals("<TestintFunc valueA=\"-55\" valueB=\"57\"/>", dataTest);
 		
-		final TestintFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestintFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestintFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestintFunc.class);
+		});
+		Assertions.assertNotNull(root);
 		Assertions.assertEquals(-55, root.getValueA());
 		Assertions.assertEquals(57, root.getValueB());
 	}
@@ -263,12 +287,16 @@ public class ExmlTestIntrospectionIntegerNative {
 		elem.valueB = -13;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"12\" valueB=\"-13\"/>", dataTest);
+		Assertions.assertEquals("<TestIntegerNative valueA=\"12\" valueB=\"-13\"/>", dataTest);
 		
-		final TestIntegerNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestIntegerNative.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestIntegerNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestIntegerNative.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(12, root.valueA);
 		Assertions.assertEquals(-13, root.valueB);
 	}
@@ -280,16 +308,20 @@ public class ExmlTestIntrospectionIntegerNative {
 		elem.setValueB(-68);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeintFunc>
 					<valueA>54</valueA>
 					<valueB>-68</valueB>
-				</elem>""", dataTest);
+				</TestNodeintFunc>""", dataTest);
 		
-		final TestNodeintFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeintFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestNodeintFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeintFunc.class);
+		});
+		Assertions.assertNotNull(root);
 		Assertions.assertEquals(54, root.getValueA());
 		Assertions.assertEquals(-68, root.getValueB());
 	}
@@ -301,16 +333,20 @@ public class ExmlTestIntrospectionIntegerNative {
 		elem.valueB = -120;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeIntegerNative>
 					<valueA>11</valueA>
 					<valueB>-120</valueB>
-				</elem>""", dataTest);
+				</TestNodeIntegerNative>""", dataTest);
 		
-		final TestNodeIntegerNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeIntegerNative.class, ExmlTestIntrospectionInteger.NODE_NAME));
+		final TestNodeIntegerNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeIntegerNative.class);
+		});
+		Assertions.assertNotNull(root);
 		Assertions.assertEquals(11, root.valueA);
 		Assertions.assertEquals(-120, root.valueB);
 	}

test/src/test/atriasoft/exml/ExmlTestIntrospectionObject.java

@@ -7,9 +7,9 @@ package test.atriasoft.exml;
 
 import java.util.List;
 
-import org.atriasoft.aknot.annotation.AknotList;
 import org.atriasoft.aknot.annotation.AknotAttribute;
-import org.atriasoft.exml.Exml;
+import org.atriasoft.aknot.annotation.AknotList;
+import org.atriasoft.exml.XmlMapper;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -128,11 +128,11 @@ public class ExmlTestIntrospectionObject {
 		elem.values[2].value2 = -75.0f;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeObject>
 					<values value1="55">
 						<value2>12568.0</value2>
 					</values>
@@ -142,9 +142,13 @@ public class ExmlTestIntrospectionObject {
 					<values value1="152654">
 						<value2>-75.0</value2>
 					</values>
-				</elem>""", dataTest);
+				</TestArrayNodeObject>""", dataTest);
 		
-		final TestArrayNodeObject root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeObject.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestArrayNodeObject root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeObject.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(3, root.values.length);
 		Assertions.assertEquals(55, root.values[0].value1);
 		Assertions.assertEquals(12568.0f, root.values[0].value2);
@@ -166,11 +170,11 @@ public class ExmlTestIntrospectionObject {
 		elem.getValues()[2].value2 = -75.0f;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeObjectFunc>
 					<values value1="55">
 						<value2>12568.0</value2>
 					</values>
@@ -180,9 +184,13 @@ public class ExmlTestIntrospectionObject {
 					<values value1="152654">
 						<value2>-75.0</value2>
 					</values>
-				</elem>""", dataTest);
+				</TestArrayNodeObjectFunc>""", dataTest);
 		
-		final TestArrayNodeObjectFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeObjectFunc.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestArrayNodeObjectFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeObjectFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(3, root.getValues().length);
 		Assertions.assertEquals(55, root.getValues()[0].value1);
 		Assertions.assertEquals(12568.0f, root.getValues()[0].value2);
@@ -204,11 +212,11 @@ public class ExmlTestIntrospectionObject {
 		elem.getValues()[2].value2 = -75.0f;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeStructuredObjectFunc>
 					<values>
 						<elem value1="55">
 							<value2>12568.0</value2>
@@ -220,9 +228,13 @@ public class ExmlTestIntrospectionObject {
 							<value2>-75.0</value2>
 						</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestArrayNodeStructuredObjectFunc>""", dataTest);
 		
-		final TestArrayNodeStructuredObjectFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeStructuredObjectFunc.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestArrayNodeStructuredObjectFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeStructuredObjectFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(3, root.getValues().length);
 		Assertions.assertEquals(55, root.getValues()[0].value1);
 		Assertions.assertEquals(12568.0f, root.getValues()[0].value2);
@@ -244,11 +256,11 @@ public class ExmlTestIntrospectionObject {
 		elem.values.get(2).value2 = -75.0f;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeObject>
 					<values value1="55">
 						<value2>12568.0</value2>
 					</values>
@@ -258,9 +270,13 @@ public class ExmlTestIntrospectionObject {
 					<values value1="152654">
 						<value2>-75.0</value2>
 					</values>
-				</elem>""", dataTest);
+				</TestListNodeObject>""", dataTest);
 		
-		final TestListNodeObject root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeObject.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestListNodeObject root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeObject.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(3, root.values.size());
 		Assertions.assertEquals(55, root.values.get(0).value1);
 		Assertions.assertEquals(12568.0f, root.values.get(0).value2);
@@ -282,11 +298,11 @@ public class ExmlTestIntrospectionObject {
 		elem.getValues().get(2).value2 = -75.0f;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeObjectFunc>
 					<values value1="55">
 						<value2>12568.0</value2>
 					</values>
@@ -296,9 +312,13 @@ public class ExmlTestIntrospectionObject {
 					<values value1="152654">
 						<value2>-75.0</value2>
 					</values>
-				</elem>""", dataTest);
+				</TestListNodeObjectFunc>""", dataTest);
 		
-		final TestListNodeObjectFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeObjectFunc.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestListNodeObjectFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeObjectFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(3, root.getValues().size());
 		Assertions.assertEquals(55, root.getValues().get(0).value1);
 		Assertions.assertEquals(12568.0f, root.getValues().get(0).value2);
@@ -320,11 +340,11 @@ public class ExmlTestIntrospectionObject {
 		elem.getValues().get(2).value2 = -75.0f;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeStructuredObjectFunc>
 					<values>
 						<elem value1="55">
 							<value2>12568.0</value2>
@@ -336,9 +356,13 @@ public class ExmlTestIntrospectionObject {
 							<value2>-75.0</value2>
 						</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestListNodeStructuredObjectFunc>""", dataTest);
 		
-		final TestListNodeStructuredObjectFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeStructuredObjectFunc.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestListNodeStructuredObjectFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeStructuredObjectFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(3, root.getValues().size());
 		Assertions.assertEquals(55, root.getValues().get(0).value1);
 		Assertions.assertEquals(12568.0f, root.getValues().get(0).value2);
@@ -359,20 +383,24 @@ public class ExmlTestIntrospectionObject {
 		elem.valueB.value2 = -12568.0f;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeObject>
 					<valueA value1="55">
 						<value2>12568.0</value2>
 					</valueA>
 					<valueB value1="-55">
 						<value2>-12568.0</value2>
 					</valueB>
-				</elem>""", dataTest);
+				</TestNodeObject>""", dataTest);
 		
-		final TestNodeObject root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObject.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestNodeObject root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeObject.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(55, root.valueA.value1);
 		Assertions.assertEquals(12568.0f, root.valueA.value2);
 		Assertions.assertEquals(-55, root.valueB.value1);
@@ -390,20 +418,24 @@ public class ExmlTestIntrospectionObject {
 		elem.getValueB().value2 = 85422.0f;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeObjectFunc>
 					<valueA value1="4564">
 						<value2>152.0</value2>
 					</valueA>
 					<valueB value1="454564">
 						<value2>85422.0</value2>
 					</valueB>
-				</elem>""", dataTest);
+				</TestNodeObjectFunc>""", dataTest);
 		
-		final TestNodeObjectFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObjectFunc.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestNodeObjectFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeObjectFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(4564, root.getValueA().value1);
 		Assertions.assertEquals(152.0f, root.getValueA().value2);
 		Assertions.assertEquals(454564, root.getValueB().value1);

test/src/test/atriasoft/exml/ExmlTestIntrospectionObjectConstructor.java

@@ -5,9 +5,9 @@
  */
 package test.atriasoft.exml;
 
-import org.atriasoft.aknot.annotation.AknotName;
 import org.atriasoft.aknot.annotation.AknotAttribute;
-import org.atriasoft.exml.Exml;
+import org.atriasoft.aknot.annotation.AknotName;
+import org.atriasoft.exml.XmlMapper;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -60,15 +60,19 @@ public class ExmlTestIntrospectionObjectConstructor {
 	public void testModelConstructorSpecific() {
 		final TestConstructorSpecific elem = new TestConstructorSpecific(66, 18523.0);
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem valueA="66">
+				<TestConstructorSpecific valueA="66">
 					<valueB>18523.0</valueB>
-				</elem>""", dataTest);
+				</TestConstructorSpecific>""", dataTest);
 		
-		final TestConstructorSpecific root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestConstructorSpecific.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestConstructorSpecific root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestConstructorSpecific.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(66, root.valueA);
 		Assertions.assertEquals(18523.0f, root.valueB);
 	}
@@ -77,15 +81,19 @@ public class ExmlTestIntrospectionObjectConstructor {
 	public void testModelConstructorSpecificParameter() {
 		final TestConstructorSpecificParameter elem = new TestConstructorSpecificParameter(66, 18523.0);
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem valueA="66">
+				<TestConstructorSpecificParameter valueA="66">
 					<valueB>18523.0</valueB>
-				</elem>""", dataTest);
+				</TestConstructorSpecificParameter>""", dataTest);
 		
-		final TestConstructorSpecificParameter root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestConstructorSpecificParameter.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestConstructorSpecificParameter root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestConstructorSpecificParameter.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(66, root.valueA);
 		Assertions.assertEquals(18523.0f, root.valueB);
 	}
@@ -94,15 +102,19 @@ public class ExmlTestIntrospectionObjectConstructor {
 	public void testModelMultiConstructor() {
 		final TestMultiConstructor elem = new TestMultiConstructor(66, 18523.0);
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem valueA="66">
+				<TestMultiConstructor valueA="66">
 					<valueB>18523.0</valueB>
-				</elem>""", dataTest);
+				</TestMultiConstructor>""", dataTest);
 		
-		final TestMultiConstructor root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestMultiConstructor.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestMultiConstructor root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestMultiConstructor.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(66, root.valueA);
 		Assertions.assertEquals(18523.0f, root.valueB);
 	}

test/src/test/atriasoft/exml/ExmlTestIntrospectionRecord.java

@@ -5,9 +5,9 @@
  */
 package test.atriasoft.exml;
 
-import org.atriasoft.aknot.annotation.AknotName;
 import org.atriasoft.aknot.annotation.AknotAttribute;
-import org.atriasoft.exml.Exml;
+import org.atriasoft.aknot.annotation.AknotName;
+import org.atriasoft.exml.XmlMapper;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -32,16 +32,20 @@ public class ExmlTestIntrospectionRecord {
 	public void testModelRecord() {
 		final TestRecord elem = new TestRecord(66, 18523.0);
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestRecord>
 					<valueA>66</valueA>
 					<valueB>18523.0</valueB>
-				</elem>""", dataTest);
+				</TestRecord>""", dataTest);
 		
-		final TestRecord root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestRecord.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestRecord root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestRecord.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(66, root.valueA);
 		Assertions.assertEquals(18523.0f, root.valueB);
 	}
@@ -50,12 +54,16 @@ public class ExmlTestIntrospectionRecord {
 	public void testModelRecordProperty() {
 		final TestRecordProperty elem = new TestRecordProperty(66, 18523.0);
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"66\" valueB=\"18523.0\"/>", dataTest);
+		Assertions.assertEquals("<TestRecordProperty valueA=\"66\" valueB=\"18523.0\"/>", dataTest);
 		
-		final TestRecordProperty root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestRecordProperty.class, ExmlTestIntrospectionObject.NODE_NAME));
+		final TestRecordProperty root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestRecordProperty.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(66, root.valueA);
 		Assertions.assertEquals(18523.0f, root.valueB);
 	}

test/src/test/atriasoft/exml/ExmlTestIntrospectionShort.java

@@ -7,9 +7,9 @@ package test.atriasoft.exml;
 
 import java.util.List;
 
-import org.atriasoft.aknot.annotation.AknotList;
 import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
-import org.atriasoft.exml.Exml;
+import org.atriasoft.aknot.annotation.AknotList;
+import org.atriasoft.exml.XmlMapper;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -183,11 +183,11 @@ public class ExmlTestIntrospectionShort {
 		elem.values = new Short[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeShortStructured>
 					<values>
 						<elem>12</elem>
 						<elem>-13</elem>
@@ -195,9 +195,13 @@ public class ExmlTestIntrospectionShort {
 						<elem>78</elem>
 						<elem>-127</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestArrayNodeShortStructured>""", dataTest);
 		
-		final TestArrayNodeShortStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeShortStructured.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestArrayNodeShortStructured root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeShortStructured.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals((short) 12, root.values[0]);
 		Assertions.assertEquals((short) -13, root.values[1]);
@@ -212,11 +216,11 @@ public class ExmlTestIntrospectionShort {
 		elem.values = List.of((short) 12, (short) -13, (short) 33, (short) 78, (short) -127);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeShortStructured>
 					<values>
 						<elem>12</elem>
 						<elem>-13</elem>
@@ -224,9 +228,13 @@ public class ExmlTestIntrospectionShort {
 						<elem>78</elem>
 						<elem>-127</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestListNodeShortStructured>""", dataTest);
 		
-		final TestListNodeShortStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeShortStructured.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestListNodeShortStructured root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeShortStructured.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.size());
 		Assertions.assertEquals((short) 12, root.values.get(0));
 		Assertions.assertEquals((short) -13, root.values.get(1));
@@ -241,19 +249,23 @@ public class ExmlTestIntrospectionShort {
 		elem.values = new Short[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeShort>
 					<values>12</values>
 					<values>-13</values>
 					<values>33</values>
 					<values>78</values>
 					<values>-127</values>
-				</elem>""", dataTest);
+				</TestArrayNodeShort>""", dataTest);
 		
-		final TestArrayNodeShort root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeShort.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestArrayNodeShort root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeShort.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals((short) 12, root.values[0]);
 		Assertions.assertEquals((short) -13, root.values[1]);
@@ -268,19 +280,23 @@ public class ExmlTestIntrospectionShort {
 		elem.setValues(new Short[] { 12, -13, 33, 78, -127 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeShortFunc>
 					<values>12</values>
 					<values>-13</values>
 					<values>33</values>
 					<values>78</values>
 					<values>-127</values>
-				</elem>""", dataTest);
+				</TestArrayNodeShortFunc>""", dataTest);
 		
-		final TestArrayNodeShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestArrayNodeShortFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeShortFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals((short) 12, root.getValues()[0]);
 		Assertions.assertEquals((short) -13, root.getValues()[1]);
@@ -295,12 +311,16 @@ public class ExmlTestIntrospectionShort {
 		elem.values = new Short[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayShort values=\"12;-13;33;78;-127\"/>", dataTest);
 		
-		final TestArrayShort root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayShort.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestArrayShort root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayShort.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals((short) 12, root.values[0]);
 		Assertions.assertEquals((short) -13, root.values[1]);
@@ -315,12 +335,16 @@ public class ExmlTestIntrospectionShort {
 		elem.setValues(new Short[] { 12, -13, 33, 78, -127 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayShortFunc values=\"12;-13;33;78;-127\"/>", dataTest);
 		
-		final TestArrayShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestArrayShortFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayShortFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals((short) 12, root.getValues()[0]);
 		Assertions.assertEquals((short) -13, root.getValues()[1]);
@@ -335,19 +359,23 @@ public class ExmlTestIntrospectionShort {
 		elem.values = List.of((short) 12, (short) -13, (short) 33, (short) 78, (short) -127);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeShort>
 					<values>12</values>
 					<values>-13</values>
 					<values>33</values>
 					<values>78</values>
 					<values>-127</values>
-				</elem>""", dataTest);
+				</TestListNodeShort>""", dataTest);
 		
-		final TestListNodeShort root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeShort.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestListNodeShort root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeShort.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.size());
 		Assertions.assertEquals((short) 12, root.values.get(0));
 		Assertions.assertEquals((short) -13, root.values.get(1));
@@ -362,19 +390,23 @@ public class ExmlTestIntrospectionShort {
 		elem.setValues(List.of((short) 12, (short) -13, (short) 33, (short) 78, (short) -127));
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestListNodeShortFunc>
 					<values>12</values>
 					<values>-13</values>
 					<values>33</values>
 					<values>78</values>
 					<values>-127</values>
-				</elem>""", dataTest);
+				</TestListNodeShortFunc>""", dataTest);
 		
-		final TestListNodeShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestListNodeShortFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListNodeShortFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().size());
 		Assertions.assertEquals((short) 12, root.getValues().get(0));
 		Assertions.assertEquals((short) -13, root.getValues().get(1));
@@ -389,12 +421,16 @@ public class ExmlTestIntrospectionShort {
 		elem.values = List.of((short) 12, (short) -13, (short) 33, (short) 78, (short) -127);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
+		Assertions.assertEquals("<TestListShort values=\"12;-13;33;78;-127\"/>", dataTest);
 		
-		final TestListShort root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListShort.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestListShort root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListShort.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.size());
 		Assertions.assertEquals((short) 12, root.values.get(0));
 		Assertions.assertEquals((short) -13, root.values.get(1));
@@ -409,12 +445,16 @@ public class ExmlTestIntrospectionShort {
 		elem.setValues(List.of((short) 12, (short) -13, (short) 33, (short) 78, (short) -127));
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
+		Assertions.assertEquals("<TestListShortFunc values=\"12;-13;33;78;-127\"/>", dataTest);
 		
-		final TestListShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestListShortFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestListShortFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().size());
 		Assertions.assertEquals((short) 12, root.getValues().get(0));
 		Assertions.assertEquals((short) -13, root.getValues().get(1));
@@ -431,16 +471,20 @@ public class ExmlTestIntrospectionShort {
 		elem.valueNull = null;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeShort>
 					<valueA>11</valueA>
 					<valueB>-120</valueB>
-				</elem>""", dataTest);
+				</TestNodeShort>""", dataTest);
 		
-		final TestNodeShort root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeShort.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestNodeShort root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeShort.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals((short) 11, root.valueA);
 		Assertions.assertEquals((short) -120, root.valueB);
 		Assertions.assertEquals(null, root.valueNull);
@@ -454,16 +498,20 @@ public class ExmlTestIntrospectionShort {
 		elem.setValueNull(null);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeShortFunc>
 					<valueA>54</valueA>
 					<valueB>-68</valueB>
-				</elem>""", dataTest);
+				</TestNodeShortFunc>""", dataTest);
 		
-		final TestNodeShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestNodeShortFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeShortFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals((short) 54, root.getValueA());
 		Assertions.assertEquals((short) -68, root.getValueB());
 		Assertions.assertEquals(null, root.getValueNull());
@@ -477,12 +525,16 @@ public class ExmlTestIntrospectionShort {
 		elem.valueNull = null;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"12\" valueB=\"-13\"/>", dataTest);
+		Assertions.assertEquals("<TestShort valueA=\"12\" valueB=\"-13\"/>", dataTest);
 		
-		final TestShort root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestShort.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestShort root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestShort.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals((short) 12, root.valueA);
 		Assertions.assertEquals((short) -13, root.valueB);
 		Assertions.assertEquals(null, root.valueNull);
@@ -496,12 +548,16 @@ public class ExmlTestIntrospectionShort {
 		elem.setValueNull(null);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"-55\" valueB=\"57\"/>", dataTest);
+		Assertions.assertEquals("<TestShortFunc valueA=\"-55\" valueB=\"57\"/>", dataTest);
 		
-		final TestShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestShortFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestShortFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals((short) -55, root.getValueA());
 		Assertions.assertEquals((short) 57, root.getValueB());
 		Assertions.assertEquals(null, root.getValueNull());

test/src/test/atriasoft/exml/ExmlTestIntrospectionShortNative.java

@@ -5,9 +5,9 @@
  */
 package test.atriasoft.exml;
 
-import org.atriasoft.aknot.annotation.AknotList;
 import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
-import org.atriasoft.exml.Exml;
+import org.atriasoft.aknot.annotation.AknotList;
+import org.atriasoft.exml.XmlMapper;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -121,11 +121,11 @@ public class ExmlTestIntrospectionShortNative {
 		elem.values = new short[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeShortNativeStructured>
 					<values>
 						<elem>12</elem>
 						<elem>-13</elem>
@@ -133,9 +133,13 @@ public class ExmlTestIntrospectionShortNative {
 						<elem>78</elem>
 						<elem>-127</elem>
 					</values>
-				</elem>""", dataTest);
+				</TestArrayNodeShortNativeStructured>""", dataTest);
 		
-		final TestArrayNodeShortNativeStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeShortNativeStructured.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestArrayNodeShortNativeStructured root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeShortNativeStructured.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals((short) 12, root.values[0]);
 		Assertions.assertEquals((short) -13, root.values[1]);
@@ -150,19 +154,23 @@ public class ExmlTestIntrospectionShortNative {
 		elem.setValues(new short[] { 12, -13, 33, 78, -127 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeShortFunc>
 					<values>12</values>
 					<values>-13</values>
 					<values>33</values>
 					<values>78</values>
 					<values>-127</values>
-				</elem>""", dataTest);
+				</TestArrayNodeShortFunc>""", dataTest);
 		
-		final TestArrayNodeShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestArrayNodeShortFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeShortFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals((short) 12, root.getValues()[0]);
 		Assertions.assertEquals((short) -13, root.getValues()[1]);
@@ -177,19 +185,23 @@ public class ExmlTestIntrospectionShortNative {
 		elem.values = new short[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestArrayNodeShortNative>
 					<values>12</values>
 					<values>-13</values>
 					<values>33</values>
 					<values>78</values>
 					<values>-127</values>
-				</elem>""", dataTest);
+				</TestArrayNodeShortNative>""", dataTest);
 		
-		final TestArrayNodeShortNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeShortNative.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestArrayNodeShortNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayNodeShortNative.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals((short) 12, root.values[0]);
 		Assertions.assertEquals((short) -13, root.values[1]);
@@ -204,12 +216,16 @@ public class ExmlTestIntrospectionShortNative {
 		elem.setValues(new short[] { 12, -13, 33, 78, -127 });
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayShortFunc values=\"12;-13;33;78;-127\"/>", dataTest);
 		
-		final TestArrayShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestArrayShortFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayShortFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.getValues().length);
 		Assertions.assertEquals((short) 12, root.getValues()[0]);
 		Assertions.assertEquals((short) -13, root.getValues()[1]);
@@ -224,12 +240,16 @@ public class ExmlTestIntrospectionShortNative {
 		elem.values = new short[] { 12, -13, 33, 78, -127 };
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
+		Assertions.assertEquals("<TestArrayShortNative values=\"12;-13;33;78;-127\"/>", dataTest);
 		
-		final TestArrayShortNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayShortNative.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestArrayShortNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestArrayShortNative.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals(5, root.values.length);
 		Assertions.assertEquals((short) 12, root.values[0]);
 		Assertions.assertEquals((short) -13, root.values[1]);
@@ -245,16 +265,20 @@ public class ExmlTestIntrospectionShortNative {
 		elem.setValueB((short) -68);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeshortFunc>
 					<valueA>54</valueA>
 					<valueB>-68</valueB>
-				</elem>""", dataTest);
+				</TestNodeshortFunc>""", dataTest);
 		
-		final TestNodeshortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeshortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestNodeshortFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeshortFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals((short) 54, root.getValueA());
 		Assertions.assertEquals((short) -68, root.getValueB());
 	}
@@ -266,16 +290,20 @@ public class ExmlTestIntrospectionShortNative {
 		elem.valueB = (short) -120;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
 		Assertions.assertEquals("""
-				<elem>
+				<TestNodeShortNative>
 					<valueA>11</valueA>
 					<valueB>-120</valueB>
-				</elem>""", dataTest);
+				</TestNodeShortNative>""", dataTest);
 		
-		final TestNodeShortNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeShortNative.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestNodeShortNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestNodeShortNative.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals((short) 11, root.valueA);
 		Assertions.assertEquals((short) -120, root.valueB);
 	}
@@ -287,12 +315,16 @@ public class ExmlTestIntrospectionShortNative {
 		elem.setValueB((short) 57);
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"-55\" valueB=\"57\"/>", dataTest);
+		Assertions.assertEquals("<TestshortFunc valueA=\"-55\" valueB=\"57\"/>", dataTest);
 		
-		final TestshortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestshortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestshortFunc root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestshortFunc.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals((short) -55, root.getValueA());
 		Assertions.assertEquals((short) 57, root.getValueB());
 	}
@@ -304,12 +336,16 @@ public class ExmlTestIntrospectionShortNative {
 		elem.valueB = (short) -13;
 		
 		final StringBuilder builder = new StringBuilder();
-		Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
+		Assertions.assertDoesNotThrow(() -> (new XmlMapper()).generate(elem, builder));
 		final String dataTest = builder.toString();
 		Log.warning("data generated: " + builder.toString());
-		Assertions.assertEquals("<elem valueA=\"12\" valueB=\"-13\"/>", dataTest);
+		Assertions.assertEquals("<TestShortNative valueA=\"12\" valueB=\"-13\"/>", dataTest);
 		
-		final TestShortNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestShortNative.class, ExmlTestIntrospectionShort.NODE_NAME));
+		final TestShortNative root = Assertions.assertDoesNotThrow(() -> {
+			final XmlMapper mapper = new XmlMapper();
+			return mapper.parse(dataTest, TestShortNative.class);
+		});
+		Assertions.assertNotNull(elem);
 		Assertions.assertEquals((short) 12, root.valueA);
 		Assertions.assertEquals((short) -13, root.valueB);
 	}

test/src/test/atriasoft/exml/introspection/ClassMethodEnum.java

@@ -1,5 +1,8 @@
 package test.atriasoft.exml.introspection;
 
+import org.atriasoft.aknot.annotation.AknotName;
+
+@AknotName("elem")
 public class ClassMethodEnum {
 	private SimpleEnum data;
 	

test/src/test/atriasoft/exml/introspection/ClassPublicMemberOnly.java

@@ -1,8 +1,10 @@
 package test.atriasoft.exml.introspection;
 
 import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
+import org.atriasoft.aknot.annotation.AknotName;
 
 @AknotDefaultAttribute
+@AknotName("elem")
 public class ClassPublicMemberOnly {
 	public boolean[] memberArrayBoolean;
 	public Boolean[] memberArrayBooleanClass;

test/src/test/atriasoft/exml/introspection/ClassPublicMethodOnly.java

@@ -1,8 +1,10 @@
 package test.atriasoft.exml.introspection;
 
 import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
+import org.atriasoft.aknot.annotation.AknotName;
 
 @AknotDefaultAttribute
+@AknotName("elem")
 public class ClassPublicMethodOnly {
 	private boolean[] memberArrayBoolean;
 	private Boolean[] memberArrayBooleanClass;

test/src/test/atriasoft/exml/introspection/ClassPublicMethodeNode.java

@@ -2,9 +2,9 @@ package test.atriasoft.exml.introspection;
 
 import java.util.List;
 
-import org.atriasoft.aknot.annotation.AknotDefaultManaged;
+import org.atriasoft.aknot.annotation.AknotName;
 
-@AknotDefaultManaged(value = false)
+@AknotName("elem")
 public class ClassPublicMethodeNode {
 	
 	private boolean[] memberArrayBoolean;

test/src/test/atriasoft/exml/introspection/ClassPublicMethodeStructured.java

@@ -2,10 +2,10 @@ package test.atriasoft.exml.introspection;
 
 import java.util.List;
 
-import org.atriasoft.aknot.annotation.AknotDefaultManaged;
 import org.atriasoft.aknot.annotation.AknotList;
+import org.atriasoft.aknot.annotation.AknotName;
 
-@AknotDefaultManaged(value = false)
+@AknotName("elem")
 public class ClassPublicMethodeStructured {
 	// note: when private the decorator must be set on getter or setter, liker this you can use the internal name you want...
 	private byte[] memberArrayByte;