addeded citygml4j

.gitignore

+# Created by https://www.toptal.com/developers/gitignore/api/java,linux,windows,maven,git,eclipse
+# Edit at https://www.toptal.com/developers/gitignore?templates=java,linux,windows,maven,git,eclipse
+
+### Eclipse ###
+.metadata
+bin/
+tmp/
+*.tmp
+*.bak
+*.swp
+*~.nib
+local.properties
+.settings/
+.loadpath
+.recommenders
+
+# External tool builders
+.externalToolBuilders/
+
+# Locally stored "Eclipse launch configurations"
+*.launch
+
+# PyDev specific (Python IDE for Eclipse)
+*.pydevproject
+
+# CDT-specific (C/C++ Development Tooling)
+.cproject
+
+# CDT- autotools
+.autotools
+
+# Java annotation processor (APT)
+.factorypath
+
+# PDT-specific (PHP Development Tools)
+.buildpath
+
+# sbteclipse plugin
+.target
+
+# Tern plugin
+.tern-project
+
+# TeXlipse plugin
+.texlipse
+
+# STS (Spring Tool Suite)
+.springBeans
+
+# Code Recommenders
+.recommenders/
+
+# Annotation Processing
+.apt_generated/
+.apt_generated_test/
+
+# Scala IDE specific (Scala & Java development for Eclipse)
+.cache-main
+.scala_dependencies
+.worksheet
+
+# Uncomment this line if you wish to ignore the project description file.
+# Typically, this file would be tracked if it contains build/dependency configurations:
+#.project
+
+### Eclipse Patch ###
+# Spring Boot Tooling
+.sts4-cache/
+
+### Git ###
+# Created by git for backups. To disable backups in Git:
+# $ git config --global mergetool.keepBackup false
+*.orig
+
+# Created by git when using merge tools for conflicts
+*.BACKUP.*
+*.BASE.*
+*.LOCAL.*
+*.REMOTE.*
+*_BACKUP_*.txt
+*_BASE_*.txt
+*_LOCAL_*.txt
+*_REMOTE_*.txt
+
+### Java ###
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+### Linux ###
+*~
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+### Maven ###
+target/
+pom.xml.tag
+pom.xml.releaseBackup
+pom.xml.versionsBackup
+pom.xml.next
+release.properties
+dependency-reduced-pom.xml
+buildNumber.properties
+.mvn/timing.properties
+# https://github.com/takari/maven-wrapper#usage-without-binary-jar
+.mvn/wrapper/maven-wrapper.jar
+
+### Windows ###
+# Windows thumbnail cache files
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+
+# Dump file
+*.stackdump
+
+# Folder config file
+[Dd]esktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+# End of https://www.toptal.com/developers/gitignore/api/java,linux,windows,maven,git,eclipse

foodwaterenergycitygml4j/.classpath

+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" output="target/classes" path="src/main/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+			<attribute name="test" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+			<attribute name="test" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>

foodwaterenergycitygml4j/.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>foodwaterenergycitygml4j</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+	</natures>
+</projectDescription>

foodwaterenergycitygml4j/pom.xml

+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <groupId>de.hft.stuttgart.ade</groupId>
+  <artifactId>foodwaterenergycitygml4j</artifactId>
+  <version>0.0.1</version>
+  <packaging>jar</packaging>
+
+  <name>foodwaterenergycitygml4j</name>
+  <url>http://maven.apache.org</url>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <maven.compiler.source>1.8</maven.compiler.source>
+	<maven.compiler.target>1.8</maven.compiler.target>
+	<citygml4j.version>2.10.2</citygml4j.version>
+	<jakarta.xml.bind>2.3.2</jakarta.xml.bind>
+	<junit.jupiter.version>5.7.0</junit.jupiter.version>
+  </properties>
+
+  <dependencies>
+    <dependency>
+		<groupId>org.citygml4j</groupId>
+		<artifactId>citygml4j</artifactId>
+		<version>${citygml4j.version}</version>
+	</dependency>
+    <dependency>
+   		<groupId>jakarta.xml.bind</groupId>
+   		<artifactId>jakarta.xml.bind-api</artifactId>
+   		<version>${jakarta.xml.bind}</version>
+	</dependency>
+	<dependency>
+		<groupId>org.junit.jupiter</groupId>
+		<artifactId>junit-jupiter-api</artifactId>
+		<version>${junit.jupiter.version}</version>
+		<scope>test</scope>
+	</dependency>
+	<dependency>
+        <groupId>org.junit.jupiter</groupId>
+        <artifactId>junit-jupiter-engine</artifactId>
+        <version>${junit.jupiter.version}</version>
+		<scope>test</scope>
+    </dependency>
+  </dependencies>
+</project>

foodwaterenergycitygml4j/src/main/java/de/hft/stuttgart/ade/foodwaterenergycitygml4j/FoodWaterEnergyLandUseADEContext.java

+/*-
+ * Copyright 2021 Hochschule für Technik Stuttgart
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package de.hft.stuttgart.ade.foodwaterenergycitygml4j;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.citygml4j.model.citygml.ade.binding.ADEContext;
+import org.citygml4j.model.citygml.ade.binding.ADEMarshaller;
+import org.citygml4j.model.citygml.ade.binding.ADEUnmarshaller;
+import org.citygml4j.model.module.ade.ADEModule;
+
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.bind.FoodWaterEnergyLandUseADEMarshaller;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.bind.FoodWaterEnergyLandUseADEUnMarshaller;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.module.FoodWaterEnergyLandUseADEModule;
+
+
+public class FoodWaterEnergyLandUseADEContext implements ADEContext {
+	
+	private final List<ADEModule> modules = Collections.singletonList(FoodWaterEnergyLandUseADEModule.V0_1);
+
+
+	@Override
+	public List<ADEModule> getADEModules() {
+		return modules;
+	}
+
+	@Override
+	public List<String> getModelPackageNames() {
+		return Collections.singletonList("de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model");
+	}
+
+	@Override
+	public ADEMarshaller createADEMarshaller() {
+		return new FoodWaterEnergyLandUseADEMarshaller();
+	}
+
+	@Override
+	public ADEUnmarshaller createADEUnmarshaller() {
+		return new FoodWaterEnergyLandUseADEUnMarshaller();
+	}
+
+}

foodwaterenergycitygml4j/src/main/java/de/hft/stuttgart/ade/foodwaterenergycitygml4j/landuse/bind/FoodWaterEnergyLandUseADEMarshaller.java

+/*-
+ * Copyright 2021 Hochschule für Technik Stuttgart
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.bind;
+
+
+import javax.xml.bind.JAXBElement;
+
+import org.citygml4j.builder.jaxb.marshal.citygml.ade.ADEMarshallerHelper;
+import org.citygml4j.model.citygml.ade.binding.ADEMarshaller;
+import org.citygml4j.model.citygml.ade.binding.ADEModelObject;
+import org.citygml4j.util.mapper.TypeMapper;
+
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.ConsistsOfFWESurvey;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.EnergySurvey;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.FoodSurvey;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.FoodWaterEnergy;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.LandUseSurvey;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.WaterSurvey;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.xsd.ConsistsOfFWESurveyType;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.xsd.EnergySurveyType;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.xsd.FoodSurveyType;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.xsd.FoodWaterEnergyType;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.xsd.LandUseSurveyType;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.xsd.ObjectFactory;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.xsd.WaterSurveyType;
+
+
+public class FoodWaterEnergyLandUseADEMarshaller implements ADEMarshaller {
+	private final ObjectFactory factory = new ObjectFactory();
+	private final TypeMapper<JAXBElement<?>> elementMapper;
+	private final TypeMapper<Object> typeMapper;
+	private ADEMarshallerHelper helper;
+	
+	public FoodWaterEnergyLandUseADEMarshaller() {
+		elementMapper = TypeMapper.<JAXBElement<?>>create()
+				.with(FoodWaterEnergy.class, this::createFoodWaterEnergy)
+				.with(ConsistsOfFWESurvey.class, this::createConsistsOfFWESurvey)
+				.with(LandUseSurvey.class, this::createLandUseSurvey)
+				.with(FoodSurvey.class, this::createFoodSurvey)
+				.with(WaterSurvey.class, this::createWaterSurvey)
+				.with(EnergySurvey.class, this::createEnergySurvey);
+		
+		typeMapper = TypeMapper.create()
+				.with(FoodWaterEnergy.class, this::marshalFoodWaterEnergy)
+				.with(ConsistsOfFWESurvey.class, this::marshalConsistsOfFWESurvey)
+				.with(LandUseSurvey.class, this::marshalLandUseSurvey)
+				.with(FoodSurvey.class, this::marshalFoodSurvey)
+				.with(WaterSurvey.class, this::marshalWaterSurvey)
+				.with(EnergySurvey.class, this::marshalEnergySurvey);
+	}
+
+	@Override
+	public void setADEMarshallerHelper(ADEMarshallerHelper helper) {
+		this.helper = helper;
+	}
+
+	@Override
+	public JAXBElement<?> marshalJAXBElement(ADEModelObject src) {
+		return elementMapper.apply(src);
+	}
+
+	@Override
+	public Object marshal(ADEModelObject src) {
+		return typeMapper.apply(src);
+	}
+	
+	private JAXBElement<?> createFoodWaterEnergy(FoodWaterEnergy src) {
+		return factory.createFoodWaterEnergyType(marshalFoodWaterEnergy(src));
+	}
+	
+	private FoodWaterEnergyType marshalFoodWaterEnergy(FoodWaterEnergy src) {
+		FoodWaterEnergyType dest = new FoodWaterEnergyType();
+		/*
+		helper.getGMLMarshaller().marshalAbstractFeature(src, dest);
+		if(src.isSetId()) {
+			dest.setId(src.getId());
+		}
+		*/
+		if(src.isAreaName()) {
+			dest.setAreaName(src.getAreaName());
+		}
+		if(src.isSystemName()) {
+			dest.setSystemName(src.getSystemName());
+		}
+		if(src.isConsistsOfFWESurvey()) {
+			dest.setConsistsOfFWESurveyType(marshalConsistsOfFWESurvey(src.getConsistsOfFWESurvey()));;
+		}
+		
+		helper.getGMLMarshaller().marshalAbstractGML(src, dest);
+		return dest;
+	}
+	
+	private JAXBElement<?> createConsistsOfFWESurvey(ConsistsOfFWESurvey src) {
+		return factory.createFConsistsOfFWESurveyType(marshalConsistsOfFWESurvey(src));
+	}
+	
+	
+	private ConsistsOfFWESurveyType marshalConsistsOfFWESurvey(ConsistsOfFWESurvey src) {
+		ConsistsOfFWESurveyType dest = new ConsistsOfFWESurveyType();
+		/*
+		helper.getGMLMarshaller().marshalAbstractFeature(src, dest);
+		if(src.isSetId()) {
+			dest.setId(src.getId());
+		}
+		*/
+		if(src.isLandUseSurvey()) {
+			for(LandUseSurvey lus : src.getLandUseSurvey()) {
+				dest.getLandUseSurveyType().add(marshalLandUseSurvey(lus));
+			}
+		}
+		
+		helper.getGMLMarshaller().marshalAbstractGML(src, dest);
+		return dest;
+	}
+	
+	private JAXBElement<?> createLandUseSurvey(LandUseSurvey src) {
+		return factory.createLandUseSurveyType(marshalLandUseSurvey(src));
+	}
+	
+	private LandUseSurveyType marshalLandUseSurvey(LandUseSurvey src) {
+		LandUseSurveyType dest = new LandUseSurveyType();
+		/*
+		helper.getGMLMarshaller().marshalAbstractFeature(src, dest);
+		if(src.isSetId()) {
+			dest.setId(src.getId());
+		}
+		*/
+		if(src.isBuildingFootprintArea()) {
+			dest.setBuildingFootprintArea(helper.getGMLMarshaller().marshalArea(src.getBuildingFootprintArea()));
+		}
+		if(src.isPopulation()) {
+			dest.setPopulation(src.getPopulation());
+		}
+		if(src.isSurfaceArea()) {
+			dest.setSurfaceArea(helper.getGMLMarshaller().marshalArea(src.getSurfaceArea()));
+		}
+		if(src.isSurveyDescription()) {
+			dest.setSurveyDescription(src.getSurveyDescription());
+		}
+		if(src.isSurveyYear()) {
+			dest.setSurveyYear(src.getSurveyYear());
+		}
+		if(src.isSurveyYearVersion()) {
+			dest.setSurveyYearVersion(src.getSurveyYearVersion());
+		}
+		if(src.isFoodsurvey()) {
+			dest.setFoodSurveyType(marshalFoodSurvey(src.getFoodsurvey()));
+		}
+		if(src.isWatersurvey()) {
+			dest.setWaterSurveyType(marshalWaterSurvey(src.getWatersurvey()));
+		}
+		if(src.isEnergySurvey()) {
+			dest.setEnergySurveyType(marshalEnergySurvey(src.getEnergySurvey()));
+		}
+		
+		
+		helper.getGMLMarshaller().marshalAbstractGML(src, dest);
+		
+		return dest;
+	}
+	
+	private JAXBElement<?> createFoodSurvey(FoodSurvey src) {
+		return factory.createFoodSurveyType(marshalFoodSurvey(src));
+	}
+	
+	private FoodSurveyType marshalFoodSurvey(FoodSurvey src) {
+		FoodSurveyType dest = new FoodSurveyType();
+		/*
+		helper.getGMLMarshaller().marshalAbstractFeature(src, dest);
+		if(src.isSetId()) {
+			dest.setId(src.getId());
+		}
+		*/
+		if(src.isFoodCategory()) {
+			dest.setFoodCategory(helper.getGMLMarshaller().marshalCode(src.getFoodCategory()));
+		}
+		if(src.isFoodConsumption()) {
+			dest.setFoodConsumption(helper.getGMLMarshaller().marshalScale(src.getFoodConsumption()));
+		}
+		
+		if(src.isFoodDemand()) {
+			dest.setFoodDemand(helper.getGMLMarshaller().marshalScale(src.getFoodDemand()));
+		}
+		
+		if(src.isFoodProduction()) {
+			dest.setFoodProduction(helper.getGMLMarshaller().marshalScale(src.getFoodProduction()));
+		}
+		
+		if(src.isFoodProductionEnergyDemand()) {
+			dest.setFoodProductionEnergyDemand(helper.getGMLMarshaller().marshalScale(src.getFoodProductionEnergyDemand()));
+		}
+		
+		if(src.isFoodProductionWaterDemand()) {
+			dest.setFoodProductionWaterDemand(helper.getGMLMarshaller().marshalScale(src.getFoodProductionWaterDemand()));
+		}
+		
+		helper.getGMLMarshaller().marshalAbstractGML(src, dest);
+		return dest;		
+	}
+	
+	private JAXBElement<?> createWaterSurvey(WaterSurvey src) {
+		return factory.createWaterSurveyType(marshalWaterSurvey(src));
+	}
+	
+	private WaterSurveyType marshalWaterSurvey(WaterSurvey src) {
+		WaterSurveyType dest = new WaterSurveyType();
+		/*
+		helper.getGMLMarshaller().marshalAbstractFeature(src, dest);
+		if(src.isSetId()) {
+			dest.setId(src.getId());
+		}
+		*/
+		
+		if(src.isDomesticHotWaterDemand()) {
+			dest.setDomesticHotWaterDemand(helper.getGMLMarshaller().marshalScale(src.getDomesticHotWaterDemand()));
+		}
+		if(src.isDomesticHotWaterEnergyDemand()) {
+			dest.setDomesticHotWaterEnergyDemand(helper.getGMLMarshaller().marshalScale(src.getDomesticHotWaterEnergyDemand()));
+		}
+		if(src.isDomesticWaterDemand()) {
+			dest.setDomesticWaterDemand(helper.getGMLMarshaller().marshalScale(src.getDomesticWaterDemand()));
+		}
+		if(src.isDomesticSolidWaste()) {
+			dest.setDomesticSolidWaste(helper.getGMLMarshaller().marshalScale(src.getDomesticSolidWaste()));
+		}
+		if(src.isDomesticWaterWaste()) {
+			dest.setDomesticWaterWaste(helper.getGMLMarshaller().marshalScale(src.getDomesticWaterWaste()));
+		}
+		if(src.isTotalDomesticWaste()) {
+			dest.setTotalDomesticWaste(helper.getGMLMarshaller().marshalScale(src.getTotalDomesticWaste()));
+		}
+		
+		helper.getGMLMarshaller().marshalAbstractGML(src, dest);
+		
+		return dest;
+	}
+
+
+	private JAXBElement<?> createEnergySurvey(EnergySurvey src) {
+		return factory.createEnergySurveyType(marshalEnergySurvey(src));
+	}
+	
+	private EnergySurveyType marshalEnergySurvey(EnergySurvey src) {
+		EnergySurveyType dest = new EnergySurveyType();
+		/*
+		helper.getGMLMarshaller().marshalAbstractFeature(src, dest);
+		if(src.isSetId()) {
+			dest.setId(src.getId());
+		}
+		*/
+		
+	
+		if(src.isBiomassPrimaryEnergyPotential()) {
+			dest.setBiomassPrimaryEnergyPotential(helper.getGMLMarshaller().marshalScale(src.getBiomassPrimaryEnergyPotential()));
+		}
+		if(src.isBiomassToBioethanol()) {
+			dest.setBiomassToBioethanol(helper.getGMLMarshaller().marshalScale(src.getBiomassToBioethanol()));
+		}
+		if(src.isBiomassToBiogas()) {
+			dest.setBiomassToBiogas(helper.getGMLMarshaller().marshalScale(src.getBiomassToBiogas()));
+		}
+		if(src.isBiomassToElectricityPotential()) {
+			dest.setBiomassToElectricityPotential(helper.getGMLMarshaller().marshalScale(src.getBiomassToElectricityPotential()));
+		}
+		if(src.isBiomassToEnergyWoods()) {
+			dest.setBiomassToEnergyWoods(helper.getGMLMarshaller().marshalScale(src.getBiomassToEnergyWoods()));
+		}
+		if(src.isBiomassToPlantOil()) {
+			dest.setBiomassToPlantOil(helper.getGMLMarshaller().marshalScale(src.getBiomassToPlantOil()));
+		}
+		if(src.isBiomassToResidualSolidFuel()) {
+			dest.setBiomassToResidualSolidFuel(helper.getGMLMarshaller().marshalScale(src.getBiomassToResidualSolidFuel()));
+		}
+		if(src.isBiomassToSolidFuel()) {
+			dest.setBiomassToSolidFuel(helper.getGMLMarshaller().marshalScale(src.getBiomassToSolidFuel()));
+		}
+		if(src.isBiomassToThermalPotential()) {
+			dest.setBiomassToThermalPotential(helper.getGMLMarshaller().marshalScale(src.getBiomassToThermalPotential()));
+		}
+		if(src.isSpaceCoolingDemand()) {
+			dest.setSpaceCoolingDemand(helper.getGMLMarshaller().marshalScale(src.getSpaceCoolingDemand()));
+		}
+		if(src.isSpaceHeatingDemand()) {
+			dest.setSpaceHeatingDemand(helper.getGMLMarshaller().marshalScale(src.getSpaceHeatingDemand()));
+		}
+		if(src.isElectricityPotentialFromPVBuildings()) {
+			dest.setElectricityPotentialFromPVBuildings(helper.getGMLMarshaller().marshalScale(src.getElectricityPotentialFromPVBuildings()));
+		}
+		if(src.isResidentialElectricityDemand()) {
+			dest.setResidentialElectricityDemand(helper.getGMLMarshaller().marshalScale(src.getResidentialElectricityDemand()));
+		}
+		if(src.isVegetationCoverCategory()) {
+			dest.setVegetationCoverCategory(helper.getGMLMarshaller().marshalCode(src.getVegetationCoverCategory()));
+		}
+		
+		helper.getGMLMarshaller().marshalAbstractGML(src, dest);
+		
+		return dest;
+	}
+	
+	
+}
+
+

foodwaterenergycitygml4j/src/main/java/de/hft/stuttgart/ade/foodwaterenergycitygml4j/landuse/bind/FoodWaterEnergyLandUseADEUnMarshaller.java

+/*-
+ * Copyright 2021 Hochschule für Technik Stuttgart
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.bind;
+
+
+import javax.xml.bind.JAXBElement;
+
+import org.citygml4j.builder.jaxb.unmarshal.citygml.ade.ADEUnmarshallerHelper;
+import org.citygml4j.model.citygml.ade.binding.ADEModelObject;
+import org.citygml4j.model.citygml.ade.binding.ADEUnmarshaller;
+import org.citygml4j.util.mapper.CheckedTypeMapper;
+import org.citygml4j.xml.io.reader.MissingADESchemaException;
+
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.ConsistsOfFWESurvey;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.EnergySurvey;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.FoodSurvey;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.FoodWaterEnergy;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.LandUseSurvey;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.WaterSurvey;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.xsd.ConsistsOfFWESurveyType;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.xsd.EnergySurveyType;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.xsd.FoodSurveyType;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.xsd.FoodWaterEnergyType;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.xsd.LandUseSurveyType;
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.xsd.WaterSurveyType;
+
+public class FoodWaterEnergyLandUseADEUnMarshaller implements ADEUnmarshaller {	
+	private final CheckedTypeMapper<ADEModelObject> typeMapper;
+	private ADEUnmarshallerHelper helper;
+	
+	public FoodWaterEnergyLandUseADEUnMarshaller() {
+		typeMapper = CheckedTypeMapper.<ADEModelObject>create()
+				.with(FoodWaterEnergyType.class, this::unmarshalFoodWaterEnergyType)
+				.with(ConsistsOfFWESurveyType.class, this::unmarshalConsistsOfFWESurveyType)
+				.with(LandUseSurveyType.class, this::unmarshalLandUseSurveyType)
+				.with(FoodSurveyType.class, this::unmarshalFoodSurveyType)
+				.with(WaterSurveyType.class, this::unmarshalWaterSurveyType)
+				.with(EnergySurveyType.class, this::unmarshalEnergySurveyType);
+	}
+	
+	private FoodWaterEnergy unmarshalFoodWaterEnergyType(FoodWaterEnergyType src) throws MissingADESchemaException {
+		FoodWaterEnergy dest = new FoodWaterEnergy();
+		/*
+		if(src.isSetId()) {
+			dest.setId(src.getId());
+		}
+		*/
+		if(src.getAreaName() != null) {
+			dest.setAreaName(src.getAreaName());
+		}
+		if(src.getAreaName() != null) {
+			dest.setSystemName(src.getSystemName());
+		}
+		if(src.getConsistsOfFWESurveyType() != null) {
+			dest.setConsistsOfFWESurvey(unmarshalConsistsOfFWESurveyType(src.getConsistsOfFWESurveyType()));	
+		}
+	
+		helper.getGMLUnmarshaller().unmarshalAbstractGML(src, dest);
+		return dest;
+	}
+	
+	private ConsistsOfFWESurvey unmarshalConsistsOfFWESurveyType(ConsistsOfFWESurveyType src) throws MissingADESchemaException {
+		ConsistsOfFWESurvey dest = new ConsistsOfFWESurvey();
+		/*
+		if(src.isSetId()) {
+			dest.setId(src.getId());
+		}
+		*/
+		if(src.getLandUseSurveyType() !=null) {
+			for(LandUseSurveyType lust : src.getLandUseSurveyType()) {
+				dest.getLandUseSurvey().add(unmarshalLandUseSurveyType(lust));
+			}	
+		}
+		
+		helper.getGMLUnmarshaller().unmarshalAbstractGML(src, dest);
+		return dest;
+	}
+	
+	private LandUseSurvey unmarshalLandUseSurveyType(LandUseSurveyType src) throws MissingADESchemaException {
+		LandUseSurvey dest = new LandUseSurvey();
+		/*
+		if(src.isSetId()) {
+			dest.setId(src.getId());
+		}
+		*/
+		if(src.getBuildingFootprintArea() != null) {
+			dest.setBuildingFootprintArea(helper.getGMLUnmarshaller().unmarshalArea(src.getBuildingFootprintArea()));
+		}
+		if(src.getPopulation() != null) {
+			dest.setPopulation(src.getPopulation());
+		}
+		if(src.getSurfaceArea() != null) {
+			dest.setSurfaceArea(helper.getGMLUnmarshaller().unmarshalArea(src.getSurfaceArea()));
+		}
+		if(src.getSurveyDescription()!=null) {
+			dest.setSurveyDescription(src.getSurveyDescription());	
+		}
+		if(src.getSurveyYear()!=null) {
+			dest.setSurveyYear(src.getSurveyYear());
+		}
+		if(src.getSurveyYearVersion()!=null) {
+			dest.setSurveyYearVersion(src.getSurveyYearVersion());	
+		}
+		if(src.getFoodSurveyType() != null) {
+			dest.setFoodsurvey(unmarshalFoodSurveyType(src.getFoodSurveyType()));	
+		}
+		if(src.getWaterSurveyType() !=null) {
+			dest.setWatersurvey(unmarshalWaterSurveyType(src.getWaterSurveyType()));	
+		}
+		if(src.getEnergySurveyType() !=null) {
+			dest.setEnergySurvey(unmarshalEnergySurveyType(src.getEnergySurveyType()));	
+		}
+		
+		helper.getGMLUnmarshaller().unmarshalAbstractGML(src, dest);
+		return dest;
+	}
+	
+	private FoodSurvey unmarshalFoodSurveyType(FoodSurveyType src) throws MissingADESchemaException {
+		FoodSurvey dest = new FoodSurvey();
+		/*
+		if(src.isSetId()) {
+			dest.setId(src.getId());
+		}
+		*/
+		if(src.getFoodCategory()!=null) {
+			dest.setFoodCategory(helper.getGMLUnmarshaller().unmarshalCode(src.getFoodCategory()));
+		}
+		if(src.getFoodConsumption()!=null) {
+			dest.setFoodConsumption(helper.getGMLUnmarshaller().unmarshalScale(src.getFoodConsumption()));
+		}
+		if(src.getFoodDemand()!=null) {
+			dest.setFoodDemand(helper.getGMLUnmarshaller().unmarshalScale(src.getFoodDemand()));
+		}
+		if(src.getFoodProduction()!=null) {
+			dest.setFoodProduction(helper.getGMLUnmarshaller().unmarshalScale(src.getFoodProduction()));	
+		}
+		if(src.getFoodProductionEnergyDemand()!=null) {
+			dest.setFoodProductionEnergyDemand(helper.getGMLUnmarshaller().unmarshalScale(src.getFoodProductionEnergyDemand()));
+		}
+		if(src.getFoodProductionWaterDemand()!=null) {
+			dest.setFoodProductionWaterDemand(helper.getGMLUnmarshaller().unmarshalScale(src.getFoodProductionWaterDemand()));
+		}
+		
+		helper.getGMLUnmarshaller().unmarshalAbstractGML(src, dest);
+		return dest;
+	}
+	
+	private WaterSurvey unmarshalWaterSurveyType(WaterSurveyType src) throws MissingADESchemaException {
+		WaterSurvey dest = new WaterSurvey();
+		/*
+		if(src.isSetId()) {
+			dest.setId(src.getId());
+		}
+		*/
+		if(src.getDomesticHotWaterDemand()!=null) {
+			dest.setDomesticHotWaterDemand(helper.getGMLUnmarshaller().unmarshalScale(src.getDomesticHotWaterDemand()));	
+		}
+		if(src.getDomesticHotWaterEnergyDemand()!=null) {
+			dest.setDomesticHotWaterEnergyDemand(helper.getGMLUnmarshaller().unmarshalScale(src.getDomesticHotWaterEnergyDemand()));	
+		}
+		if(src.getDomesticSolidWaste()!=null) {
+			dest.setDomesticSolidWaste(helper.getGMLUnmarshaller().unmarshalScale(src.getDomesticSolidWaste()));	
+		}
+		if(src.getDomesticWaterDemand()!=null) {
+			dest.setDomesticWaterDemand(helper.getGMLUnmarshaller().unmarshalScale(src.getDomesticWaterDemand()));	
+		}
+		if(src.getDomesticWaterWaste()!=null) {
+			dest.setDomesticWaterWaste(helper.getGMLUnmarshaller().unmarshalScale(src.getDomesticWaterWaste()));	
+		}
+		if(src.getTotalDomesticWaste()!=null) {
+			dest.setTotalDomesticWaste(helper.getGMLUnmarshaller().unmarshalScale(src.getTotalDomesticWaste()));	
+		}
+		
+		
+		helper.getGMLUnmarshaller().unmarshalAbstractGML(src, dest);
+		return dest;
+	}
+	
+	private EnergySurvey unmarshalEnergySurveyType(EnergySurveyType src) throws MissingADESchemaException {
+		EnergySurvey dest = new EnergySurvey();
+		/*
+		if(src.isSetId()) {
+			dest.setId(src.getId());
+		}
+		*/
+		if(src.getBiomassPrimaryEnergyPotential()!=null) {
+			dest.setBiomassPrimaryEnergyPotential(helper.getGMLUnmarshaller().unmarshalScale(src.getBiomassPrimaryEnergyPotential()));	
+		}
+		if(src.getBiomassToBioethanol()!=null) {
+			dest.setBiomassToBioethanol(helper.getGMLUnmarshaller().unmarshalScale(src.getBiomassToBioethanol()));	
+		}
+		if(src.getBiomassToBiogas()!=null) {
+			dest.setBiomassToBiogas(helper.getGMLUnmarshaller().unmarshalScale(src.getBiomassToBiogas()));	
+		}
+		if(src.getBiomassToElectricityPotential()!=null) {
+			dest.setBiomassToElectricityPotential(helper.getGMLUnmarshaller().unmarshalScale(src.getBiomassToElectricityPotential()));	
+		}
+		if(src.getBiomassToEnergyWoods() != null) {
+			dest.setBiomassToEnergyWoods(helper.getGMLUnmarshaller().unmarshalScale(src.getBiomassToEnergyWoods()));	
+		}
+		if(src.getBiomassToPlantOil()!=null) {
+			dest.setBiomassToPlantOil(helper.getGMLUnmarshaller().unmarshalScale(src.getBiomassToPlantOil()));
+		}
+		if(src.getBiomassToResidualSolidFuel()!=null) {
+			dest.setBiomassToResidualSolidFuel(helper.getGMLUnmarshaller().unmarshalScale(src.getBiomassToResidualSolidFuel()));
+		}
+		if(src.getBiomassToSolidFuel()!=null) {
+			dest.setBiomassToSolidFuel(helper.getGMLUnmarshaller().unmarshalScale(src.getBiomassToSolidFuel()));
+		}
+		if(src.getBiomassToThermalPotential()!=null) {
+			dest.setBiomassToThermalPotential(helper.getGMLUnmarshaller().unmarshalScale(src.getBiomassToThermalPotential()));
+		}
+		if(src.getElectricityPotentialFromPVBuildings()!=null) {
+			dest.setElectricityPotentialFromPVBuildings(helper.getGMLUnmarshaller().unmarshalScale(src.getElectricityPotentialFromPVBuildings()));
+		}
+		if(src.getResidentialElectricityDemand()!=null) {
+			dest.setResidentialElectricityDemand(helper.getGMLUnmarshaller().unmarshalScale(src.getResidentialElectricityDemand()));
+		}
+		if(src.getSpaceCoolingDemand()!=null) {
+			dest.setSpaceCoolingDemand(helper.getGMLUnmarshaller().unmarshalScale(src.getSpaceCoolingDemand()));
+		}
+		if(src.getSpaceCoolingDemand()!=null) {
+			dest.setSpaceCoolingDemand(helper.getGMLUnmarshaller().unmarshalScale(src.getSpaceCoolingDemand()));
+		}
+		if(src.getSpaceCoolingDemand()!=null) {
+			dest.setSpaceCoolingDemand(helper.getGMLUnmarshaller().unmarshalScale(src.getSpaceCoolingDemand()));
+		}
+		if(src.getSpaceCoolingDemand()!=null) {
+			dest.setSpaceCoolingDemand(helper.getGMLUnmarshaller().unmarshalScale(src.getSpaceCoolingDemand()));
+		}
+		if(src.getSpaceHeatingDemand()!=null) {
+			dest.setSpaceHeatingDemand(helper.getGMLUnmarshaller().unmarshalScale(src.getSpaceHeatingDemand()));
+		}
+		if(src.getResidentialElectricityDemand()!=null) {
+			dest.setResidentialElectricityDemand(helper.getGMLUnmarshaller().unmarshalScale(src.getResidentialElectricityDemand()));
+		}
+		
+		if(src.getVegetationCoverCategory()!=null) {
+			dest.setVegetationCoverCategory(helper.getGMLUnmarshaller().unmarshalCode(src.getVegetationCoverCategory()));
+		}
+		
+		helper.getGMLUnmarshaller().unmarshalAbstractGML(src, dest);	
+		return dest;
+	}
+	
+	@Override
+	public void setADEUnmarshallerHelper(ADEUnmarshallerHelper helper) {
+		this.helper = helper;
+	}
+
+	@Override
+	public ADEModelObject unmarshal(JAXBElement<?> src) throws MissingADESchemaException {
+		final Object value = src.getValue();
+		
+		return unmarshal(value);
+	}
+
+	@Override
+	public ADEModelObject unmarshal(Object src) throws MissingADESchemaException {
+		return typeMapper.apply(src);
+	}
+	
+
+}

foodwaterenergycitygml4j/src/main/java/de/hft/stuttgart/ade/foodwaterenergycitygml4j/landuse/model/ConsistsOfFWESurvey.java

+/*-
+ * Copyright 2021 Hochschule für Technik Stuttgart
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model;
+
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.citygml4j.builder.copy.CopyBuilder;
+import org.citygml4j.model.citygml.ade.binding.ADEModelObject;
+import org.citygml4j.model.common.visitor.FeatureFunctor;
+import org.citygml4j.model.common.visitor.FeatureVisitor;
+import org.citygml4j.model.common.visitor.GMLFunctor;
+import org.citygml4j.model.common.visitor.GMLVisitor;
+import org.citygml4j.model.gml.feature.AbstractFeature;
+
+
+
+public class ConsistsOfFWESurvey extends AbstractFeature implements ADEModelObject{
+	
+	private static final long serialVersionUID = 5976037320544049731L;
+	
+	private List<LandUseSurvey> landUseSurvey;
+	
+	public List<LandUseSurvey> getLandUseSurvey() {
+		if(landUseSurvey == null) {
+			landUseSurvey = new ArrayList<>();
+		}
+		return landUseSurvey;
+	}
+	
+	public boolean isLandUseSurvey() {
+		return landUseSurvey != null;
+	}
+	public void setLandUseSurvey(List<LandUseSurvey> landUseSurvey) {
+		this.landUseSurvey = landUseSurvey;
+	}
+
+	@Override
+	public Object copy(CopyBuilder copyBuilder) {
+		return copyTo(new ConsistsOfFWESurvey(),copyBuilder);
+	}
+
+	@Override
+	public void accept(FeatureVisitor visitor) {
+		visitor.visit((ADEModelObject)this);
+	}
+
+	@Override
+	public <T> T accept(FeatureFunctor<T> visitor) {
+		return visitor.apply((ADEModelObject)this);
+	}
+
+	@Override
+	public void accept(GMLVisitor visitor) {
+		visitor.visit((ADEModelObject)this);
+		
+	}
+
+	@Override
+	public <T> T accept(GMLFunctor<T> visitor) {
+		return visitor.apply((ADEModelObject)this);
+	}	
+
+	
+}

foodwaterenergycitygml4j/src/main/java/de/hft/stuttgart/ade/foodwaterenergycitygml4j/landuse/model/EnergySurvey.java

+/*-
+ * Copyright 2021 Hochschule für Technik Stuttgart
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model;
+
+
+import org.citygml4j.builder.copy.CopyBuilder;
+import org.citygml4j.model.citygml.ade.binding.ADEModelObject;
+import org.citygml4j.model.common.visitor.FeatureFunctor;
+import org.citygml4j.model.common.visitor.FeatureVisitor;
+import org.citygml4j.model.common.visitor.GMLFunctor;
+import org.citygml4j.model.common.visitor.GMLVisitor;
+import org.citygml4j.model.gml.basicTypes.Code;
+import org.citygml4j.model.gml.feature.AbstractFeature;
+import org.citygml4j.model.gml.measures.Scale;
+
+
+
+public class EnergySurvey extends AbstractFeature implements ADEModelObject{
+	
+	private static final long serialVersionUID = -7095068766106216686L;
+	private Scale spaceHeatingDemand;
+	private Scale spaceCoolingDemand;
+	private Scale residentialElectricityDemand;
+	private Scale electricityPotentialFromPVBuildings;
+	private Scale biomassPrimaryEnergyPotential;
+	private Scale biomassToEnergyWoods;
+	private Scale biomassToBiogas;
+	private Scale biomassToPlantOil;
+	private Scale biomassToBioethanol;
+	private Scale biomassToResidualSolidFuel;
+	private Scale biomassToSolidFuel;
+	private Scale biomassToElectricityPotential;
+	private Scale biomassToThermalPotential;
+	private Code vegetationCoverCategory;
+	
+	
+	public Scale getSpaceHeatingDemand() {
+		return spaceHeatingDemand;
+	}
+	
+	
+	public boolean isSpaceHeatingDemand() {
+		return spaceHeatingDemand != null;
+	}
+
+	public void setSpaceHeatingDemand(Scale spaceHeatingDemand) {
+		this.spaceHeatingDemand = spaceHeatingDemand;
+	}
+
+	public Scale getSpaceCoolingDemand() {
+		return spaceCoolingDemand;
+	}
+	
+
+	public boolean isSpaceCoolingDemand() {
+		return spaceCoolingDemand!=null;
+	}
+
+	public void setSpaceCoolingDemand(Scale spaceCoolingDemand) {
+		this.spaceCoolingDemand = spaceCoolingDemand;
+	}
+
+	public Scale getResidentialElectricityDemand() {
+		return residentialElectricityDemand;
+	}
+	
+	public boolean isResidentialElectricityDemand() {
+		return residentialElectricityDemand != null;
+	}
+
+	public void setResidentialElectricityDemand(Scale residentialElectricityDemand) {
+		this.residentialElectricityDemand = residentialElectricityDemand;
+	}
+
+	public Scale getElectricityPotentialFromPVBuildings() {
+		return electricityPotentialFromPVBuildings;
+	}
+	
+
+	public boolean isElectricityPotentialFromPVBuildings() {
+		return electricityPotentialFromPVBuildings!=null;
+	}
+
+	public void setElectricityPotentialFromPVBuildings(Scale electricityPotentialFromPVBuildings) {
+		this.electricityPotentialFromPVBuildings = electricityPotentialFromPVBuildings;
+	}
+
+	public Code getVegetationCoverCategory() {
+		return vegetationCoverCategory;
+	}
+	
+
+	public boolean isVegetationCoverCategory() {
+		return vegetationCoverCategory != null;
+	}
+
+	public void setVegetationCoverCategory(Code vegetationCoverCategory) {
+		this.vegetationCoverCategory = vegetationCoverCategory;
+	}
+
+	public Scale getBiomassPrimaryEnergyPotential() {
+		return biomassPrimaryEnergyPotential;
+	}
+	
+	public boolean isBiomassPrimaryEnergyPotential() {
+		return biomassPrimaryEnergyPotential != null;
+	}
+
+	public void setBiomassPrimaryEnergyPotential(Scale biomassPrimaryEnergyPotential) {
+		this.biomassPrimaryEnergyPotential = biomassPrimaryEnergyPotential;
+	}
+
+	public Scale getBiomassToEnergyWoods() {
+		return biomassToEnergyWoods;
+	}
+	
+
+	public boolean isBiomassToEnergyWoods() {
+		return biomassToEnergyWoods !=null;
+	}
+
+	public void setBiomassToEnergyWoods(Scale biomassToEnergyWoods) {
+		this.biomassToEnergyWoods = biomassToEnergyWoods;
+	}
+
+	public Scale getBiomassToBiogas() {
+		return biomassToBiogas;
+	}
+	
+
+	public boolean isBiomassToBiogas() {
+		return biomassToBiogas != null;
+	}
+
+	public void setBiomassToBiogas(Scale biomassToBiogas) {
+		this.biomassToBiogas = biomassToBiogas;
+	}
+
+	public Scale getBiomassToPlantOil() {
+		return biomassToPlantOil;
+	}
+	
+
+	public boolean isBiomassToPlantOil() {
+		return biomassToPlantOil != null;
+	}
+
+
+	public void setBiomassToPlantOil(Scale biomassToPlantOil) {
+		this.biomassToPlantOil = biomassToPlantOil;
+	}
+
+	public Scale getBiomassToBioethanol() {
+		return biomassToBioethanol;
+	}
+	
+
+	public boolean isBiomassToBioethanol() {
+		return biomassToBioethanol != null;
+	}
+
+	public void setBiomassToBioethanol(Scale biomassToBioethanol) {
+		this.biomassToBioethanol = biomassToBioethanol;
+	}
+
+	public Scale getBiomassToResidualSolidFuel() {
+		return biomassToResidualSolidFuel;
+	}
+	
+
+	public boolean isBiomassToResidualSolidFuel() {
+		return biomassToResidualSolidFuel!=null;
+	}
+
+	public void setBiomassToResidualSolidFuel(Scale biomassToResidualSolidFuel) {
+		this.biomassToResidualSolidFuel = biomassToResidualSolidFuel;
+	}
+
+	public Scale getBiomassToSolidFuel() {
+		return biomassToSolidFuel;
+	}
+	
+
+	public boolean isBiomassToSolidFuel() {
+		return biomassToSolidFuel !=null;
+	}
+
+	public void setBiomassToSolidFuel(Scale biomassToSolidFuel) {
+		this.biomassToSolidFuel = biomassToSolidFuel;
+	}
+
+	public Scale getBiomassToElectricityPotential() {
+		return biomassToElectricityPotential;
+	}
+	
+
+	public boolean isBiomassToElectricityPotential() {
+		return biomassToElectricityPotential !=null;
+	}
+
+	public void setBiomassToElectricityPotential(Scale biomassToElectricityPotential) {
+		this.biomassToElectricityPotential = biomassToElectricityPotential;
+	}
+
+	public Scale getBiomassToThermalPotential() {
+		return biomassToThermalPotential;
+	}
+	
+
+	public boolean isBiomassToThermalPotential() {
+		return biomassToThermalPotential != null;
+	}
+
+	public void setBiomassToThermalPotential(Scale biomassToThermalPotential) {
+		this.biomassToThermalPotential = biomassToThermalPotential;
+	}
+
+	@Override
+	public Object copy(CopyBuilder copyBuilder) {
+		return copyTo(new EnergySurvey(),copyBuilder);
+	}
+
+	@Override
+	public void accept(FeatureVisitor visitor) {
+		visitor.visit((ADEModelObject)this);
+	}
+
+	@Override
+	public <T> T accept(FeatureFunctor<T> visitor) {
+		return visitor.apply((ADEModelObject)this);
+	}
+
+	@Override
+	public void accept(GMLVisitor visitor) {
+		visitor.visit((ADEModelObject)this);
+		
+	}
+
+	@Override
+	public <T> T accept(GMLFunctor<T> visitor) {
+		return visitor.apply((ADEModelObject)this);
+	}	
+	
+}

foodwaterenergycitygml4j/src/main/java/de/hft/stuttgart/ade/foodwaterenergycitygml4j/landuse/model/FoodSurvey.java

+/*-
+ * Copyright 2021 Hochschule für Technik Stuttgart
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model;
+
+
+
+import org.citygml4j.builder.copy.CopyBuilder;
+import org.citygml4j.model.citygml.ade.binding.ADEModelObject;
+import org.citygml4j.model.common.visitor.FeatureFunctor;
+import org.citygml4j.model.common.visitor.FeatureVisitor;
+import org.citygml4j.model.common.visitor.GMLFunctor;
+import org.citygml4j.model.common.visitor.GMLVisitor;
+import org.citygml4j.model.gml.basicTypes.Code;
+import org.citygml4j.model.gml.feature.AbstractFeature;
+import org.citygml4j.model.gml.measures.Scale;
+
+
+public class FoodSurvey extends AbstractFeature implements ADEModelObject{
+		
+	
+	private static final long serialVersionUID = 6757445678768677685L;
+	
+	private Code foodCategory;
+	private Scale foodDemand;
+	private Scale foodProduction;
+	private Scale foodProductionWaterDemand;
+	private Scale foodProductionEnergyDemand;
+	private Scale foodConsumption;
+	
+	
+	
+	
+	public Code getFoodCategory() {
+		return foodCategory;
+	}
+	public boolean isFoodCategory() {
+		return foodCategory != null;
+	}
+	public void setFoodCategory(Code foodCategory) {
+		this.foodCategory = foodCategory;
+	}
+	
+	public Scale getFoodDemand() {
+		return foodDemand;
+	}
+	
+
+	public boolean isFoodDemand() {
+		return foodDemand!=null;
+	}
+	public void setFoodDemand(Scale foodDemand) {
+		this.foodDemand = foodDemand;
+	}
+	public Scale getFoodProduction() {
+		return foodProduction;
+	}
+	public boolean isFoodProduction() {
+		return foodProduction != null;
+	}
+	public void setFoodProduction(Scale foodProduction) {
+		this.foodProduction = foodProduction;
+	}
+	public Scale getFoodProductionWaterDemand() {
+		return foodProductionWaterDemand;
+	}
+	public boolean isFoodProductionWaterDemand() {
+		return foodProductionWaterDemand!=null;
+	}
+	public void setFoodProductionWaterDemand(Scale foodProductionWaterDemand) {
+		this.foodProductionWaterDemand = foodProductionWaterDemand;
+	}
+	public Scale getFoodProductionEnergyDemand() {
+		return foodProductionEnergyDemand;
+	}
+	public boolean isFoodProductionEnergyDemand() {
+		return foodProductionEnergyDemand!=null;
+	}
+	public void setFoodProductionEnergyDemand(Scale foodProductionEnergyDemand) {
+		this.foodProductionEnergyDemand = foodProductionEnergyDemand;
+	}
+	public Scale getFoodConsumption() {
+		return foodConsumption;
+	}
+	public boolean isFoodConsumption() {
+		return foodConsumption!=null;
+	}
+	public void setFoodConsumption(Scale foodConsumption) {
+		this.foodConsumption = foodConsumption;
+	}
+	@Override
+	public Object copy(CopyBuilder copyBuilder) {
+		return copyTo(new FoodSurvey(),copyBuilder);
+	}
+
+	@Override
+	public void accept(FeatureVisitor visitor) {
+		visitor.visit((ADEModelObject)this);
+	}
+
+	@Override
+	public <T> T accept(FeatureFunctor<T> visitor) {
+		return visitor.apply((ADEModelObject)this);
+	}
+
+	@Override
+	public void accept(GMLVisitor visitor) {
+		visitor.visit((ADEModelObject)this);
+		
+	}
+
+	@Override
+	public <T> T accept(GMLFunctor<T> visitor) {
+		return visitor.apply((ADEModelObject)this);
+	}
+}

foodwaterenergycitygml4j/src/main/java/de/hft/stuttgart/ade/foodwaterenergycitygml4j/landuse/model/FoodWaterEnergy.java

+/*-
+ * Copyright 2021 Hochschule für Technik Stuttgart
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model;
+
+
+
+import org.citygml4j.builder.copy.CopyBuilder;
+import org.citygml4j.model.citygml.ade.binding.ADEModelObject;
+import org.citygml4j.model.common.visitor.FeatureFunctor;
+import org.citygml4j.model.common.visitor.FeatureVisitor;
+import org.citygml4j.model.common.visitor.GMLFunctor;
+import org.citygml4j.model.common.visitor.GMLVisitor;
+import org.citygml4j.model.gml.feature.AbstractFeature;
+
+public class FoodWaterEnergy extends AbstractFeature implements ADEModelObject {
+
+	private static final long serialVersionUID = -3892787504021716683L;
+	private String areaName;
+	private String systemName;
+	private ConsistsOfFWESurvey consistsOfFWESurvey;
+	
+	public String getAreaName() {
+		return areaName;
+	}
+	
+	public boolean isAreaName() {
+		return areaName!=null;
+	}
+
+	public void setAreaName(String areaName) {
+		this.areaName = areaName;
+	}
+
+	public String getSystemName() {
+		return systemName;
+	}
+	
+	public boolean isSystemName() {
+		return systemName != null;
+	}
+
+	public void setSystemName(String systemName) {
+		this.systemName = systemName;
+	}
+
+	public ConsistsOfFWESurvey getConsistsOfFWESurvey() {
+		return consistsOfFWESurvey;
+	}
+	
+	public boolean isConsistsOfFWESurvey() {
+		return consistsOfFWESurvey!=null;
+	}
+	public void setConsistsOfFWESurvey(ConsistsOfFWESurvey consistsOfFWESurvey) {
+		this.consistsOfFWESurvey = consistsOfFWESurvey;
+	}
+	@Override
+	public Object copy(CopyBuilder copyBuilder) {
+		return copyTo(new FoodWaterEnergy(),copyBuilder);
+	}
+
+	@Override
+	public void accept(FeatureVisitor visitor) {
+		visitor.visit((ADEModelObject)this);
+	}
+
+	@Override
+	public <T> T accept(FeatureFunctor<T> visitor) {
+		return visitor.apply((ADEModelObject)this);
+	}
+
+	@Override
+	public void accept(GMLVisitor visitor) {
+		visitor.visit((ADEModelObject)this);
+		
+	}
+
+	@Override
+	public <T> T accept(GMLFunctor<T> visitor) {
+		return visitor.apply((ADEModelObject)this);
+	}
+}

foodwaterenergycitygml4j/src/main/java/de/hft/stuttgart/ade/foodwaterenergycitygml4j/landuse/model/LandUseSurvey.java

+/*-
+ * Copyright 2021 Hochschule für Technik Stuttgart
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model;
+
+
+import org.citygml4j.builder.copy.CopyBuilder;
+import org.citygml4j.model.citygml.ade.binding.ADEModelObject;
+import org.citygml4j.model.common.visitor.FeatureFunctor;
+import org.citygml4j.model.common.visitor.FeatureVisitor;
+import org.citygml4j.model.common.visitor.GMLFunctor;
+import org.citygml4j.model.common.visitor.GMLVisitor;
+import org.citygml4j.model.gml.feature.AbstractFeature;
+import org.citygml4j.model.gml.measures.Area;
+
+
+public class LandUseSurvey extends AbstractFeature implements ADEModelObject  {
+
+	private static final long serialVersionUID = -3539870873714199259L;
+	private Area buildingFootprintArea;
+	private Integer population;
+	private Integer surveyYear;
+	private Double surveyYearVersion;
+	private String surveyDescription;
+	private Area surfaceArea;
+	private FoodSurvey foodsurvey;
+	private WaterSurvey watersurvey;
+	private EnergySurvey energySurvey;
+
+	
+	public Area getBuildingFootprintArea() {
+		return buildingFootprintArea;
+	}
+	
+	public boolean isBuildingFootprintArea() {
+		return buildingFootprintArea != null;
+	}
+	public void setBuildingFootprintArea(Area buildingFootprintArea) {
+		this.buildingFootprintArea = buildingFootprintArea;
+	}
+	public Integer getPopulation() {
+		return population;
+	}
+	
+	public boolean isPopulation() {
+		return population!=null;
+	}
+	public void setPopulation(Integer population) {
+		this.population = population;
+	}
+	public Integer getSurveyYear() {
+		return surveyYear;
+	}
+	public boolean isSurveyYear() {
+		return surveyYear!= null;
+	}
+	public void setSurveyYear(Integer surveyYear) {
+		this.surveyYear = surveyYear;
+	}
+	public Double getSurveyYearVersion() {
+		return surveyYearVersion;
+	}
+	public boolean isSurveyYearVersion() {
+		return surveyYearVersion != null;
+	}
+	public void setSurveyYearVersion(Double surveyYearVersion) {
+		this.surveyYearVersion = surveyYearVersion;
+	}
+	public String getSurveyDescription() {
+		return surveyDescription;
+	}
+	public boolean isSurveyDescription() {
+		return surveyDescription != null;
+	}
+	public void setSurveyDescription(String surveyDescription) {
+		this.surveyDescription = surveyDescription;
+	}
+	public Area getSurfaceArea() {
+		return surfaceArea;
+	}
+	public boolean isSurfaceArea() {
+		return surfaceArea != null;
+	}
+	public void setSurfaceArea(Area surfaceArea) {
+		this.surfaceArea = surfaceArea;
+	}
+	
+
+	public FoodSurvey getFoodsurvey() {
+		return foodsurvey;
+	}
+	
+	public boolean isFoodsurvey() {
+		return foodsurvey!=null;
+	}
+
+	public void setFoodsurvey(FoodSurvey foodsurvey) {
+		this.foodsurvey = foodsurvey;
+	}
+	
+	
+
+	public WaterSurvey getWatersurvey() {
+		return watersurvey;
+	}
+	
+	public boolean isWatersurvey() {
+		return watersurvey!=null;
+	}
+
+	public void setWatersurvey(WaterSurvey watersurvey) {
+		this.watersurvey = watersurvey;
+	}
+
+	public EnergySurvey getEnergySurvey() {
+		return energySurvey;
+	}
+	
+	public boolean isEnergySurvey() {
+		return energySurvey != null;
+	}
+
+	public void setEnergySurvey(EnergySurvey energySurvey) {
+		this.energySurvey = energySurvey;
+	}
+
+	@Override
+	public Object copy(CopyBuilder copyBuilder) {
+		return copyTo(new LandUseSurvey(),copyBuilder);
+	}
+
+	@Override
+	public void accept(FeatureVisitor visitor) {
+		visitor.visit((ADEModelObject)this);
+	}
+
+	@Override
+	public <T> T accept(FeatureFunctor<T> visitor) {
+		return visitor.apply((ADEModelObject)this);
+	}
+
+	@Override
+	public void accept(GMLVisitor visitor) {
+		visitor.visit((ADEModelObject)this);
+		
+	}
+
+	@Override
+	public <T> T accept(GMLFunctor<T> visitor) {
+		return visitor.apply((ADEModelObject)this);
+	}
+	
+	
+	
+	
+	/*
+	private List<FoodSurveyType> foodSurvey;
+	private List<WaterSurveyType> waterSurvey;
+	private List<EnergySurveyType> energySurvey;
+	*/
+	
+	
+	
+}

foodwaterenergycitygml4j/src/main/java/de/hft/stuttgart/ade/foodwaterenergycitygml4j/landuse/model/WaterSurvey.java

+/*-
+ * Copyright 2021 Hochschule für Technik Stuttgart
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model;
+
+
+import org.citygml4j.builder.copy.CopyBuilder;
+import org.citygml4j.model.citygml.ade.binding.ADEModelObject;
+import org.citygml4j.model.common.visitor.FeatureFunctor;
+import org.citygml4j.model.common.visitor.FeatureVisitor;
+import org.citygml4j.model.common.visitor.GMLFunctor;
+import org.citygml4j.model.common.visitor.GMLVisitor;
+import org.citygml4j.model.gml.feature.AbstractFeature;
+import org.citygml4j.model.gml.measures.Scale;
+
+
+
+public class WaterSurvey extends AbstractFeature implements ADEModelObject  {
+	
+
+	private static final long serialVersionUID = 1712280908279134012L;
+	
+	private Scale domesticWaterDemand;
+	private Scale domesticHotWaterDemand;
+	private Scale domesticHotWaterEnergyDemand;
+	private Scale domesticWaterWaste;
+	private Scale domesticSolidWaste;
+	private Scale totalDomesticWaste;
+	
+	
+	
+	public Scale getDomesticWaterDemand() {
+		return domesticWaterDemand;
+	}
+	public boolean isDomesticWaterDemand() {
+		return domesticWaterDemand != null;
+	}
+
+	public void setDomesticWaterDemand(Scale domesticWaterDemand) {
+		this.domesticWaterDemand = domesticWaterDemand;
+	}
+
+	public Scale getDomesticHotWaterDemand() {
+		return domesticHotWaterDemand;
+	}
+
+	public boolean isDomesticHotWaterDemand() {
+		return domesticHotWaterDemand != null;
+	}
+
+	public void setDomesticHotWaterDemand(Scale domesticHotWaterDemand) {
+		this.domesticHotWaterDemand = domesticHotWaterDemand;
+	}
+
+	public Scale getDomesticHotWaterEnergyDemand() {
+		return domesticHotWaterEnergyDemand;
+	}
+	
+
+	public boolean isDomesticHotWaterEnergyDemand() {
+		return domesticHotWaterEnergyDemand != null;
+	}
+
+	public void setDomesticHotWaterEnergyDemand(Scale domesticHotWaterEnergyDemand) {
+		this.domesticHotWaterEnergyDemand = domesticHotWaterEnergyDemand;
+	}
+
+	public Scale getDomesticWaterWaste() {
+		return domesticWaterWaste;
+	}
+	
+
+	public boolean isDomesticWaterWaste() {
+		return domesticWaterWaste !=null;
+	}
+
+	public void setDomesticWaterWaste(Scale domesticWaterWaste) {
+		this.domesticWaterWaste = domesticWaterWaste;
+	}
+
+	public Scale getDomesticSolidWaste() {
+		return domesticSolidWaste;
+	}
+	
+	public boolean isDomesticSolidWaste() {
+		return domesticSolidWaste!=null;
+	}
+
+	public void setDomesticSolidWaste(Scale domesticSolidWaste) {
+		this.domesticSolidWaste = domesticSolidWaste;
+	}
+
+	public Scale getTotalDomesticWaste() {
+		return totalDomesticWaste;
+	}
+	
+	public boolean isTotalDomesticWaste() {
+		return totalDomesticWaste!=null;
+	}
+
+	public void setTotalDomesticWaste(Scale totalDomesticWaste) {
+		this.totalDomesticWaste = totalDomesticWaste;
+	}
+
+	@Override
+	public Object copy(CopyBuilder copyBuilder) {
+		return copyTo(new WaterSurvey(),copyBuilder);
+	}
+
+	@Override
+	public void accept(FeatureVisitor visitor) {
+		visitor.visit((ADEModelObject)this);
+	}
+
+	@Override
+	public <T> T accept(FeatureFunctor<T> visitor) {
+		return visitor.apply((ADEModelObject)this);
+	}
+
+	@Override
+	public void accept(GMLVisitor visitor) {
+		visitor.visit((ADEModelObject)this);
+		
+	}
+
+	@Override
+	public <T> T accept(GMLFunctor<T> visitor) {
+		return visitor.apply((ADEModelObject)this);
+	}
+
+
+}

foodwaterenergycitygml4j/src/main/java/de/hft/stuttgart/ade/foodwaterenergycitygml4j/landuse/model/xsd/ConsistsOfFWESurveyType.java

+/*-
+ * Copyright 2021 Hochschule für Technik Stuttgart
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.xsd;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+
+import net.opengis.gml.AbstractFeatureType;
+
+
+@XmlType(name = "consistsOfFWESurvey")
+@XmlAccessorType(XmlAccessType.FIELD)
+public class ConsistsOfFWESurveyType extends AbstractFeatureType {
+	
+	//@XmlElementWrapper(name = "LandUseSurveys")
+	@XmlElement(name = "landUseSurvey")
+	private List<LandUseSurveyType> landUseSurveyType;
+
+	public List<LandUseSurveyType> getLandUseSurveyType() {
+		if(landUseSurveyType == null) {
+			landUseSurveyType = new ArrayList<>();
+		}
+		return landUseSurveyType;
+	}
+
+
+	public void setLandUseSurveyType(List<LandUseSurveyType> landUseSurveyType) {
+		this.landUseSurveyType = landUseSurveyType;
+	}
+	
+}

foodwaterenergycitygml4j/src/main/java/de/hft/stuttgart/ade/foodwaterenergycitygml4j/landuse/model/xsd/EnergySurveyType.java

+/*-
+ * Copyright 2021 Hochschule für Technik Stuttgart
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.xsd;
+
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+
+import net.opengis.gml.AbstractFeatureType;
+import net.opengis.gml.CodeType;
+import net.opengis.gml.ScaleType;
+
+@XmlType(name = "EnergySurvey")
+public class EnergySurveyType extends AbstractFeatureType {
+	
+	
+	@XmlElement(name = "spaceHeatingDemand")
+	private ScaleType spaceHeatingDemand;
+	@XmlElement(name = "spaceCoolingDemand")
+	private ScaleType spaceCoolingDemand;
+	@XmlElement(name = "residentialElectricityDemand")
+	private ScaleType residentialElectricityDemand;
+	@XmlElement(name = "electricityPotentialFromPVBuildings")
+	private ScaleType electricityPotentialFromPVBuildings;
+	@XmlElement(name = "vegetationCoverCategory")
+	private CodeType vegetationCoverCategory;
+	@XmlElement(name = "biomassPrimaryEnergyPotential")
+	private ScaleType biomassPrimaryEnergyPotential;
+	@XmlElement(name = "biomassToEnergyWoods")
+	private ScaleType biomassToEnergyWoods;
+	@XmlElement(name = "biomassToBiogas")
+	private ScaleType biomassToBiogas;
+	@XmlElement(name = "biomassToPlantOil")
+	private ScaleType biomassToPlantOil;
+	@XmlElement(name = "biomassToBioethanol")
+	private ScaleType biomassToBioethanol;
+	@XmlElement(name = "biomassToResidualSolidFuel")
+	private ScaleType biomassToResidualSolidFuel;
+	@XmlElement(name = "biomassToSolidFuel")
+	private ScaleType biomassToSolidFuel;
+	@XmlElement(name = "biomassToElectricityPotential")
+	private ScaleType biomassToElectricityPotential;
+	@XmlElement(name = "biomassToThermalPotential")
+	private ScaleType biomassToThermalPotential;
+	
+	public ScaleType getSpaceHeatingDemand() {
+		return spaceHeatingDemand;
+	}
+	public void setSpaceHeatingDemand(ScaleType spaceHeatingDemand) {
+		this.spaceHeatingDemand = spaceHeatingDemand;
+	}
+	public ScaleType getSpaceCoolingDemand() {
+		return spaceCoolingDemand;
+	}
+	
+	public void setSpaceCoolingDemand(ScaleType spaceCoolingDemand) {
+		this.spaceCoolingDemand = spaceCoolingDemand;
+	}
+	public ScaleType getResidentialElectricityDemand() {
+		return residentialElectricityDemand;
+	}
+	public void setResidentialElectricityDemand(ScaleType residentialElectricityDemand) {
+		this.residentialElectricityDemand = residentialElectricityDemand;
+	}
+	public ScaleType getElectricityPotentialFromPVBuildings() {
+		return electricityPotentialFromPVBuildings;
+	}
+	public void setElectricityPotentialFromPVBuildings(ScaleType electricityPotentialFromPVBuildings) {
+		this.electricityPotentialFromPVBuildings = electricityPotentialFromPVBuildings;
+	}
+	public CodeType getVegetationCoverCategory() {
+		return vegetationCoverCategory;
+	}
+	public void setVegetationCoverCategory(CodeType vegetationCoverCategory) {
+		this.vegetationCoverCategory = vegetationCoverCategory;
+	}
+	public ScaleType getBiomassPrimaryEnergyPotential() {
+		return biomassPrimaryEnergyPotential;
+	}
+	public void setBiomassPrimaryEnergyPotential(ScaleType biomassPrimaryEnergyPotential) {
+		this.biomassPrimaryEnergyPotential = biomassPrimaryEnergyPotential;
+	}
+	public ScaleType getBiomassToEnergyWoods() {
+		return biomassToEnergyWoods;
+	}
+	public void setBiomassToEnergyWoods(ScaleType biomassToEnergyWoods) {
+		this.biomassToEnergyWoods = biomassToEnergyWoods;
+	}
+	public ScaleType getBiomassToBiogas() {
+		return biomassToBiogas;
+	}
+	public void setBiomassToBiogas(ScaleType biomassToBiogas) {
+		this.biomassToBiogas = biomassToBiogas;
+	}
+	public ScaleType getBiomassToPlantOil() {
+		return biomassToPlantOil;
+	}
+	public void setBiomassToPlantOil(ScaleType biomassToPlantOil) {
+		this.biomassToPlantOil = biomassToPlantOil;
+	}
+	public ScaleType getBiomassToBioethanol() {
+		return biomassToBioethanol;
+	}
+	public void setBiomassToBioethanol(ScaleType biomassToBioethanol) {
+		this.biomassToBioethanol = biomassToBioethanol;
+	}
+	public ScaleType getBiomassToResidualSolidFuel() {
+		return biomassToResidualSolidFuel;
+	}
+	public void setBiomassToResidualSolidFuel(ScaleType biomassToResidualSolidFuel) {
+		this.biomassToResidualSolidFuel = biomassToResidualSolidFuel;
+	}
+	public ScaleType getBiomassToSolidFuel() {
+		return biomassToSolidFuel;
+	}
+	public void setBiomassToSolidFuel(ScaleType biomassToSolidFuel) {
+		this.biomassToSolidFuel = biomassToSolidFuel;
+	}
+	public ScaleType getBiomassToElectricityPotential() {
+		return biomassToElectricityPotential;
+	}
+	public void setBiomassToElectricityPotential(ScaleType biomassToElectricityPotential) {
+		this.biomassToElectricityPotential = biomassToElectricityPotential;
+	}
+	public ScaleType getBiomassToThermalPotential() {
+		return biomassToThermalPotential;
+	}
+	public void setBiomassToThermalPotential(ScaleType biomassToThermalPotential) {
+		this.biomassToThermalPotential = biomassToThermalPotential;
+	}
+}

foodwaterenergycitygml4j/src/main/java/de/hft/stuttgart/ade/foodwaterenergycitygml4j/landuse/model/xsd/FoodSurveyType.java

+/*-
+ * Copyright 2021 Hochschule für Technik Stuttgart
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.xsd;
+
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+
+import net.opengis.gml.AbstractFeatureType;
+import net.opengis.gml.CodeType;
+import net.opengis.gml.ScaleType;
+
+@XmlType(name = "FoodSurvey")
+public class FoodSurveyType extends AbstractFeatureType {
+	
+	
+	@XmlElement(name = "foodCategory")
+	private CodeType foodCategory;
+	@XmlElement(name = "foodDemand")
+	private ScaleType foodDemand;
+	@XmlElement(name = "foodProduction")
+	private ScaleType foodProduction;
+	@XmlElement(name = "foodProductionWaterDemand")
+	private ScaleType foodProductionWaterDemand;
+	@XmlElement(name = "foodProductionEnergyDemand")
+	private ScaleType foodProductionEnergyDemand;
+	@XmlElement(name = "foodConsumption")
+	private ScaleType foodConsumption;
+	
+	public CodeType getFoodCategory() {
+		return foodCategory;
+	}
+	public void setFoodCategory(CodeType foodCategory) {
+		this.foodCategory = foodCategory;
+	}
+	public ScaleType getFoodDemand() {
+		return foodDemand;
+	}
+	public void setFoodDemand(ScaleType foodDemand) {
+		this.foodDemand = foodDemand;
+	}
+	
+	public ScaleType getFoodProduction() {
+		return foodProduction;
+	}
+	public void setFoodProduction(ScaleType foodProduction) {
+		this.foodProduction = foodProduction;
+	}
+	
+	public ScaleType getFoodProductionWaterDemand() {
+		return foodProductionWaterDemand;
+	}
+	public void setFoodProductionWaterDemand(ScaleType foodProductionWaterDemand) {
+		this.foodProductionWaterDemand = foodProductionWaterDemand;
+	}
+	
+	public ScaleType getFoodProductionEnergyDemand() {
+		return foodProductionEnergyDemand;
+	}
+	public void setFoodProductionEnergyDemand(ScaleType foodProductionEnergyDemand) {
+		this.foodProductionEnergyDemand = foodProductionEnergyDemand;
+	}
+	
+	public ScaleType getFoodConsumption() {
+		return foodConsumption;
+	}
+	public void setFoodConsumption(ScaleType foodConsumption) {
+		this.foodConsumption = foodConsumption;
+	}
+	
+
+	
+
+}

foodwaterenergycitygml4j/src/main/java/de/hft/stuttgart/ade/foodwaterenergycitygml4j/landuse/model/xsd/FoodWaterEnergyType.java

+/*-
+ * Copyright 2021 Hochschule für Technik Stuttgart
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.xsd;
+
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+
+import net.opengis.gml.AbstractFeatureType;
+
+
+@XmlType(name = "FoodWaterEnergy")
+public class FoodWaterEnergyType extends AbstractFeatureType {
+	@XmlElement(name = "fweAreaName")
+	private String areaName;
+	
+	@XmlElement(name = "fweSystemName")
+	private String systemName;
+	
+	@XmlElement(name = "consistsOfFWESurvey")
+	private ConsistsOfFWESurveyType consistsOfFWESurveyType;
+	
+	public String getAreaName() {
+		return areaName;
+	}
+
+	public void setAreaName(String areaName) {
+		this.areaName = areaName;
+	}
+
+	public String getSystemName() {
+		return systemName;
+	}
+
+	public void setSystemName(String systemName) {
+		this.systemName = systemName;
+	}
+
+	public ConsistsOfFWESurveyType getConsistsOfFWESurveyType() {
+		return consistsOfFWESurveyType;
+	}
+
+	public void setConsistsOfFWESurveyType(ConsistsOfFWESurveyType consistsOfFWESurveyType) {
+		this.consistsOfFWESurveyType = consistsOfFWESurveyType;
+	}
+}

foodwaterenergycitygml4j/src/main/java/de/hft/stuttgart/ade/foodwaterenergycitygml4j/landuse/model/xsd/LandUseSurveyType.java

+/*-
+ * Copyright 2021 Hochschule für Technik Stuttgart
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.xsd;
+
+
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+import net.opengis.gml.AbstractFeatureType;
+import net.opengis.gml.AreaType;
+
+
+@XmlType(name = "LandUseSurvey")
+public class LandUseSurveyType extends AbstractFeatureType  {
+	@XmlElement(name = "buildingFootprintArea")
+	private AreaType buildingFootprintArea;
+	@XmlElement(name = "population")
+	private Integer population;
+	@XmlElement(name = "surveyYear")
+	private Integer surveyYear;
+	@XmlElement(name = "surveyYearVersion")
+	private Double surveyYearVersion;
+	@XmlElement(name = "surveyDescription")
+	private String surveyDescription;
+	@XmlElement(name = "surfaceArea")
+	private AreaType surfaceArea;
+	@XmlElement(name = "foodSurvey")
+	private FoodSurveyType foodSurveyType;
+	@XmlElement(name = "waterSurvey")
+	private WaterSurveyType waterSurveyType;
+	@XmlElement(name = "energySurvey")
+	private EnergySurveyType energySurveyType;
+
+	
+	public AreaType getBuildingFootprintArea() {
+		return buildingFootprintArea;
+	}
+	public void setBuildingFootprintArea(AreaType buildingFootprintArea) {
+		this.buildingFootprintArea = buildingFootprintArea;
+	}
+	public Integer getPopulation() {
+		return population;
+	}
+	public void setPopulation(Integer population) {
+		this.population = population;
+	}
+	public Integer getSurveyYear() {
+		return surveyYear;
+	}
+	public void setSurveyYear(Integer surveyYear) {
+		this.surveyYear = surveyYear;
+	}
+	public Double getSurveyYearVersion() {
+		return surveyYearVersion;
+	}
+	public void setSurveyYearVersion(Double surveyYearVersion) {
+		this.surveyYearVersion = surveyYearVersion;
+	}
+	public String getSurveyDescription() {
+		return surveyDescription;
+	}
+	public void setSurveyDescription(String surveyDescription) {
+		this.surveyDescription = surveyDescription;
+	}
+	public AreaType getSurfaceArea() {
+		return surfaceArea;
+	}
+	public void setSurfaceArea(AreaType surfaceArea) {
+		this.surfaceArea = surfaceArea;
+	}
+	public FoodSurveyType getFoodSurveyType() {
+		return foodSurveyType;
+	}
+	public void setFoodSurveyType(FoodSurveyType foodSurveyType) {
+		this.foodSurveyType = foodSurveyType;
+	}
+	public WaterSurveyType getWaterSurveyType() {
+		return waterSurveyType;
+	}
+	public void setWaterSurveyType(WaterSurveyType waterSurveyType) {
+		this.waterSurveyType = waterSurveyType;
+	}
+	public EnergySurveyType getEnergySurveyType() {
+		return energySurveyType;
+	}
+	public void setEnergySurveyType(EnergySurveyType energySurveyType) {
+		this.energySurveyType = energySurveyType;
+	}
+
+}

foodwaterenergycitygml4j/src/main/java/de/hft/stuttgart/ade/foodwaterenergycitygml4j/landuse/model/xsd/ObjectFactory.java

+/*-
+ * Copyright 2021 Hochschule für Technik Stuttgart
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.xsd;
+
+import javax.xml.bind.JAXBElement;
+import javax.xml.bind.annotation.XmlElementDecl;
+import javax.xml.bind.annotation.XmlRegistry;
+import javax.xml.namespace.QName;
+
+import de.hft.stuttgart.ade.foodwaterenergycitygml4j.module.FoodWaterEnergyLandUseADEModule;
+
+
+@XmlRegistry
+public class ObjectFactory {
+
+	private static final QName FOODWATERENERGY_QNAME = new QName(FoodWaterEnergyLandUseADEModule.NAMESPACE_URI, "foodwaterenergy");
+	private static final QName CONSISTSOFFWESURVEY_QNAME = new QName(FoodWaterEnergyLandUseADEModule.NAMESPACE_URI, "consistsOfFWESurvey");
+	private static final QName LandUseSurvey_QNAME = new QName(FoodWaterEnergyLandUseADEModule.NAMESPACE_URI, "LandUseSurvey");
+	private static final QName FoodSurvey_QNAME = new QName(FoodWaterEnergyLandUseADEModule.NAMESPACE_URI, "FoodSurvey");
+	private static final QName WaterSurvey_QNAME = new QName(FoodWaterEnergyLandUseADEModule.NAMESPACE_URI, "WaterSurvey");
+	private static final QName EnergySurvey_QNAME = new QName(FoodWaterEnergyLandUseADEModule.NAMESPACE_URI, "EnergySurvey");
+	
+	 public FoodWaterEnergyType createFoodWaterEnergyType() {
+			return new FoodWaterEnergyType();
+		}
+	 public ConsistsOfFWESurveyType createConsistsOfFWESurveyType() {
+			return new ConsistsOfFWESurveyType();
+		}
+	 
+	 public LandUseSurveyType createLandUseSurveyType() {
+			return new LandUseSurveyType();
+		}
+	 
+	 public FoodSurveyType createFoodSurveyType() {
+			return new FoodSurveyType();
+		}
+
+	 public WaterSurveyType createWaterSurveyType() {
+			return new WaterSurveyType();
+		}
+	 
+	 public EnergySurveyType createEnergySurveyType() {
+			return new EnergySurveyType();
+		}
+
+	@XmlElementDecl(namespace = FoodWaterEnergyLandUseADEModule.NAMESPACE_URI, name = "foodwaterenergy", substitutionHeadNamespace = "http://www.opengis.net/citygml/landuse/2.0", substitutionHeadName = "_GenericApplicationPropertyOfLandUse")
+	public JAXBElement<FoodWaterEnergyType> createFoodWaterEnergyType(FoodWaterEnergyType type) {
+			return new JAXBElement<>(FOODWATERENERGY_QNAME, FoodWaterEnergyType.class, type);
+		}
+	
+	@XmlElementDecl(namespace = FoodWaterEnergyLandUseADEModule.NAMESPACE_URI, name = "consistsOfFWESurvey" ,substitutionHeadNamespace = "http://transfer.hft-stuttgart.de/pages/in-source/fwe-ade/FWELanduse/v2.1.1/XSD", substitutionHeadName = "foodwaterenergy")
+	public JAXBElement<ConsistsOfFWESurveyType> createFConsistsOfFWESurveyType(ConsistsOfFWESurveyType type) {
+			return new JAXBElement<>(CONSISTSOFFWESURVEY_QNAME, ConsistsOfFWESurveyType.class, type);
+		}
+
+	@XmlElementDecl(namespace = FoodWaterEnergyLandUseADEModule.NAMESPACE_URI, name = "LandUseSurvey" ,substitutionHeadNamespace = "http://transfer.hft-stuttgart.de/pages/in-source/fwe-ade/FWELanduse/v2.1.1/XSD", substitutionHeadName = "consistsOfFWESurvey")
+	public JAXBElement<LandUseSurveyType> createLandUseSurveyType(LandUseSurveyType type) {
+			return new JAXBElement<>(LandUseSurvey_QNAME, LandUseSurveyType.class, type);
+		}
+	
+	@XmlElementDecl(namespace = FoodWaterEnergyLandUseADEModule.NAMESPACE_URI, name = "FoodSurvey", substitutionHeadNamespace = "http://transfer.hft-stuttgart.de/pages/in-source/fwe-ade/FWELanduse/v2.1.1/XSD", substitutionHeadName = "LandUseSurvey")
+	public JAXBElement<FoodSurveyType> createFoodSurveyType(FoodSurveyType type) {
+			return new JAXBElement<>(FoodSurvey_QNAME, FoodSurveyType.class, type);
+		}
+	
+
+	@XmlElementDecl(namespace = FoodWaterEnergyLandUseADEModule.NAMESPACE_URI, name = "WaterSurvey",substitutionHeadNamespace = "http://transfer.hft-stuttgart.de/pages/in-source/fwe-ade/FWELanduse/v2.1.1/XSD", substitutionHeadName = "LandUseSurvey")
+	public JAXBElement<WaterSurveyType> createWaterSurveyType(WaterSurveyType type) {
+			return new JAXBElement<>(WaterSurvey_QNAME, WaterSurveyType.class, type);
+		}
+	
+
+	@XmlElementDecl(namespace = FoodWaterEnergyLandUseADEModule.NAMESPACE_URI, name = "EnergySurvey",substitutionHeadNamespace = "http://transfer.hft-stuttgart.de/pages/in-source/fwe-ade/FWELanduse/v2.1.1/XSD", substitutionHeadName = "LandUseSurvey")
+	public JAXBElement<EnergySurveyType> createEnergySurveyType(EnergySurveyType type) {
+			return new JAXBElement<>(EnergySurvey_QNAME, EnergySurveyType.class, type);
+		}	
+}

foodwaterenergycitygml4j/src/main/java/de/hft/stuttgart/ade/foodwaterenergycitygml4j/landuse/model/xsd/WaterSurveyType.java

+/*-
+ * Copyright 2021 Hochschule für Technik Stuttgart
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package de.hft.stuttgart.ade.foodwaterenergycitygml4j.landuse.model.xsd;
+
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+
+import net.opengis.gml.AbstractFeatureType;
+import net.opengis.gml.ScaleType;
+
+@XmlType(name = "WaterSurvey")
+public class WaterSurveyType extends AbstractFeatureType {
+	
+	@XmlElement(name = "domesticWaterDemand")
+	private ScaleType domesticWaterDemand;
+	@XmlElement(name = "domesticHotWaterDemand")
+	private ScaleType domesticHotWaterDemand;
+	@XmlElement(name = "domesticHotWaterEnergyDemand")
+	private ScaleType domesticHotWaterEnergyDemand;
+	@XmlElement(name = "domesticWaterWaste")
+	private ScaleType domesticWaterWaste;
+	@XmlElement(name = "domesticSolidWaste")
+	private ScaleType domesticSolidWaste;
+	@XmlElement(name = "totalDomesticWaste")
+	private ScaleType totalDomesticWaste;
+	
+	
+	public ScaleType getDomesticWaterDemand() {
+		return domesticWaterDemand;
+	}
+	public void setDomesticWaterDemand(ScaleType domesticWaterDemand) {
+		this.domesticWaterDemand = domesticWaterDemand;
+	}
+	public ScaleType getDomesticHotWaterDemand() {
+		return domesticHotWaterDemand;
+	}
+	public void setDomesticHotWaterDemand(ScaleType domesticHotWaterDemand) {
+		this.domesticHotWaterDemand = domesticHotWaterDemand;
+	}
+	public ScaleType getDomesticHotWaterEnergyDemand() {
+		return domesticHotWaterEnergyDemand;
+	}
+	public void setDomesticHotWaterEnergyDemand(ScaleType domesticHotWaterEnergyDemand) {
+		this.domesticHotWaterEnergyDemand = domesticHotWaterEnergyDemand;
+	}
+	public ScaleType getDomesticWaterWaste() {
+		return domesticWaterWaste;
+	}
+	public void setDomesticWaterWaste(ScaleType domesticWaterWaste) {
+		this.domesticWaterWaste = domesticWaterWaste;
+	}
+	public ScaleType getDomesticSolidWaste() {
+		return domesticSolidWaste;
+	}
+	public void setDomesticSolidWaste(ScaleType domesticSolidWaste) {
+		this.domesticSolidWaste = domesticSolidWaste;
+	}
+	public ScaleType getTotalDomesticWaste() {
+		return totalDomesticWaste;
+	}
+	public void setTotalDomesticWaste(ScaleType totalDomesticWaste) {
+		this.totalDomesticWaste = totalDomesticWaste;
+	}
+
+}