citygml4j-quality-ade/src/main/java/de/hft/stuttgart/quality/adapter/types/FilterAdapter.java

+package de.hft.stuttgart.quality.adapter.types;
+
+import javax.xml.namespace.QName;
+
+import org.xmlobjects.annotation.XMLElement;
+import org.xmlobjects.builder.ObjectBuildException;
+import org.xmlobjects.builder.ObjectBuilder;
+import org.xmlobjects.serializer.ObjectSerializeException;
+import org.xmlobjects.serializer.ObjectSerializer;
+import org.xmlobjects.stream.XMLReadException;
+import org.xmlobjects.stream.XMLReader;
+import org.xmlobjects.stream.XMLWriteException;
+import org.xmlobjects.stream.XMLWriter;
+import org.xmlobjects.xml.Attributes;
+import org.xmlobjects.xml.Element;
+import org.xmlobjects.xml.Namespaces;
+
+import de.hft.stuttgart.quality.QualityADEModule;
+import de.hft.stuttgart.quality.adapter.properties.CheckingPropertyAdapter;
+import de.hft.stuttgart.quality.model.properties.CheckingProperty;
+import de.hft.stuttgart.quality.model.types.Filter;
+
+@XMLElement(name = "Filter", namespaceURI = QualityADEModule.NAMESPACE_URI)
+public class FilterAdapter implements ObjectBuilder<Filter>, ObjectSerializer<Filter> {
+
+	@Override
+	public Filter createObject(QName name, Object parent) throws ObjectBuildException {
+		return new Filter();
+	}
+
+	@Override
+	public void buildChildObject(Filter object, QName name, Attributes attributes, XMLReader reader)
+			throws ObjectBuildException, XMLReadException {
+		if (!QualityADEModule.NAMESPACE_URI.equals(name.getNamespaceURI())) {
+			return;
+		}
+		switch (name.getLocalPart()) {
+		case "checking":
+			object.getChecking().add(reader.getObjectUsingBuilder(CheckingPropertyAdapter.class));
+			break;
+		default:
+			throw new IllegalStateException("Cannot handle name " + name + " when building Filter element");
+		}
+	}
+
+	@Override
+	public Element createElement(Filter object, Namespaces namespaces) throws ObjectSerializeException {
+		return Element.of(QualityADEModule.NAMESPACE_URI, "Filter");
+	}
+
+	@Override
+	public void writeChildElements(Filter object, Namespaces namespaces, XMLWriter writer)
+			throws ObjectSerializeException, XMLWriteException {
+		for (CheckingProperty checkProp : object.getChecking()) {
+			writer.writeElementUsingSerializer(Element.of(QualityADEModule.NAMESPACE_URI, "checking"), checkProp,
+					CheckingPropertyAdapter.class, namespaces);
+		}
+	}
+}

citygml4j-quality-ade/src/main/java/de/hft/stuttgart/quality/adapter/types/GlobalParametersAdapter.java

+package de.hft.stuttgart.quality.adapter.types;
+
+import javax.xml.namespace.QName;
+
+import org.xmlobjects.annotation.XMLElement;
+import org.xmlobjects.builder.ObjectBuildException;
+import org.xmlobjects.builder.ObjectBuilder;
+import org.xmlobjects.serializer.ObjectSerializeException;
+import org.xmlobjects.serializer.ObjectSerializer;
+import org.xmlobjects.stream.XMLReadException;
+import org.xmlobjects.stream.XMLReader;
+import org.xmlobjects.stream.XMLWriteException;
+import org.xmlobjects.stream.XMLWriter;
+import org.xmlobjects.xml.Attributes;
+import org.xmlobjects.xml.Element;
+import org.xmlobjects.xml.Namespaces;
+
+import de.hft.stuttgart.quality.QualityADEModule;
+import de.hft.stuttgart.quality.adapter.properties.ParameterPropertyAdapter;
+import de.hft.stuttgart.quality.model.properties.ParameterProperty;
+import de.hft.stuttgart.quality.model.types.GlobalParameters;
+
+@XMLElement(name = "GlobalParameters", namespaceURI = QualityADEModule.NAMESPACE_URI)
+public class GlobalParametersAdapter implements ObjectBuilder<GlobalParameters>, ObjectSerializer<GlobalParameters> {
+
+	@Override
+	public GlobalParameters createObject(QName name, Object parent) throws ObjectBuildException {
+		return new GlobalParameters();
+	}
+
+	@Override
+	public void buildChildObject(GlobalParameters object, QName name, Attributes attributes, XMLReader reader)
+			throws ObjectBuildException, XMLReadException {
+		if (!QualityADEModule.NAMESPACE_URI.equals(name.getNamespaceURI())) {
+			return;
+		}
+		switch (name.getLocalPart()) {
+		case "parameter":
+			object.getParameters().add(reader.getObjectUsingBuilder(ParameterPropertyAdapter.class));
+			break;
+		default:
+			throw new IllegalStateException("Cannot handle name " + name + " when building GlobalParameters element");
+		}
+	}
+
+	@Override
+	public Element createElement(GlobalParameters object, Namespaces namespaces) throws ObjectSerializeException {
+		return Element.of(QualityADEModule.NAMESPACE_URI, "GlobalParameters");
+	}
+
+	@Override
+	public void writeChildElements(GlobalParameters object, Namespaces namespaces, XMLWriter writer)
+			throws ObjectSerializeException, XMLWriteException {
+		for (ParameterProperty gpp : object.getParameters()) {
+			writer.writeElementUsingSerializer(Element.of(QualityADEModule.NAMESPACE_URI, "parameter"), gpp,
+					ParameterPropertyAdapter.class, namespaces);
+		}
+	}
+}

citygml4j-quality-ade/src/main/java/de/hft/stuttgart/quality/adapter/types/HoleOutsideErrorAdapter.java

+package de.hft.stuttgart.quality.adapter.types;
+
+import javax.xml.namespace.QName;
+
+import org.xmlobjects.annotation.XMLElement;
+import org.xmlobjects.builder.ObjectBuildException;
+import org.xmlobjects.serializer.ObjectSerializeException;
+import org.xmlobjects.stream.XMLReadException;
+import org.xmlobjects.stream.XMLReader;
+import org.xmlobjects.stream.XMLWriteException;
+import org.xmlobjects.stream.XMLWriter;
+import org.xmlobjects.xml.Attributes;
+import org.xmlobjects.xml.Element;
+import org.xmlobjects.xml.Namespaces;
+
+import de.hft.stuttgart.quality.QualityADEModule;
+import de.hft.stuttgart.quality.model.types.HoleOutsideError;
+
+@XMLElement(name = "GE_P_HOLE_OUTSIDE", namespaceURI = QualityADEModule.NAMESPACE_URI)
+public class HoleOutsideErrorAdapter extends AbstractPolygonErrorAdapter<HoleOutsideError> {
+
+	@Override
+	public HoleOutsideError createObject(QName name, Object parent) throws ObjectBuildException {
+		return new HoleOutsideError();
+	}
+
+	@Override
+	public void buildChildObject(HoleOutsideError object, QName name, Attributes attributes, XMLReader reader)
+			throws ObjectBuildException, XMLReadException {
+		if (!QualityADEModule.NAMESPACE_URI.equals(name.getNamespaceURI())) {
+			return;
+		}
+		switch (name.getLocalPart()) {
+		case "linearRingId":
+			reader.getTextContent().ifPresent(object::setLinearRingId);
+			break;
+		default:
+			super.buildChildObject(object, name, attributes, reader);
+		}
+	}
+
+	@Override
+	public Element createElement(HoleOutsideError object, Namespaces namespaces) throws ObjectSerializeException {
+		return Element.of(QualityADEModule.NAMESPACE_URI, "GE_P_HOLE_OUTSIDE");
+	}
+
+	@Override
+	public void writeChildElements(HoleOutsideError object, Namespaces namespaces, XMLWriter writer)
+			throws ObjectSerializeException, XMLWriteException {
+		super.writeChildElements(object, namespaces, writer);
+
+		if (object.getLinearRingId() != null) {
+			writer.writeElement(Element.of(QualityADEModule.NAMESPACE_URI, "linearRingId")
+					.addTextContent(object.getLinearRingId()));
+		}
+	}
+}

citygml4j-quality-ade/src/main/java/de/hft/stuttgart/quality/adapter/types/InnerRingsNestedErrorAdapter.java

+package de.hft.stuttgart.quality.adapter.types;
+
+import javax.xml.namespace.QName;
+
+import org.xmlobjects.annotation.XMLElement;
+import org.xmlobjects.builder.ObjectBuildException;
+import org.xmlobjects.serializer.ObjectSerializeException;
+import org.xmlobjects.stream.XMLReadException;
+import org.xmlobjects.stream.XMLReader;
+import org.xmlobjects.stream.XMLWriteException;
+import org.xmlobjects.stream.XMLWriter;
+import org.xmlobjects.xml.Attributes;
+import org.xmlobjects.xml.Element;
+import org.xmlobjects.xml.Namespaces;
+
+import de.hft.stuttgart.quality.QualityADEModule;
+import de.hft.stuttgart.quality.model.types.InnerRingsNestedError;
+
+@XMLElement(name = "GE_P_INNER_RINGS_NESTED", namespaceURI = QualityADEModule.NAMESPACE_URI)
+public class InnerRingsNestedErrorAdapter extends AbstractPolygonErrorAdapter<InnerRingsNestedError> {
+
+	@Override
+	public InnerRingsNestedError createObject(QName name, Object parent) throws ObjectBuildException {
+		return new InnerRingsNestedError();
+	}
+
+	@Override
+	public void buildChildObject(InnerRingsNestedError object, QName name, Attributes attributes, XMLReader reader)
+			throws ObjectBuildException, XMLReadException {
+		if (!QualityADEModule.NAMESPACE_URI.equals(name.getNamespaceURI())) {
+			return;
+		}
+		switch (name.getLocalPart()) {
+		case "linearRingId1":
+			reader.getTextContent().ifPresent(object::setLinearRingId1);
+			break;
+		case "linearRingId2":
+			reader.getTextContent().ifPresent(object::setLinearRingId2);
+			break;
+		default:
+			super.buildChildObject(object, name, attributes, reader);
+		}
+	}
+
+	@Override
+	public Element createElement(InnerRingsNestedError object, Namespaces namespaces) throws ObjectSerializeException {
+		return Element.of(QualityADEModule.NAMESPACE_URI, "GE_P_INNER_RINGS_NESTED");
+	}
+
+	@Override
+	public void writeChildElements(InnerRingsNestedError object, Namespaces namespaces, XMLWriter writer)
+			throws ObjectSerializeException, XMLWriteException {
+		super.writeChildElements(object, namespaces, writer);
+		if (object.getLinearRingId1() != null) {
+			writer.writeElement(Element.of(QualityADEModule.NAMESPACE_URI, "linearRingId1")
+					.addTextContent(object.getLinearRingId1()));
+		}
+		if (object.getLinearRingId2() != null) {
+			writer.writeElement(Element.of(QualityADEModule.NAMESPACE_URI, "linearRingId2")
+					.addTextContent(object.getLinearRingId2()));
+		}
+	}
+}

citygml4j-quality-ade/src/main/java/de/hft/stuttgart/quality/adapter/types/InteriorDisconnectedErrorAdapter.java

+package de.hft.stuttgart.quality.adapter.types;
+
+import javax.xml.namespace.QName;
+
+import org.xmlobjects.annotation.XMLElement;
+import org.xmlobjects.builder.ObjectBuildException;
+import org.xmlobjects.serializer.ObjectSerializeException;
+import org.xmlobjects.xml.Element;
+import org.xmlobjects.xml.Namespaces;
+
+import de.hft.stuttgart.quality.QualityADEModule;
+import de.hft.stuttgart.quality.model.types.InteriorDisconnectedError;
+
+@XMLElement(name = "GE_P_INTERIOR_DISCONNECTED", namespaceURI = QualityADEModule.NAMESPACE_URI)
+public class InteriorDisconnectedErrorAdapter extends AbstractPolygonErrorAdapter<InteriorDisconnectedError> {
+
+	@Override
+	public InteriorDisconnectedError createObject(QName name, Object parent) throws ObjectBuildException {
+		return new InteriorDisconnectedError();
+	}
+
+	@Override
+	public Element createElement(InteriorDisconnectedError object, Namespaces namespaces)
+			throws ObjectSerializeException {
+		return Element.of(QualityADEModule.NAMESPACE_URI, "GE_P_INTERIOR_DISCONNECTED");
+	}
+
+}

citygml4j-quality-ade/src/main/java/de/hft/stuttgart/quality/adapter/types/IntersectingRingsErrorAdapter.java

+package de.hft.stuttgart.quality.adapter.types;
+
+import javax.xml.namespace.QName;
+
+import org.xmlobjects.annotation.XMLElement;
+import org.xmlobjects.builder.ObjectBuildException;
+import org.xmlobjects.serializer.ObjectSerializeException;
+import org.xmlobjects.stream.XMLReadException;
+import org.xmlobjects.stream.XMLReader;
+import org.xmlobjects.stream.XMLWriteException;
+import org.xmlobjects.stream.XMLWriter;
+import org.xmlobjects.xml.Attributes;
+import org.xmlobjects.xml.Element;
+import org.xmlobjects.xml.Namespaces;
+
+import de.hft.stuttgart.quality.QualityADEModule;
+import de.hft.stuttgart.quality.model.types.IntersectingRingsError;
+
+@XMLElement(name = "GE_P_INTERSECTING_RINGS", namespaceURI = QualityADEModule.NAMESPACE_URI)
+public class IntersectingRingsErrorAdapter extends AbstractPolygonErrorAdapter<IntersectingRingsError> {
+
+	@Override
+	public IntersectingRingsError createObject(QName name, Object parent) throws ObjectBuildException {
+		return new IntersectingRingsError();
+	}
+
+	@Override
+	public void buildChildObject(IntersectingRingsError object, QName name, Attributes attributes, XMLReader reader)
+			throws ObjectBuildException, XMLReadException {
+		if (!QualityADEModule.NAMESPACE_URI.equals(name.getNamespaceURI())) {
+			return;
+		}
+		switch (name.getLocalPart()) {
+		case "linearRingId1":
+			reader.getTextContent().ifPresent(object::setLinearRingId1);
+			break;
+		case "linearRingId2":
+			reader.getTextContent().ifPresent(object::setLinearRingId2);
+			break;
+		default:
+			super.buildChildObject(object, name, attributes, reader);
+		}
+	}
+
+	@Override
+	public Element createElement(IntersectingRingsError object, Namespaces namespaces) throws ObjectSerializeException {
+		return Element.of(QualityADEModule.NAMESPACE_URI, "GE_P_INTERSECTING_RINGS");
+	}
+
+	@Override
+	public void writeChildElements(IntersectingRingsError object, Namespaces namespaces, XMLWriter writer)
+			throws ObjectSerializeException, XMLWriteException {
+		super.writeChildElements(object, namespaces, writer);
+
+		if (object.getLinearRingId1() != null) {
+			writer.writeElement(Element.of(QualityADEModule.NAMESPACE_URI, "linearRingId1")
+					.addTextContent(object.getLinearRingId1()));
+		}
+		if (object.getLinearRingId2() != null) {
+			writer.writeElement(Element.of(QualityADEModule.NAMESPACE_URI, "linearRingId2")
+					.addTextContent(object.getLinearRingId2()));
+		}
+	}
+}

citygml4j-quality-ade/src/main/java/de/hft/stuttgart/quality/adapter/types/MultipleComponentsErrorAdapter.java

+package de.hft.stuttgart.quality.adapter.types;
+
+import javax.xml.namespace.QName;
+
+import org.xmlobjects.annotation.XMLElement;
+import org.xmlobjects.builder.ObjectBuildException;
+import org.xmlobjects.serializer.ObjectSerializeException;
+import org.xmlobjects.stream.XMLReadException;
+import org.xmlobjects.stream.XMLReader;
+import org.xmlobjects.stream.XMLWriteException;
+import org.xmlobjects.stream.XMLWriter;
+import org.xmlobjects.xml.Attributes;
+import org.xmlobjects.xml.Element;
+import org.xmlobjects.xml.Namespaces;
+
+import de.hft.stuttgart.quality.QualityADEModule;
+import de.hft.stuttgart.quality.adapter.properties.PolygonIdListPropertyAdapter;
+import de.hft.stuttgart.quality.model.properties.PolygonIdListProperty;
+import de.hft.stuttgart.quality.model.types.MultipleComponentsError;
+
+@XMLElement(name = "GE_S_MULTIPLE_CONNECTED_COMPONENTS", namespaceURI = QualityADEModule.NAMESPACE_URI)
+public class MultipleComponentsErrorAdapter extends AbstractSolidErrorAdapter<MultipleComponentsError> {
+
+	@Override
+	public MultipleComponentsError createObject(QName name, Object parent) throws ObjectBuildException {
+		return new MultipleComponentsError();
+	}
+
+	@Override
+	public void buildChildObject(MultipleComponentsError object, QName name, Attributes attributes, XMLReader reader)
+			throws ObjectBuildException, XMLReadException {
+		if (!QualityADEModule.NAMESPACE_URI.equals(name.getNamespaceURI())) {
+			return;
+		}
+		switch (name.getLocalPart()) {
+		case "component":
+			object.getComponents().add(reader.getObjectUsingBuilder(PolygonIdListPropertyAdapter.class));
+			break;
+		default:
+			super.buildChildObject(object, name, attributes, reader);
+		}
+	}
+
+	@Override
+	public Element createElement(MultipleComponentsError object, Namespaces namespaces)
+			throws ObjectSerializeException {
+		return Element.of(QualityADEModule.NAMESPACE_URI, "GE_S_MULTIPLE_CONNECTED_COMPONENTS");
+	}
+
+	@Override
+	public void writeChildElements(MultipleComponentsError object, Namespaces namespaces, XMLWriter writer)
+			throws ObjectSerializeException, XMLWriteException {
+		super.writeChildElements(object, namespaces, writer);
+		for (PolygonIdListProperty clp : object.getComponents()) {
+			writer.writeElementUsingSerializer(Element.of(QualityADEModule.NAMESPACE_URI, "component"), clp,
+					PolygonIdListPropertyAdapter.class, namespaces);
+		}
+	}
+}

citygml4j-quality-ade/src/main/java/de/hft/stuttgart/quality/adapter/types/NonManifoldEdgeErrorAdapter.java

+package de.hft.stuttgart.quality.adapter.types;
+
+import javax.xml.namespace.QName;
+
+import org.xmlobjects.annotation.XMLElement;
+import org.xmlobjects.builder.ObjectBuildException;
+import org.xmlobjects.serializer.ObjectSerializeException;
+import org.xmlobjects.stream.XMLReadException;
+import org.xmlobjects.stream.XMLReader;
+import org.xmlobjects.stream.XMLWriteException;
+import org.xmlobjects.stream.XMLWriter;
+import org.xmlobjects.xml.Attributes;
+import org.xmlobjects.xml.Element;
+import org.xmlobjects.xml.Namespaces;
+
+import de.hft.stuttgart.quality.QualityADEModule;
+import de.hft.stuttgart.quality.adapter.properties.EdgeListPropertyAdapter;
+import de.hft.stuttgart.quality.model.types.NonManifoldEdgeError;
+
+@XMLElement(name = "GE_S_NON_MANIFOLD_EDGE", namespaceURI = QualityADEModule.NAMESPACE_URI)
+public class NonManifoldEdgeErrorAdapter extends AbstractSolidErrorAdapter<NonManifoldEdgeError> {
+
+	@Override
+	public NonManifoldEdgeError createObject(QName name, Object parent) throws ObjectBuildException {
+		return new NonManifoldEdgeError();
+	}
+
+	@Override
+	public void buildChildObject(NonManifoldEdgeError object, QName name, Attributes attributes, XMLReader reader)
+			throws ObjectBuildException, XMLReadException {
+		if (!QualityADEModule.NAMESPACE_URI.equals(name.getNamespaceURI())) {
+			return;
+		}
+		switch (name.getLocalPart()) {
+		case "edges":
+			object.setEdges(reader.getObjectUsingBuilder(EdgeListPropertyAdapter.class));
+			break;
+		default:
+			super.buildChildObject(object, name, attributes, reader);
+		}
+	}
+
+	@Override
+	public Element createElement(NonManifoldEdgeError object, Namespaces namespaces) throws ObjectSerializeException {
+		return Element.of(QualityADEModule.NAMESPACE_URI, "GE_S_NON_MANIFOLD_EDGE");
+	}
+
+	@Override
+	public void writeChildElements(NonManifoldEdgeError object, Namespaces namespaces, XMLWriter writer)
+			throws ObjectSerializeException, XMLWriteException {
+		super.writeChildElements(object, namespaces, writer);
+		if (object.getEdges() != null) {
+			writer.writeElementUsingSerializer(Element.of(QualityADEModule.NAMESPACE_URI, "edges"), object.getEdges(),
+					EdgeListPropertyAdapter.class, namespaces);
+		}
+	}
+}

citygml4j-quality-ade/src/main/java/de/hft/stuttgart/quality/adapter/types/NonManifoldVertexErrorAdapter.java

+package de.hft.stuttgart.quality.adapter.types;
+
+import javax.xml.namespace.QName;
+
+import org.xmlobjects.annotation.XMLElement;
+import org.xmlobjects.builder.ObjectBuildException;
+import org.xmlobjects.gml.adapter.geometry.DirectPositionAdapter;
+import org.xmlobjects.serializer.ObjectSerializeException;
+import org.xmlobjects.stream.XMLReadException;
+import org.xmlobjects.stream.XMLReader;
+import org.xmlobjects.stream.XMLWriteException;
+import org.xmlobjects.stream.XMLWriter;
+import org.xmlobjects.xml.Attributes;
+import org.xmlobjects.xml.Element;
+import org.xmlobjects.xml.Namespaces;
+
+import de.hft.stuttgart.quality.QualityADEModule;
+import de.hft.stuttgart.quality.model.types.NonManifoldVertexError;
+
+@XMLElement(name = "GE_S_NON_MANIFOLD_VERTEX", namespaceURI = QualityADEModule.NAMESPACE_URI)
+public class NonManifoldVertexErrorAdapter extends AbstractSolidErrorAdapter<NonManifoldVertexError> {
+
+	@Override
+	public NonManifoldVertexError createObject(QName name, Object parent) throws ObjectBuildException {
+		return new NonManifoldVertexError();
+	}
+
+	@Override
+	public void buildChildObject(NonManifoldVertexError object, QName name, Attributes attributes, XMLReader reader)
+			throws ObjectBuildException, XMLReadException {
+		if (!QualityADEModule.NAMESPACE_URI.equals(name.getNamespaceURI())) {
+			return;
+		}
+		switch (name.getLocalPart()) {
+		case "vertex":
+			object.setVertex(reader.getObjectUsingBuilder(DirectPositionAdapter.class));
+			break;
+		default:
+			super.buildChildObject(object, name, attributes, reader);
+		}
+	}
+
+	@Override
+	public Element createElement(NonManifoldVertexError object, Namespaces namespaces) throws ObjectSerializeException {
+		return Element.of(QualityADEModule.NAMESPACE_URI, "GE_S_NON_MANIFOLD_VERTEX");
+	}
+
+	@Override
+	public void writeChildElements(NonManifoldVertexError object, Namespaces namespaces, XMLWriter writer)
+			throws ObjectSerializeException, XMLWriteException {
+		super.writeChildElements(object, namespaces, writer);
+		if (object.getVertex() != null) {
+			writer.writeElementUsingSerializer(Element.of(QualityADEModule.NAMESPACE_URI, "vertex"), object.getVertex(),
+					DirectPositionAdapter.class, namespaces);
+		}
+	}
+}

citygml4j-quality-ade/src/main/java/de/hft/stuttgart/quality/adapter/types/OrientationRingsSameErrorAdapter.java

+package de.hft.stuttgart.quality.adapter.types;
+
+import javax.xml.namespace.QName;
+
+import org.xmlobjects.annotation.XMLElement;
+import org.xmlobjects.builder.ObjectBuildException;
+import org.xmlobjects.serializer.ObjectSerializeException;
+import org.xmlobjects.stream.XMLReadException;
+import org.xmlobjects.stream.XMLReader;
+import org.xmlobjects.stream.XMLWriteException;
+import org.xmlobjects.stream.XMLWriter;
+import org.xmlobjects.xml.Attributes;
+import org.xmlobjects.xml.Element;
+import org.xmlobjects.xml.Namespaces;
+
+import de.hft.stuttgart.quality.QualityADEModule;
+import de.hft.stuttgart.quality.model.types.OrientationRingsSameError;
+
+@XMLElement(name = "GE_P_ORIENTATION_RINGS_SAME", namespaceURI = QualityADEModule.NAMESPACE_URI)
+public class OrientationRingsSameErrorAdapter extends AbstractPolygonErrorAdapter<OrientationRingsSameError> {
+
+	@Override
+	public OrientationRingsSameError createObject(QName name, Object parent) throws ObjectBuildException {
+		return new OrientationRingsSameError();
+	}
+
+	@Override
+	public void buildChildObject(OrientationRingsSameError object, QName name, Attributes attributes, XMLReader reader)
+			throws ObjectBuildException, XMLReadException {
+		if (!QualityADEModule.NAMESPACE_URI.equals(name.getNamespaceURI())) {
+			return;
+		}
+		switch (name.getLocalPart()) {
+		case "linearRingId":
+			reader.getTextContent().ifPresent(object::setLinearRing);
+			break;
+		default:
+			super.buildChildObject(object, name, attributes, reader);
+		}
+	}
+
+	@Override
+	public Element createElement(OrientationRingsSameError object, Namespaces namespaces)
+			throws ObjectSerializeException {
+		return Element.of(QualityADEModule.NAMESPACE_URI, "GE_P_ORIENTATION_RINGS_SAME");
+	}
+
+	@Override
+	public void writeChildElements(OrientationRingsSameError object, Namespaces namespaces, XMLWriter writer)
+			throws ObjectSerializeException, XMLWriteException {
+		super.writeChildElements(object, namespaces, writer);
+		if (object.getLinearRing() != null) {
+			writer.writeElement(
+					Element.of(QualityADEModule.NAMESPACE_URI, "linearRingId").addTextContent(object.getLinearRing()));
+		}
+	}
+}

citygml4j-quality-ade/src/main/java/de/hft/stuttgart/quality/adapter/types/ParameterAdapter.java

+package de.hft.stuttgart.quality.adapter.types;
+
+import de.hft.stuttgart.quality.model.types.Parameter;
+
+import de.hft.stuttgart.quality.QualityADEModule;
+
+import org.xmlobjects.annotation.XMLElement;
+import org.xmlobjects.builder.ObjectBuildException;
+import org.xmlobjects.builder.ObjectBuilder;
+import org.xmlobjects.serializer.ObjectSerializeException;
+import org.xmlobjects.serializer.ObjectSerializer;
+import org.xmlobjects.stream.XMLReadException;
+import org.xmlobjects.stream.XMLReader;
+import org.xmlobjects.stream.XMLWriteException;
+import org.xmlobjects.stream.XMLWriter;
+import org.xmlobjects.xml.Attributes;
+import org.xmlobjects.xml.Element;
+import org.xmlobjects.xml.Namespaces;
+
+import javax.xml.namespace.QName;
+
+@XMLElement(name = "Parameter", namespaceURI = QualityADEModule.NAMESPACE_URI)
+public class ParameterAdapter implements ObjectBuilder<Parameter>, ObjectSerializer<Parameter> {
+
+	@Override
+	public Parameter createObject(QName name, Object parent) throws ObjectBuildException {
+		return new Parameter();
+	}
+
+	@Override
+	public void buildChildObject(Parameter object, QName name, Attributes attributes, XMLReader reader)
+			throws ObjectBuildException, XMLReadException {
+		if (!QualityADEModule.NAMESPACE_URI.equals(name.getNamespaceURI())) {
+			return;
+		}
+		switch (name.getLocalPart()) {
+		case "name":
+			reader.getTextContent().ifPresent(object::setName);
+			break;
+		case "uom":
+			reader.getTextContent().ifPresent(object::setUom);
+			break;
+		case "value":
+			reader.getTextContent().ifPresent(object::setValue);
+			break;
+		default:
+			throw new IllegalStateException("Cannot handle name " + name + " when building Parameter element");
+		}
+	}
+
+	@Override
+	public Element createElement(Parameter object, Namespaces namespaces) throws ObjectSerializeException {
+		return Element.of(QualityADEModule.NAMESPACE_URI, "Parameter");
+	}
+
+	@Override
+	public void writeChildElements(Parameter object, Namespaces namespaces, XMLWriter writer)
+			throws ObjectSerializeException, XMLWriteException {
+		if (object.getName() != null) {
+			writer.writeElement(Element.of(QualityADEModule.NAMESPACE_URI, "name").addTextContent(object.getName()));
+		}
+		if (object.getUom() != null) {
+			writer.writeElement(Element.of(QualityADEModule.NAMESPACE_URI, "uom").addTextContent(object.getUom()));
+		}
+		if (object.getValue() != null) {
+			writer.writeElement(Element.of(QualityADEModule.NAMESPACE_URI, "value").addTextContent(object.getValue()));
+		}
+	}
+}

citygml4j-quality-ade/src/main/java/de/hft/stuttgart/quality/adapter/types/PlanarDistancePlaneErrorAdapter.java

+package de.hft.stuttgart.quality.adapter.types;
+
+import javax.xml.namespace.QName;
+
+import org.xmlobjects.annotation.XMLElement;
+import org.xmlobjects.builder.ObjectBuildException;
+import org.xmlobjects.gml.adapter.geometry.DirectPositionAdapter;
+import org.xmlobjects.gml.adapter.measures.LengthAdapter;
+import org.xmlobjects.serializer.ObjectSerializeException;
+import org.xmlobjects.stream.XMLReadException;
+import org.xmlobjects.stream.XMLReader;
+import org.xmlobjects.stream.XMLWriteException;
+import org.xmlobjects.stream.XMLWriter;
+import org.xmlobjects.xml.Attributes;
+import org.xmlobjects.xml.Element;
+import org.xmlobjects.xml.Namespaces;
+
+import de.hft.stuttgart.quality.QualityADEModule;
+import de.hft.stuttgart.quality.model.types.PlanarDistancePlaneError;
+
+@XMLElement(name = "GE_P_NON_PLANAR_POLYGON_DISTANCE_PLANE", namespaceURI = QualityADEModule.NAMESPACE_URI)
+public class PlanarDistancePlaneErrorAdapter extends AbstractPolygonErrorAdapter<PlanarDistancePlaneError> {
+
+	@Override
+	public PlanarDistancePlaneError createObject(QName name, Object parent) throws ObjectBuildException {
+		return new PlanarDistancePlaneError();
+	}
+
+	@Override
+	public void buildChildObject(PlanarDistancePlaneError object, QName name, Attributes attributes, XMLReader reader)
+			throws ObjectBuildException, XMLReadException {
+		if (!QualityADEModule.NAMESPACE_URI.equals(name.getNamespaceURI())) {
+			return;
+		}
+		switch (name.getLocalPart()) {
+		case "vertex":
+			object.setVertex(reader.getObjectUsingBuilder(DirectPositionAdapter.class));
+			break;
+		case "distance":
+			object.setDistance(reader.getObjectUsingBuilder(LengthAdapter.class));
+			break;
+		default:
+			super.buildChildObject(object, name, attributes, reader);
+		}
+	}
+
+	@Override
+	public Element createElement(PlanarDistancePlaneError object, Namespaces namespaces)
+			throws ObjectSerializeException {
+		return Element.of(QualityADEModule.NAMESPACE_URI, "GE_P_NON_PLANAR_POLYGON_DISTANCE_PLANE");
+	}
+
+	@Override
+	public void writeChildElements(PlanarDistancePlaneError object, Namespaces namespaces, XMLWriter writer)
+			throws ObjectSerializeException, XMLWriteException {
+		super.writeChildElements(object, namespaces, writer);
+		if (object.getDistance() != null) {
+			writer.writeElementUsingSerializer(Element.of(QualityADEModule.NAMESPACE_URI, "distance"),
+					object.getDistance(), LengthAdapter.class, namespaces);
+		}
+		if (object.getVertex() != null) {
+			writer.writeElementUsingSerializer(Element.of(QualityADEModule.NAMESPACE_URI, "vertex"), object.getVertex(),
+					DirectPositionAdapter.class, namespaces);
+		}
+
+	}
+}

citygml4j-quality-ade/src/main/java/de/hft/stuttgart/quality/adapter/types/PlanarNormalsDeviationErrorAdapter.java

+package de.hft.stuttgart.quality.adapter.types;
+
+import javax.xml.namespace.QName;
+
+import org.xmlobjects.annotation.XMLElement;
+import org.xmlobjects.builder.ObjectBuildException;
+import org.xmlobjects.gml.adapter.measures.AngleAdapter;
+import org.xmlobjects.serializer.ObjectSerializeException;
+import org.xmlobjects.stream.XMLReadException;
+import org.xmlobjects.stream.XMLReader;
+import org.xmlobjects.stream.XMLWriteException;
+import org.xmlobjects.stream.XMLWriter;
+import org.xmlobjects.xml.Attributes;
+import org.xmlobjects.xml.Element;
+import org.xmlobjects.xml.Namespaces;
+
+import de.hft.stuttgart.quality.QualityADEModule;
+import de.hft.stuttgart.quality.model.types.PlanarNormalsDeviationError;
+
+@XMLElement(name = "GE_P_NON_PLANAR_POLYGON_NORMALS_DEVIATION", namespaceURI = QualityADEModule.NAMESPACE_URI)
+public class PlanarNormalsDeviationErrorAdapter extends AbstractPolygonErrorAdapter<PlanarNormalsDeviationError> {
+
+	@Override
+	public PlanarNormalsDeviationError createObject(QName name, Object parent) throws ObjectBuildException {
+		return new PlanarNormalsDeviationError();
+	}
+
+	@Override
+	public void buildChildObject(PlanarNormalsDeviationError object, QName name, Attributes attributes,
+			XMLReader reader) throws ObjectBuildException, XMLReadException {
+		if (!QualityADEModule.NAMESPACE_URI.equals(name.getNamespaceURI())) {
+			return;
+		}
+		switch (name.getLocalPart()) {
+		case "deviation":
+			object.setDeviation(reader.getObjectUsingBuilder(AngleAdapter.class));
+			break;
+		default:
+			super.buildChildObject(object, name, attributes, reader);
+		}
+	}
+
+	@Override
+	public Element createElement(PlanarNormalsDeviationError object, Namespaces namespaces)
+			throws ObjectSerializeException {
+		return Element.of(QualityADEModule.NAMESPACE_URI, "GE_P_NON_PLANAR_POLYGON_NORMALS_DEVIATION");
+	}
+
+	@Override
+	public void writeChildElements(PlanarNormalsDeviationError object, Namespaces namespaces, XMLWriter writer)
+			throws ObjectSerializeException, XMLWriteException {
+		super.writeChildElements(object, namespaces, writer);
+		if (object.getDeviation() != null) {
+			writer.writeElementUsingSerializer(Element.of(QualityADEModule.NAMESPACE_URI, "deviation"),
+					object.getDeviation(), AngleAdapter.class, namespaces);
+		}
+	}
+}

citygml4j-quality-ade/src/main/java/de/hft/stuttgart/quality/adapter/types/PolygonIdListAdapter.java

+package de.hft.stuttgart.quality.adapter.types;
+
+import de.hft.stuttgart.quality.model.types.PolygonIdList;
+
+import de.hft.stuttgart.quality.QualityADEModule;
+
+import org.xmlobjects.annotation.XMLElement;
+import org.xmlobjects.builder.ObjectBuildException;
+import org.xmlobjects.builder.ObjectBuilder;
+import org.xmlobjects.serializer.ObjectSerializeException;
+import org.xmlobjects.serializer.ObjectSerializer;
+import org.xmlobjects.stream.XMLReadException;
+import org.xmlobjects.stream.XMLReader;
+import org.xmlobjects.stream.XMLWriteException;
+import org.xmlobjects.stream.XMLWriter;
+import org.xmlobjects.xml.Attributes;
+import org.xmlobjects.xml.Element;
+import org.xmlobjects.xml.Namespaces;
+
+import javax.xml.namespace.QName;
+
+@XMLElement(name = "PolygonIdList", namespaceURI = QualityADEModule.NAMESPACE_URI)
+public class PolygonIdListAdapter implements ObjectBuilder<PolygonIdList>, ObjectSerializer<PolygonIdList> {
+
+	@Override
+	public PolygonIdList createObject(QName name, Object parent) throws ObjectBuildException {
+		return new PolygonIdList();
+	}
+
+	@Override
+	public void buildChildObject(PolygonIdList object, QName name, Attributes attributes, XMLReader reader)
+			throws ObjectBuildException, XMLReadException {
+		if (!QualityADEModule.NAMESPACE_URI.equals(name.getNamespaceURI())) {
+			return;
+		}
+		switch (name.getLocalPart()) {
+		case "polygonId":
+			object.getPolygonIds().add(reader.getTextContent().get());
+			break;
+		default:
+			throw new IllegalStateException("Cannot handle name " + name + " when building PolygonIdList element");
+		}
+	}
+
+	@Override
+	public Element createElement(PolygonIdList object, Namespaces namespaces) throws ObjectSerializeException {
+		return Element.of(QualityADEModule.NAMESPACE_URI, "PolygonIdList");
+	}
+
+	@Override
+	public void writeChildElements(PolygonIdList object, Namespaces namespaces, XMLWriter writer)
+			throws ObjectSerializeException, XMLWriteException {
+		for (String polygonId : object.getPolygonIds()) {
+			writer.writeElement(Element.of(QualityADEModule.NAMESPACE_URI, "polygonId").addTextContent(polygonId));
+		}
+	}
+}

citygml4j-quality-ade/src/main/java/de/hft/stuttgart/quality/adapter/types/PolygonWrongOrientationErrorAdapter.java

+package de.hft.stuttgart.quality.adapter.types;
+
+import javax.xml.namespace.QName;
+
+import org.xmlobjects.annotation.XMLElement;
+import org.xmlobjects.builder.ObjectBuildException;
+import org.xmlobjects.serializer.ObjectSerializeException;
+import org.xmlobjects.stream.XMLReadException;
+import org.xmlobjects.stream.XMLReader;
+import org.xmlobjects.stream.XMLWriteException;
+import org.xmlobjects.stream.XMLWriter;
+import org.xmlobjects.xml.Attributes;
+import org.xmlobjects.xml.Element;
+import org.xmlobjects.xml.Namespaces;
+
+import de.hft.stuttgart.quality.QualityADEModule;
+import de.hft.stuttgart.quality.adapter.properties.EdgeListPropertyAdapter;
+import de.hft.stuttgart.quality.model.types.PolygonWrongOrientationError;
+
+@XMLElement(name = "GE_S_POLYGON_WRONG_ORIENTATION", namespaceURI = QualityADEModule.NAMESPACE_URI)
+public class PolygonWrongOrientationErrorAdapter extends AbstractSolidErrorAdapter<PolygonWrongOrientationError> {
+
+	@Override
+	public PolygonWrongOrientationError createObject(QName name, Object parent) throws ObjectBuildException {
+		return new PolygonWrongOrientationError();
+	}
+
+	@Override
+	public void buildChildObject(PolygonWrongOrientationError object, QName name, Attributes attributes,
+			XMLReader reader) throws ObjectBuildException, XMLReadException {
+		if (!QualityADEModule.NAMESPACE_URI.equals(name.getNamespaceURI())) {
+			return;
+		}
+		switch (name.getLocalPart()) {
+		case "edges":
+			object.setEdges(reader.getObjectUsingBuilder(EdgeListPropertyAdapter.class));
+			break;
+		default:
+			super.buildChildObject(object, name, attributes, reader);
+		}
+	}
+
+	@Override
+	public Element createElement(PolygonWrongOrientationError object, Namespaces namespaces)
+			throws ObjectSerializeException {
+		return Element.of(QualityADEModule.NAMESPACE_URI, "GE_S_POLYGON_WRONG_ORIENTATION");
+	}
+
+	@Override
+	public void writeChildElements(PolygonWrongOrientationError object, Namespaces namespaces, XMLWriter writer)
+			throws ObjectSerializeException, XMLWriteException {
+		super.writeChildElements(object, namespaces, writer);
+		if (object.getEdges() != null) {
+			writer.writeElementUsingSerializer(Element.of(QualityADEModule.NAMESPACE_URI, "edges"), object.getEdges(),
+					EdgeListPropertyAdapter.class, namespaces);
+		}
+	}
+}

citygml4j-quality-ade/src/main/java/de/hft/stuttgart/quality/adapter/types/RequirementAdapter.java

+package de.hft.stuttgart.quality.adapter.types;
+
+import de.hft.stuttgart.quality.model.enums.RequirementId;
+import de.hft.stuttgart.quality.model.properties.ParameterProperty;
+import de.hft.stuttgart.quality.model.types.Requirement;
+
+import de.hft.stuttgart.quality.QualityADEModule;
+import de.hft.stuttgart.quality.adapter.properties.ParameterPropertyAdapter;
+
+import org.xmlobjects.annotation.XMLElement;
+import org.xmlobjects.builder.ObjectBuildException;
+import org.xmlobjects.builder.ObjectBuilder;
+import org.xmlobjects.serializer.ObjectSerializeException;
+import org.xmlobjects.serializer.ObjectSerializer;
+import org.xmlobjects.stream.XMLReadException;
+import org.xmlobjects.stream.XMLReader;
+import org.xmlobjects.stream.XMLWriteException;
+import org.xmlobjects.stream.XMLWriter;
+import org.xmlobjects.xml.Attributes;
+import org.xmlobjects.xml.Element;
+import org.xmlobjects.xml.Namespaces;
+
+import javax.xml.namespace.QName;
+
+@XMLElement(name = "Requirement", namespaceURI = QualityADEModule.NAMESPACE_URI)
+public class RequirementAdapter implements ObjectBuilder<Requirement>, ObjectSerializer<Requirement> {
+
+	@Override
+	public Requirement createObject(QName name, Object parent) throws ObjectBuildException {
+		return new Requirement();
+	}
+
+	@Override
+	public void buildChildObject(Requirement object, QName name, Attributes attributes, XMLReader reader)
+			throws ObjectBuildException, XMLReadException {
+		if (!QualityADEModule.NAMESPACE_URI.equals(name.getNamespaceURI())) {
+			return;
+		}
+		switch (name.getLocalPart()) {
+		case "enabled":
+			reader.getTextContent().ifPresent(s -> object.setEnabled(Boolean.parseBoolean(s)));
+			break;
+		case "requirementType":
+			object.setRequirementType(RequirementId.valueOf(reader.getTextContent().get()));
+			break;
+		case "parameter":
+			object.getParameters().add(reader.getObjectUsingBuilder(ParameterPropertyAdapter.class));
+			break;
+		default:
+			throw new IllegalStateException("Cannot handle name " + name + " when building Requirement element");
+		}
+	}
+
+	@Override
+	public Element createElement(Requirement object, Namespaces namespaces) throws ObjectSerializeException {
+		return Element.of(QualityADEModule.NAMESPACE_URI, "Requirement");
+	}
+
+	@Override
+	public void writeChildElements(Requirement object, Namespaces namespaces, XMLWriter writer)
+			throws ObjectSerializeException, XMLWriteException {
+		writer.writeElement(Element.of(QualityADEModule.NAMESPACE_URI, "enabled")
+				.addTextContent(Boolean.toString(object.isEnabled())));
+		if (object.getRequirementType() != null) {
+			writer.writeElement(Element.of(QualityADEModule.NAMESPACE_URI, "requirementType")
+					.addTextContent(object.getRequirementType().toString()));
+		}
+		for (ParameterProperty params : object.getParameters()) {
+			writer.writeElementUsingSerializer(Element.of(QualityADEModule.NAMESPACE_URI, "parameter"), params,
+					ParameterPropertyAdapter.class, namespaces);
+		}
+	}
+}

citygml4j-quality-ade/src/main/java/de/hft/stuttgart/quality/adapter/types/RingNotClosedErrorAdapter.java

+package de.hft.stuttgart.quality.adapter.types;
+
+import javax.xml.namespace.QName;
+
+import org.xmlobjects.annotation.XMLElement;
+import org.xmlobjects.builder.ObjectBuildException;
+import org.xmlobjects.serializer.ObjectSerializeException;
+import org.xmlobjects.xml.Element;
+import org.xmlobjects.xml.Namespaces;
+
+import de.hft.stuttgart.quality.QualityADEModule;
+import de.hft.stuttgart.quality.model.types.RingNotClosedError;
+
+@XMLElement(name = "GE_R_NOT_CLOSED", namespaceURI = QualityADEModule.NAMESPACE_URI)
+public class RingNotClosedErrorAdapter extends AbstractRingErrorAdapter<RingNotClosedError> {
+
+	@Override
+	public RingNotClosedError createObject(QName name, Object parent) throws ObjectBuildException {
+		return new RingNotClosedError();
+	}
+
+	@Override
+	public Element createElement(RingNotClosedError object, Namespaces namespaces) throws ObjectSerializeException {
+		return Element.of(QualityADEModule.NAMESPACE_URI, "GE_R_NOT_CLOSED");
+	}
+}

citygml4j-quality-ade/src/main/java/de/hft/stuttgart/quality/adapter/types/RingSelfIntersectionErrorAdapter.java

+package de.hft.stuttgart.quality.adapter.types;
+
+import javax.xml.namespace.QName;
+
+import org.xmlobjects.annotation.XMLElement;
+import org.xmlobjects.builder.ObjectBuildException;
+import org.xmlobjects.gml.adapter.geometry.DirectPositionAdapter;
+import org.xmlobjects.serializer.ObjectSerializeException;
+import org.xmlobjects.stream.XMLReadException;
+import org.xmlobjects.stream.XMLReader;
+import org.xmlobjects.stream.XMLWriteException;
+import org.xmlobjects.stream.XMLWriter;
+import org.xmlobjects.xml.Attributes;
+import org.xmlobjects.xml.Element;
+import org.xmlobjects.xml.Namespaces;
+
+import de.hft.stuttgart.quality.QualityADEModule;
+import de.hft.stuttgart.quality.adapter.properties.EdgePropertyAdapter;
+import de.hft.stuttgart.quality.model.enums.RingSelfIntType;
+import de.hft.stuttgart.quality.model.types.RingSelfIntersectionError;
+
+@XMLElement(name = "GE_R_SELF_INTERSECTION", namespaceURI = QualityADEModule.NAMESPACE_URI)
+public class RingSelfIntersectionErrorAdapter extends AbstractRingErrorAdapter<RingSelfIntersectionError> {
+
+	@Override
+	public RingSelfIntersectionError createObject(QName name, Object parent) throws ObjectBuildException {
+		return new RingSelfIntersectionError();
+	}
+
+	@Override
+	public void buildChildObject(RingSelfIntersectionError object, QName name, Attributes attributes, XMLReader reader)
+			throws ObjectBuildException, XMLReadException {
+		if (!QualityADEModule.NAMESPACE_URI.equals(name.getNamespaceURI())) {
+			return;
+		}
+		switch (name.getLocalPart()) {
+		case "type":
+			reader.getTextContent().ifPresent(s -> object.setType(RingSelfIntType.valueOf(s)));
+			break;
+		case "edge1":
+			object.setEdge1(reader.getObjectUsingBuilder(EdgePropertyAdapter.class));
+			break;
+		case "edge2":
+			object.setEdge2(reader.getObjectUsingBuilder(EdgePropertyAdapter.class));
+			break;
+		case "vertex1":
+			object.setVertex1(reader.getObjectUsingBuilder(DirectPositionAdapter.class));
+			break;
+		case "vertex2":
+			object.setVertex2(reader.getObjectUsingBuilder(DirectPositionAdapter.class));
+			break;
+		default:
+			super.buildChildObject(object, name, attributes, reader);
+		}
+	}
+
+	@Override
+	public Element createElement(RingSelfIntersectionError object, Namespaces namespaces)
+			throws ObjectSerializeException {
+		return Element.of(QualityADEModule.NAMESPACE_URI, "GE_R_SELF_INTERSECTION");
+	}
+
+	@Override
+	public void writeChildElements(RingSelfIntersectionError object, Namespaces namespaces, XMLWriter writer)
+			throws ObjectSerializeException, XMLWriteException {
+		super.writeChildElements(object, namespaces, writer);
+		if (object.getEdge1() != null) {
+			writer.writeElementUsingSerializer(Element.of(QualityADEModule.NAMESPACE_URI, "edge1"), object.getEdge1(),
+					EdgePropertyAdapter.class, namespaces);
+		}
+		if (object.getEdge2() != null) {
+			writer.writeElementUsingSerializer(Element.of(QualityADEModule.NAMESPACE_URI, "edge2"), object.getEdge2(),
+					EdgePropertyAdapter.class, namespaces);
+		}
+		if (object.getVertex1() != null) {
+			writer.writeElementUsingSerializer(Element.of(QualityADEModule.NAMESPACE_URI, "vertex1"),
+					object.getVertex1(), DirectPositionAdapter.class, namespaces);
+		}
+		if (object.getVertex2() != null) {
+			writer.writeElementUsingSerializer(Element.of(QualityADEModule.NAMESPACE_URI, "vertex2"),
+					object.getVertex2(), DirectPositionAdapter.class, namespaces);
+		}
+		if (object.getType() != null) {
+			writer.writeElement(
+					Element.of(QualityADEModule.NAMESPACE_URI, "type").addTextContent(object.getType().toString()));
+		}
+	}
+}

citygml4j-quality-ade/src/main/java/de/hft/stuttgart/quality/adapter/types/RingTooFewPointsErrorAdapter.java

+package de.hft.stuttgart.quality.adapter.types;
+
+import javax.xml.namespace.QName;
+
+import org.xmlobjects.annotation.XMLElement;
+import org.xmlobjects.builder.ObjectBuildException;
+import org.xmlobjects.serializer.ObjectSerializeException;
+import org.xmlobjects.xml.Element;
+import org.xmlobjects.xml.Namespaces;
+
+import de.hft.stuttgart.quality.QualityADEModule;
+import de.hft.stuttgart.quality.model.types.RingTooFewPointsError;
+
+@XMLElement(name = "GE_R_TOO_FEW_POINTS", namespaceURI = QualityADEModule.NAMESPACE_URI)
+public class RingTooFewPointsErrorAdapter extends AbstractRingErrorAdapter<RingTooFewPointsError> {
+
+	@Override
+	public RingTooFewPointsError createObject(QName name, Object parent) throws ObjectBuildException {
+		return new RingTooFewPointsError();
+	}
+
+	@Override
+	public Element createElement(RingTooFewPointsError object, Namespaces namespaces) throws ObjectSerializeException {
+		return Element.of(QualityADEModule.NAMESPACE_URI, "GE_R_TOO_FEW_POINTS");
+	}
+
+}

citygml4j-quality-ade/src/main/java/de/hft/stuttgart/quality/adapter/types/SemanticAttributeMissingErrorAdapter.java

+package de.hft.stuttgart.quality.adapter.types;
+
+import javax.xml.namespace.QName;
+
+import org.xmlobjects.annotation.XMLElement;
+import org.xmlobjects.builder.ObjectBuildException;
+import org.xmlobjects.serializer.ObjectSerializeException;
+import org.xmlobjects.stream.XMLReadException;
+import org.xmlobjects.stream.XMLReader;
+import org.xmlobjects.stream.XMLWriteException;
+import org.xmlobjects.stream.XMLWriter;
+import org.xmlobjects.xml.Attributes;
+import org.xmlobjects.xml.Element;
+import org.xmlobjects.xml.Namespaces;
+
+import de.hft.stuttgart.quality.QualityADEModule;
+import de.hft.stuttgart.quality.model.types.SemanticAttributeMissingError;
+
+@XMLElement(name = "SE_ATTRIBUTE_MISSING", namespaceURI = QualityADEModule.NAMESPACE_URI)
+public class SemanticAttributeMissingErrorAdapter extends AbstractSemanticErrorAdapter<SemanticAttributeMissingError> {
+
+	@Override
+	public SemanticAttributeMissingError createObject(QName name, Object parent) throws ObjectBuildException {
+		return new SemanticAttributeMissingError();
+	}
+
+	@Override
+	public void buildChildObject(SemanticAttributeMissingError object, QName name, Attributes attributes,
+			XMLReader reader) throws ObjectBuildException, XMLReadException {
+		if (!QualityADEModule.NAMESPACE_URI.equals(name.getNamespaceURI())) {
+			return;
+		}
+		switch (name.getLocalPart()) {
+		case "childId":
+			reader.getTextContent().ifPresent(object::setChildId);
+			break;
+		case "attributeName":
+			reader.getTextContent().ifPresent(object::setAttributeName);
+			break;
+		case "generic":
+			reader.getTextContent().ifPresent(s -> object.setGeneric(Boolean.parseBoolean(s)));
+			break;
+		default:
+			throw new IllegalStateException(
+					"Cannot handle name " + name + " when building SemanticAttributeMissingError element");
+		}
+	}
+
+	@Override
+	public Element createElement(SemanticAttributeMissingError object, Namespaces namespaces)
+			throws ObjectSerializeException {
+		return Element.of(QualityADEModule.NAMESPACE_URI, "SE_ATTRIBUTE_MISSING");
+	}
+
+	@Override
+	public void writeChildElements(SemanticAttributeMissingError object, Namespaces namespaces, XMLWriter writer)
+			throws ObjectSerializeException, XMLWriteException {
+		if (object.getChildId() != null) {
+			writer.writeElement(
+					Element.of(QualityADEModule.NAMESPACE_URI, "childId").addTextContent(object.getChildId()));
+		}
+		if (object.getAttributeName() != null) {
+			writer.writeElement(Element.of(QualityADEModule.NAMESPACE_URI, "attributeName")
+					.addTextContent(object.getAttributeName()));
+		}
+		writer.writeElement(Element.of(QualityADEModule.NAMESPACE_URI, "generic")
+				.addTextContent(Boolean.toString(object.isGeneric())));
+	}
+}