Initial commit

src/main/java/org/citygml4j/ade/energy/model/core/WeatherData.java

+/*
+ * energy-ade-citygml4j - Energy ADE module for citygml4j
+ * https://github.com/citygml4j/energy-ade-citygml4j
+ *
+ * energy-ade-citygml4j is part of the citygml4j project
+ *
+ * Copyright 2019-2024 Claus Nagel <claus.nagel@gmail.com>
+ *
+ * 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 org.citygml4j.ade.energy.model.core;
+
+import org.citygml4j.ade.energy.model.supportingClasses.AbstractTimeSeriesProperty;
+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.base.AbstractGML;
+import org.citygml4j.model.gml.basicTypes.Code;
+import org.citygml4j.model.gml.basicTypes.Measure;
+import org.citygml4j.model.gml.feature.AbstractFeature;
+import org.citygml4j.model.gml.geometry.primitives.PointProperty;
+import org.sig3d.citygml.energyADE2beta7.AbstractTimeSeriesPropertyType;
+
+public class WeatherData extends AbstractFeature implements ADEModelObject {
+    private Code libraryCode;
+    private Code type;
+    private Code valueType;
+    private Measure yearlyValue;
+    private ReferencePointProperty position;
+    private AbstractTimeSeriesProperty timeDependentValues;
+
+    public AbstractTimeSeriesProperty getTimeDependentValues() {
+        return timeDependentValues;
+    }
+
+    public void setTimeDependentValues(AbstractTimeSeriesProperty timeDependentValues) {
+        this.timeDependentValues = timeDependentValues;
+    }
+
+    public Code getLibraryCode() {
+        return libraryCode;
+    }
+
+    public void setLibraryCode(Code libraryCode) {
+        this.libraryCode = libraryCode;
+    }
+
+    public Code getType() {
+        return type;
+    }
+
+    public void setType(Code type) {
+        this.type = type;
+    }
+
+    public Code getValueType() {
+        return valueType;
+    }
+
+    public void setValueType(Code valueType) {
+        this.valueType = valueType;
+    }
+
+    public Measure getYearlyValue() {
+        return yearlyValue;
+    }
+
+    public void setYearlyValue(Measure yearlyValue) {
+        this.yearlyValue = yearlyValue;
+    }
+
+    public ReferencePointProperty getPosition() {
+        return position;
+    }
+
+    public void setPosition(ReferencePointProperty position) {
+        this.position = position;
+    }
+
+    public boolean isSetPosition() {
+        return position != null;
+    }
+    public boolean isSetValueType() {
+        return valueType != null;
+    }
+    public boolean isSetYearlyValue() {
+        return yearlyValue != null;
+    }
+    public boolean isSetType() {
+        return type != null;
+    }
+    public boolean isSetLibraryCode() {
+        return libraryCode != null;
+    }
+    public boolean isSetTimeDependentValues() {
+        return timeDependentValues != null;
+    }
+
+    @Override
+    public Object copy(CopyBuilder copyBuilder) {
+        return copyTo(new WeatherData(), copyBuilder);
+    }
+
+    @Override
+    public Object copyTo(Object target, CopyBuilder copyBuilder) {
+        WeatherData copy = (target == null) ? new WeatherData() : (WeatherData) target;
+        super.copyTo(copy, copyBuilder);
+
+        if (isSetPosition())
+            copy.setPosition((ReferencePointProperty) copyBuilder.copy(position));
+
+        if (isSetValueType())
+            copy.setValueType((Code) copyBuilder.copy(valueType));
+
+        if (isSetLibraryCode())
+            copy.setLibraryCode((Code) copyBuilder.copy(libraryCode));
+
+        if (isSetYearlyValue())
+            copy.setYearlyValue((Measure) copyBuilder.copy(yearlyValue));
+
+        if (isSetType())
+            copy.setType((Code) copyBuilder.copy(type));
+        if (isSetTimeDependentValues())
+            copy.setTimeDependentValues((AbstractTimeSeriesProperty) copyBuilder.copy(this));
+
+        return copy;
+    }
+
+    @Override
+    public void accept(FeatureVisitor featureVisitor) {
+        featureVisitor.visit(this);
+    }
+
+    @Override
+    public <T> T accept(FeatureFunctor<T> featureFunctor) {
+        return featureFunctor.apply(this);
+    }
+
+    @Override
+    public void accept(GMLVisitor visitor) {
+        visitor.visit(this);
+    }
+
+    @Override
+    public <T> T accept(GMLFunctor<T> visitor) {
+        return visitor.apply(this);
+    }
+}

src/main/java/org/citygml4j/ade/energy/model/core/WeatherDataProperty.java

+/*
+ * energy-ade-citygml4j - Energy ADE module for citygml4j
+ * https://github.com/citygml4j/energy-ade-citygml4j
+ *
+ * energy-ade-citygml4j is part of the citygml4j project
+ *
+ * Copyright 2019-2024 Claus Nagel <claus.nagel@gmail.com>
+ *
+ * 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 org.citygml4j.ade.energy.model.core;
+
+import org.citygml4j.builder.copy.CopyBuilder;
+import org.citygml4j.model.citygml.ade.binding.ADEModelObject;
+import org.citygml4j.model.gml.base.AssociationByRepOrRef;
+
+public class WeatherDataProperty extends AssociationByRepOrRef<WeatherData> implements ADEModelObject {
+
+    public WeatherDataProperty() {
+    }
+
+    public WeatherDataProperty(WeatherData weatherData) {
+        super(weatherData);
+    }
+
+    public WeatherDataProperty(String href) {
+        super(href);
+    }
+
+    public WeatherData getWeatherData() {
+        return super.getObject();
+    }
+
+    public boolean isSetWeatherData() {
+        return super.isSetObject();
+    }
+
+    public void setWeatherData(WeatherData weatherData) {
+        super.setObject(weatherData);
+    }
+
+    public void unsetWeatherData() {
+        super.unsetObject();
+    }
+
+    @Override
+    public Class<WeatherData> getAssociableClass() {
+        return WeatherData.class;
+    }
+
+    @Override
+    public Object copy(CopyBuilder copyBuilder) {
+        return copyTo(new WeatherDataProperty(), copyBuilder);
+    }
+
+    @Override
+    public Object copyTo(Object target, CopyBuilder copyBuilder) {
+        WeatherDataProperty copy = (target == null) ? new WeatherDataProperty() : (WeatherDataProperty) target;
+        return super.copyTo(copy, copyBuilder);
+    }
+}

src/main/java/org/citygml4j/ade/energy/model/core/WeatherDataPropertyElement.java

+/*
+ * energy-ade-citygml4j - Energy ADE module for citygml4j
+ * https://github.com/citygml4j/energy-ade-citygml4j
+ *
+ * energy-ade-citygml4j is part of the citygml4j project
+ *
+ * Copyright 2019-2024 Claus Nagel <claus.nagel@gmail.com>
+ *
+ * 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 org.citygml4j.ade.energy.model.core;
+
+import org.citygml4j.builder.copy.CopyBuilder;
+import org.citygml4j.model.citygml.ade.binding.ADEGenericApplicationProperty;
+
+public class WeatherDataPropertyElement extends ADEGenericApplicationProperty<WeatherDataProperty> {
+
+    public WeatherDataPropertyElement() {
+    }
+
+    public WeatherDataPropertyElement(WeatherDataProperty value) {
+        super(value);
+    }
+
+    @Override
+    public Object copy(CopyBuilder copyBuilder) {
+        return copyTo(new WeatherDataPropertyElement(), copyBuilder);
+    }
+}

src/main/java/org/citygml4j/ade/energy/model/core/WeatherDataTypeValue.java

+/*
+ * energy-ade-citygml4j - Energy ADE module for citygml4j
+ * https://github.com/citygml4j/energy-ade-citygml4j
+ *
+ * energy-ade-citygml4j is part of the citygml4j project
+ *
+ * Copyright 2019-2024 Claus Nagel <claus.nagel@gmail.com>
+ *
+ * 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 org.citygml4j.ade.energy.model.core;
+
+public enum WeatherDataTypeValue {
+    AIR_TEMPERATURE("airTemperature"),
+    HUMIDITY("humidity"),
+    WIND_SPEED("windSpeed"),
+    CLOUDINESS("cloudiness"),
+    GLOBAL_SOLAR_IRRADIANCE("globalSolarIrradiance"),
+    DIRECT_SOLAR_IRRADIANCE("directSolarIrradiance"),
+    DIFFUSE_SOLAR_IRRADIANCE("diffuseSolarIrradiance"),
+    TERRESTRIAL_EMISSION("terrestrialEmission"),
+    DOWNWARD_TERRESTRIAL_RADIATION("downwardTerrestrialRadiation"),
+    DAYLIGHT_ILLUMINANCE("daylightIlluminance");
+
+    private final String value;
+
+    WeatherDataTypeValue(String value) {
+        this.value = value;
+    }
+
+    public String value() {
+        return value;
+    }
+
+    public static WeatherDataTypeValue fromValue(String v) {
+        for (WeatherDataTypeValue c : WeatherDataTypeValue.values()) {
+            if (c.value.equals(v))
+                return c;
+        }
+
+        return null;
+    }
+}

src/main/java/org/citygml4j/ade/energy/model/module/EnergyADEModule.java

+/*
+ * energy-ade-citygml4j - Energy ADE module for citygml4j
+ * https://github.com/citygml4j/energy-ade-citygml4j
+ *
+ * energy-ade-citygml4j is part of the citygml4j project
+ *
+ * Copyright 2019-2024 Claus Nagel <claus.nagel@gmail.com>
+ *
+ * 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 org.citygml4j.ade.energy.model.module;
+
+import org.citygml4j.ade.energy.EnergyADEContext;
+import org.citygml4j.ade.energy.model.core.*;
+import org.citygml4j.ade.energy.model.supportingClasses.*;
+import org.citygml4j.model.gml.feature.AbstractFeature;
+import org.citygml4j.model.module.ade.ADEModule;
+import org.citygml4j.model.module.citygml.CityGMLVersion;
+
+import javax.xml.namespace.QName;
+import java.net.URL;
+import java.util.*;
+
+public class EnergyADEModule extends ADEModule {
+    public static final EnergyADEModule v2_0 = new EnergyADEModule();
+
+    private HashMap<String, Class<? extends AbstractFeature>> features;
+    private HashSet<String> featureProperties;
+
+    public EnergyADEModule() {
+        super("http://www.citygml.org/ade/energy/2.0",
+                "nrg2",
+                CityGMLVersion.v2_0_0);
+
+        features = new HashMap<>();
+        features.put("WeatherStation", WeatherStation.class);
+        features.put("UrbanFunctionArea", UrbanFunctionArea.class);
+        features.put("AbstractDevice", AbstractDevice.class);
+        features.put("RefurbishmentMeasure", RefurbishmentMeasure.class);
+        features.put("EnergyPerformanceCertificate", EnergyPerformanceCertificate.class);
+        features.put("UtilityNetworkConnection", UtilityNetworkConnection.class);
+        features.put("AbstractTimeSeries", AbstractTimeSeries.class);
+        features.put("TypicalValuesTimeSeries", TypicalValuesTimeSeries.class);
+        features.put("RegularTimeSeries", RegularTimeSeries.class);
+        features.put("RegularTimeSeriesFile", RegularTimeSeriesFile.class);
+        features.put("TypicalValuesTimeSeriesFile", TypicalValuesTimeSeriesFile.class);
+        features.put("SensorConnection", SensorConnection.class);
+        features.put("DeviceOperation", DeviceOperation.class);
+        features.put("AbstractResource", AbstractResource.class);
+        features.put("Water", Water.class);
+        features.put("Waste", Waste.class);
+        features.put("Energy", Energy.class);
+        features.put("Food", Food.class);
+        features.put("OtherResource", OtherResource.class);
+        features.put("ConstructionMaterial", ConstructionMaterial.class);
+        featureProperties = new HashSet<>();
+
+    }
+
+    @Override
+    public URL getSchemaResource() {
+        return EnergyADEContext.class.getResource("/Energy_ADE_2.0_beta7.xsd");
+    }
+
+    @Override
+    public List<String> getJAXBPackageNames() {
+        return Collections.singletonList("org.sig3d.citygml.energyADE2beta7");
+    }
+
+    @Override
+    public boolean hasFeatureProperty(String name) {
+        return featureProperties.contains(name);
+    }
+
+    @Override
+    public boolean hasFeature(String name) {
+        return features.containsKey(name);
+    }
+
+    @Override
+    public Class<? extends AbstractFeature> getFeatureClass(String name) {
+        return features.get(name);
+    }
+
+    @Override
+    public QName getFeatureName(Class<? extends AbstractFeature> featureClass) {
+        for (Map.Entry<String, Class<? extends AbstractFeature>> entry : features.entrySet()) {
+            if (entry.getValue() == featureClass)
+                return new QName(getNamespaceURI(), entry.getKey());
+        }
+
+        return null;
+    }
+
+    @Override
+    public Map<String, Class<? extends AbstractFeature>> getFeatures() {
+        return new HashMap<>(features);
+    }
+
+    @Override
+    public boolean isTopLevelFeature(String name) {
+        return "WeatherStation".equals(name)
+            || "UrbanFunctionArea".equals(name);
+    }
+}

src/main/java/org/citygml4j/ade/energy/model/supportingClasses/AbstractSchedule.java

+/*
+ * energy-ade-citygml4j - Energy ADE module for citygml4j
+ * https://github.com/citygml4j/energy-ade-citygml4j
+ *
+ * energy-ade-citygml4j is part of the citygml4j project
+ *
+ * Copyright 2019-2024 Claus Nagel <claus.nagel@gmail.com>
+ *
+ * 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 org.citygml4j.ade.energy.model.supportingClasses;
+
+import org.citygml4j.model.citygml.ade.binding.ADEModelObject;
+import org.citygml4j.model.common.visitor.GMLFunctor;
+import org.citygml4j.model.common.visitor.GMLVisitor;
+import org.citygml4j.model.gml.base.AbstractGML;
+import org.citygml4j.model.gml.basicTypes.Code;
+
+import java.time.ZonedDateTime;
+
+public abstract class AbstractSchedule extends AbstractGML implements ADEModelObject {
+
+    private Code libraryCode;
+    private Code ScheduleTypeValue;
+    private ZonedDateTime startTime;
+    private Integer startDay;
+    private Integer startMonth;
+    private Integer startYear;
+    private TimeIntervalLength temporalExtent;
+
+    public boolean isSetLibraryCode() {
+        return libraryCode != null;
+    }
+    public boolean isSetScheduleTypeValue() {
+        return ScheduleTypeValue != null;
+    }
+    public boolean isSetStartTime() {
+        return startTime != null;
+    }
+    public boolean isSetStartDay() {
+        return startDay != null;
+    }
+    public boolean isSetStartMonth() {
+        return startMonth != null;
+    }
+    public boolean isSetStartYear() {
+        return startYear != null;
+    }
+    public boolean isSetTemporalExtent() {
+        return temporalExtent != null;
+    }
+
+    public Code getLibraryCode() {
+        return libraryCode;
+    }
+
+    public void setLibraryCode(Code libraryCode) {
+        this.libraryCode = libraryCode;
+    }
+
+    public Code getScheduleTypeValue() {
+        return ScheduleTypeValue;
+    }
+
+    public void setScheduleTypeValue(Code scheduleTypeValue) {
+        ScheduleTypeValue = scheduleTypeValue;
+    }
+
+    public ZonedDateTime getStartTime() {
+        return startTime;
+    }
+
+    public void setStartTime(ZonedDateTime startTime) {
+        this.startTime = startTime;
+    }
+
+    public Integer getStartDay() {
+        return startDay;
+    }
+
+    public void setStartDay(Integer startDay) {
+        this.startDay = startDay;
+    }
+
+    public Integer getStartMonth() {
+        return startMonth;
+    }
+
+    public void setStartMonth(Integer startMonth) {
+        this.startMonth = startMonth;
+    }
+
+    public Integer getStartYear() {
+        return startYear;
+    }
+
+    public void setStartYear(Integer startYear) {
+        this.startYear = startYear;
+    }
+
+    public TimeIntervalLength getTemporalExtent() {
+        return temporalExtent;
+    }
+
+    public void setTemporalExtent(TimeIntervalLength temporalExtent) {
+        this.temporalExtent = temporalExtent;
+    }
+
+
+    @Override
+    public void accept(GMLVisitor visitor) {
+        visitor.visit(this);
+    }
+
+    @Override
+    public <T> T accept(GMLFunctor<T> visitor) {
+        return visitor.apply(this);
+    }
+}

src/main/java/org/citygml4j/ade/energy/model/supportingClasses/AbstractScheduleProperty.java

+/*
+ * energy-ade-citygml4j - Energy ADE module for citygml4j
+ * https://github.com/citygml4j/energy-ade-citygml4j
+ *
+ * energy-ade-citygml4j is part of the citygml4j project
+ *
+ * Copyright 2019-2024 Claus Nagel <claus.nagel@gmail.com>
+ *
+ * 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 org.citygml4j.ade.energy.model.supportingClasses;
+
+import org.citygml4j.builder.copy.CopyBuilder;
+import org.citygml4j.model.citygml.ade.binding.ADEModelObject;
+import org.citygml4j.model.gml.base.AssociationByRepOrRef;
+
+public class AbstractScheduleProperty extends AssociationByRepOrRef<AbstractSchedule> implements ADEModelObject {
+
+    public AbstractScheduleProperty() {
+    }
+
+    public AbstractScheduleProperty(AbstractSchedule abstractSchedule) {
+        super(abstractSchedule);
+    }
+
+    public AbstractScheduleProperty(String href) {
+        super(href);
+    }
+
+    public AbstractSchedule getAbstractSchedule() {
+        return super.getObject();
+    }
+
+    public boolean isSetAbstractSchedule() {
+        return super.isSetObject();
+    }
+
+    public void setAbstractSchedule(AbstractSchedule abstractSchedule) {
+        super.setObject(abstractSchedule);
+    }
+
+    public void unsetAbstractSchedule() {
+        super.unsetObject();
+    }
+
+    @Override
+    public Class<AbstractSchedule> getAssociableClass() {
+        return AbstractSchedule.class;
+    }
+
+    @Override
+    public Object copy(CopyBuilder copyBuilder) {
+        return copyTo(new AbstractScheduleProperty(), copyBuilder);
+    }
+
+    @Override
+    public Object copyTo(Object target, CopyBuilder copyBuilder) {
+        AbstractScheduleProperty copy = (target == null) ? new AbstractScheduleProperty() : (AbstractScheduleProperty) target;
+        return super.copyTo(copy, copyBuilder);
+    }
+}

src/main/java/org/citygml4j/ade/energy/model/supportingClasses/AbstractSolarCollector.java

+package org.citygml4j.ade.energy.model.supportingClasses;
+
+import org.citygml4j.model.citygml.ade.binding.ADEModelObject;
+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.geometry.aggregates.MultiSurfaceProperty;
+import org.citygml4j.model.gml.measures.Angle;
+import org.citygml4j.model.gml.measures.Area;
+
+public abstract class AbstractSolarCollector extends AbstractFeature implements ADEModelObject {
+
+    private Area moduleArea;
+    private Area apertureArea;
+    private Angle azimuth;
+    private Angle inclination;
+    private MultiSurfaceProperty lod2MultiSurface;
+    private MultiSurfaceProperty lod3MultiSurface;
+
+    public boolean isSetLod2MultiSurface() {
+        return lod2MultiSurface != null;
+    }
+    public boolean isSetLod3MultiSurface() {
+        return lod3MultiSurface != null;
+    }
+    public boolean isSetModuleArea() {
+        return moduleArea != null;
+    }
+    public boolean isSetApertureArea() {
+        return apertureArea != null;
+    }
+    public boolean isSetAzimuth() {
+        return azimuth != null;
+    }
+    public boolean isSetInclination() {
+        return inclination != null;
+    }
+
+    public Area getModuleArea() {
+        return moduleArea;
+    }
+
+    public void setModuleArea(Area moduleArea) {
+        this.moduleArea = moduleArea;
+    }
+
+    public Area getApertureArea() {
+        return apertureArea;
+    }
+
+    public void setApertureArea(Area apertureArea) {
+        this.apertureArea = apertureArea;
+    }
+
+    public Angle getAzimuth() {
+        return azimuth;
+    }
+
+    public void setAzimuth(Angle azimuth) {
+        this.azimuth = azimuth;
+    }
+
+    public Angle getInclination() {
+        return inclination;
+    }
+
+    public void setInclination(Angle inclination) {
+        this.inclination = inclination;
+    }
+
+    public MultiSurfaceProperty getLod2MultiSurface() {
+        return lod2MultiSurface;
+    }
+
+    public void setLod2MultiSurface(MultiSurfaceProperty lod2MultiSurface) {
+        this.lod2MultiSurface = lod2MultiSurface;
+    }
+
+    public MultiSurfaceProperty getLod3MultiSurface() {
+        return lod3MultiSurface;
+    }
+
+    public void setLod3MultiSurface(MultiSurfaceProperty lod3MultiSurface) {
+        this.lod3MultiSurface = lod3MultiSurface;
+    }
+
+    @Override
+    public void accept(GMLVisitor visitor) {
+        visitor.visit(this);
+    }
+
+    @Override
+    public <T> T accept(GMLFunctor<T> visitor) {
+        return visitor.apply(this);
+    }
+}

src/main/java/org/citygml4j/ade/energy/model/supportingClasses/AbstractSolarCollectorProperty.java

+package org.citygml4j.ade.energy.model.supportingClasses;
+
+import org.citygml4j.builder.copy.CopyBuilder;
+import org.citygml4j.model.citygml.ade.binding.ADEModelObject;
+import org.citygml4j.model.gml.base.AssociationByRepOrRef;
+
+public class AbstractSolarCollectorProperty extends AssociationByRepOrRef<AbstractSolarCollector> implements ADEModelObject {
+
+    public AbstractSolarCollectorProperty() {
+    }
+
+    public AbstractSolarCollectorProperty(AbstractSolarCollector abstractSolarCollector) {
+        super(abstractSolarCollector);
+    }
+
+    public AbstractSolarCollectorProperty(String href) {
+        super(href);
+    }
+
+    public AbstractSolarCollector getAbstractSolarCollector() {
+        return super.getObject();
+    }
+
+    public boolean isSetAbstractSolarCollector() {
+        return super.isSetObject();
+    }
+
+    public void setAbstractSolarCollector(AbstractSolarCollector abstractSolarCollector) {
+        super.setObject(abstractSolarCollector);
+    }
+
+    public void unsetAbstractSolarCollector() {
+        super.unsetObject();
+    }
+
+    @Override
+    public Class<AbstractSolarCollector> getAssociableClass() {
+        return AbstractSolarCollector.class;
+    }
+
+    @Override
+    public Object copy(CopyBuilder copyBuilder) {
+        return copyTo(new AbstractSolarCollectorProperty(), copyBuilder);
+    }
+
+    @Override
+    public Object copyTo(Object target, CopyBuilder copyBuilder) {
+        AbstractSolarCollectorProperty copy = (target == null) ? new AbstractSolarCollectorProperty() : (AbstractSolarCollectorProperty) target;
+        return super.copyTo(copy, copyBuilder);
+    }
+}

src/main/java/org/citygml4j/ade/energy/model/supportingClasses/AbstractTimeSeries.java

+package org.citygml4j.ade.energy.model.supportingClasses;
+
+import org.citygml4j.builder.copy.CopyBuilder;
+import org.citygml4j.model.citygml.ade.binding.ADEModelObject;
+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;
+
+public abstract class AbstractTimeSeries extends AbstractFeature implements ADEModelObject {
+
+    private Code acquisitionMethod;
+    private InterpolationTypeValue interpolationTypeValue;
+    private String source;
+
+    public InterpolationTypeValue getInterpolationTypeValue() {
+        return interpolationTypeValue;
+    }
+
+    public Code getAcquisitionMethod() {
+        return acquisitionMethod;
+    }
+
+    public String getSource() {
+        return source;
+    }
+
+    public boolean isSetAcquisitionMethod() {
+        return  acquisitionMethod != null;
+    }
+    public boolean isSetInterpolationTypeValue() { return (interpolationTypeValue != null); }
+    public boolean isSetSource() { return source != null; }
+
+    public void setAcquisitionMethod(Code acquisitionMethod) {
+        this.acquisitionMethod = acquisitionMethod;
+    }
+
+    public void setInterpolationTypeValue(InterpolationTypeValue interpolationTypeValue) {
+        this.interpolationTypeValue = interpolationTypeValue;
+    }
+
+    public void setSource(String source) {
+        this.source = source;
+    }
+
+    @Override
+    public void accept(GMLVisitor gmlVisitor) {
+        gmlVisitor.visit(this);
+    }
+
+    @Override
+    public <T> T accept(GMLFunctor<T> gmlFunctor) {
+        return null;
+    }
+
+    @Override
+    public Object copy(CopyBuilder copyBuilder) {
+        return null;
+    }
+
+}

src/main/java/org/citygml4j/ade/energy/model/supportingClasses/AbstractTimeSeriesProperty.java

+package org.citygml4j.ade.energy.model.supportingClasses;
+
+import org.citygml4j.builder.copy.CopyBuilder;
+import org.citygml4j.model.citygml.ade.binding.ADEModelObject;
+import org.citygml4j.model.gml.base.AssociationByRepOrRef;
+
+public class AbstractTimeSeriesProperty extends AssociationByRepOrRef<AbstractTimeSeries> implements ADEModelObject {
+
+    public AbstractTimeSeriesProperty() {
+    }
+
+    public AbstractTimeSeriesProperty(AbstractTimeSeries abstractTimeSeries) {
+        super(abstractTimeSeries);
+    }
+
+    public AbstractTimeSeriesProperty(String href) {
+        super(href);
+    }
+
+    public AbstractTimeSeries getAbstractTimeSeries() {
+        return super.getObject();
+    }
+
+    public boolean isSetAbstractTimeSeries() {
+        return super.isSetObject();
+    }
+
+    public void setAbstractTimeSeries(AbstractTimeSeries abstractTimeSeries) {
+        super.setObject(abstractTimeSeries);
+    }
+
+    public void unsetAbstractTimeSeries() {
+        super.unsetObject();
+    }
+
+    @Override
+    public Class<AbstractTimeSeries> getAssociableClass() {
+        return AbstractTimeSeries.class;
+    }
+
+    @Override
+    public Object copy(CopyBuilder copyBuilder) {
+        return copyTo(new AbstractTimeSeriesProperty(), copyBuilder);
+    }
+
+    @Override
+    public Object copyTo(Object target, CopyBuilder copyBuilder) {
+        AbstractTimeSeriesProperty copy = (target == null) ? new AbstractTimeSeriesProperty() : (AbstractTimeSeriesProperty) target;
+        return super.copyTo(copy, copyBuilder);
+    }
+}

src/main/java/org/citygml4j/ade/energy/model/supportingClasses/AtomicSchedule.java

+package org.citygml4j.ade.energy.model.supportingClasses;
+
+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.Measure;
+import org.citygml4j.model.gml.feature.AbstractFeature;
+
+public class AtomicSchedule extends AbstractFeature implements ADEModelObject {
+
+    private Measure constantValue;
+
+    public Measure getConstantValue() {
+        return constantValue;
+    }
+
+    public void setConstantValue(Measure constantValue) {
+        this.constantValue = constantValue;
+    }
+
+    public boolean isSetConstantValue() {
+        return constantValue != null;
+    }
+
+    @Override
+    public void accept(FeatureVisitor featureVisitor) {
+        featureVisitor.visit(this);
+    }
+
+    @Override
+    public <T> T accept(FeatureFunctor<T> featureFunctor) {
+        return featureFunctor.apply(this);
+    }
+
+    @Override
+    public void accept(GMLVisitor gmlVisitor) {
+        gmlVisitor.visit(this);
+    }
+
+    @Override
+    public <T> T accept(GMLFunctor<T> gmlFunctor) {
+        return gmlFunctor.apply(this);
+    }
+
+    @Override
+    public Object copy(CopyBuilder copyBuilder) {
+        return copyTo(new AtomicSchedule(), copyBuilder);
+    }
+}

src/main/java/org/citygml4j/ade/energy/model/supportingClasses/AtomicScheduleProperty.java

+package org.citygml4j.ade.energy.model.supportingClasses;
+
+import org.citygml4j.builder.copy.CopyBuilder;
+import org.citygml4j.model.citygml.ade.binding.ADEModelObject;
+import org.citygml4j.model.gml.base.AssociationByRepOrRef;
+
+public class AtomicScheduleProperty extends AssociationByRepOrRef<AtomicSchedule> implements ADEModelObject {
+
+    public AtomicScheduleProperty() {
+    }
+
+    public AtomicScheduleProperty(AtomicSchedule atomicSchedule) {
+        super(atomicSchedule);
+    }
+
+    public AtomicSchedule getAtomicSchedule() {
+        return super.getObject();
+    }
+
+    public boolean isSetAtomicSchedule() {
+        return super.isSetObject();
+    }
+
+    public void setAtomicSchedule(AtomicSchedule atomicSchedule) {
+        super.setObject(atomicSchedule);
+    }
+
+    public void unsetAtomicSchedule() {
+        super.unsetObject();
+    }
+
+    @Override
+    public Class<AtomicSchedule> getAssociableClass() {
+        return AtomicSchedule.class;
+    }
+
+    @Override
+    public Object copy(CopyBuilder copyBuilder) {
+        return copyTo(new AtomicScheduleProperty(), copyBuilder);
+    }
+
+    @Override
+    public Object copyTo(Object target, CopyBuilder copyBuilder) {
+        AtomicScheduleProperty copy = (target == null) ? new AtomicScheduleProperty() : (AtomicScheduleProperty) target;
+        return super.copyTo(copy, copyBuilder);
+    }
+}

src/main/java/org/citygml4j/ade/energy/model/supportingClasses/Boiler.java

+package org.citygml4j.ade.energy.model.supportingClasses;
+
+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 Boiler extends AbstractFeature implements ADEModelObject {
+
+    private Boolean hasCondensation;
+
+    public Boolean getHasCondensation() { return hasCondensation; }
+    public void setHasCondensation(Boolean hasCondensation) { this.hasCondensation = hasCondensation; }
+    public boolean isSetHasCondensation() { return hasCondensation;}
+
+    @Override
+    public Object copy(CopyBuilder copyBuilder) {
+        return copyTo(new Boiler(), copyBuilder);
+    }
+
+    @Override
+    public Object copyTo(Object target, CopyBuilder copyBuilder) {
+        Boiler copy = (target == null) ? new Boiler() : (Boiler) target;
+
+        if (isSetHasCondensation())
+            copy.setHasCondensation(hasCondensation);
+        return super.copyTo(copy, copyBuilder);
+    }
+
+
+    @Override
+    public void accept(FeatureVisitor visitor) {
+        visitor.visit(this);
+    }
+
+    @Override
+    public <T> T accept(FeatureFunctor<T> visitor) {
+        return visitor.apply(this);
+    }
+
+    @Override
+    public void accept(GMLVisitor visitor) {
+        visitor.visit(this);
+    }
+
+    @Override
+    public <T> T accept(GMLFunctor<T> visitor) {
+        return visitor.apply(this);
+    }
+
+}

src/main/java/org/citygml4j/ade/energy/model/supportingClasses/BoilerProperty.java

+package org.citygml4j.ade.energy.model.supportingClasses;
+
+import org.citygml4j.builder.copy.CopyBuilder;
+import org.citygml4j.model.citygml.ade.binding.ADEModelObject;
+import org.citygml4j.model.gml.base.AssociationByRepOrRef;
+
+public class BoilerProperty  extends AssociationByRepOrRef<Boiler> implements ADEModelObject {
+
+    public BoilerProperty() {
+    }
+
+    public BoilerProperty(Boiler boiler) {
+        super(boiler);
+    }
+
+    public BoilerProperty(String href) {
+        super(href);
+    }
+
+    public Boiler getBoiler() {
+        return super.getObject();
+    }
+
+    public boolean isSetBoiler() {
+        return super.isSetObject();
+    }
+
+    public void setBoiler(Boiler boiler) {
+        super.setObject(boiler);
+    }
+
+    public void unsetBoiler() {
+        super.unsetObject();
+    }
+
+    @Override
+    public Class<Boiler> getAssociableClass() {
+        return Boiler.class;
+    }
+
+    @Override
+    public Object copy(CopyBuilder copyBuilder) {
+        return copyTo(new BoilerProperty(), copyBuilder);
+    }
+
+    @Override
+    public Object copyTo(Object target, CopyBuilder copyBuilder) {
+        BoilerProperty copy = (target == null) ? new BoilerProperty() : (BoilerProperty) target;
+        return super.copyTo(copy, copyBuilder);
+    }
+}

src/main/java/org/citygml4j/ade/energy/model/supportingClasses/CompositeSchedule.java

+package org.citygml4j.ade.energy.model.supportingClasses;
+
+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 CompositeSchedule extends AbstractFeature implements ADEModelObject {
+
+    @Override
+    public void accept(FeatureVisitor featureVisitor) {
+        featureVisitor.visit(this);
+    }
+
+    @Override
+    public <T> T accept(FeatureFunctor<T> featureFunctor) {
+        return featureFunctor.apply(this);
+    }
+
+    @Override
+    public void accept(GMLVisitor gmlVisitor) {
+        gmlVisitor.visit(this);
+    }
+
+    @Override
+    public <T> T accept(GMLFunctor<T> gmlFunctor) {
+        return gmlFunctor.apply(this);
+    }
+
+    @Override
+    public Object copy(CopyBuilder copyBuilder) {
+        return copyTo(new CompositeSchedule(), copyBuilder);
+    }
+}

src/main/java/org/citygml4j/ade/energy/model/supportingClasses/CompositeScheduleProperty.java

+package org.citygml4j.ade.energy.model.supportingClasses;
+
+import org.citygml4j.builder.copy.CopyBuilder;
+import org.citygml4j.model.citygml.ade.binding.ADEModelObject;
+import org.citygml4j.model.gml.base.AssociationByRepOrRef;
+
+public class CompositeScheduleProperty extends AssociationByRepOrRef<CompositeSchedule> implements ADEModelObject {
+
+    public CompositeScheduleProperty() {
+    }
+
+    public CompositeScheduleProperty(CompositeSchedule compositeSchedule) {
+        super(compositeSchedule);
+    }
+
+    public CompositeSchedule getCompositeSchedule() {
+        return super.getObject();
+    }
+
+    public boolean isSetCompositeSchedule() {
+        return super.isSetObject();
+    }
+
+    public void setCompositeSchedule(CompositeSchedule compositeSchedule) {
+        super.setObject(compositeSchedule);
+    }
+
+    public void unsetCompositeSchedule() {
+        super.unsetObject();
+    }
+
+    @Override
+    public Class<CompositeSchedule> getAssociableClass() {
+        return CompositeSchedule.class;
+    }
+
+    @Override
+    public Object copy(CopyBuilder copyBuilder) {
+        return copyTo(new CompositeScheduleProperty(), copyBuilder);
+    }
+
+    @Override
+    public Object copyTo(Object target, CopyBuilder copyBuilder) {
+        CompositeScheduleProperty copy = (target == null) ? new CompositeScheduleProperty() : (CompositeScheduleProperty) target;
+        return super.copyTo(copy, copyBuilder);
+    }
+}

src/main/java/org/citygml4j/ade/energy/model/supportingClasses/ConstructionMaterial.java

+package org.citygml4j.ade.energy.model.supportingClasses;
+
+import org.citygml4j.ade.energy.model.core.AbstractResource;
+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;
+
+public class ConstructionMaterial extends AbstractResource implements ADEModelObject {
+
+    private Code constructionMaterialTypeValue;
+    private Code constructionMaterialEndUseValue;
+
+    public Code getConstructionMaterialTypeValue() {
+        return constructionMaterialTypeValue;
+    }
+
+    public void setConstructionMaterialTypeValue(Code constructionMaterialTypeValue) {
+        this.constructionMaterialTypeValue = constructionMaterialTypeValue;
+    }
+
+    public Code getConstructionMaterialEndUseValue() {
+        return constructionMaterialEndUseValue;
+    }
+
+    public void setConstructionMaterialEndUseValue(Code constructionMaterialEndUseValue) {
+        this.constructionMaterialEndUseValue = constructionMaterialEndUseValue;
+    }
+
+    public boolean isSetConstructionMaterialTypeValue() {
+        return constructionMaterialTypeValue != null;
+    }
+
+    public boolean isSetConstructionMaterialEndUseValue() {
+        return constructionMaterialEndUseValue != null;
+    }
+
+
+    @Override
+    public Object copy(CopyBuilder copyBuilder) {
+        return copyTo(new ConstructionMaterial(), copyBuilder);
+    }
+
+    @Override
+    public Object copyTo(Object target, CopyBuilder copyBuilder) {
+        ConstructionMaterial copy = (target == null) ? new ConstructionMaterial() : (ConstructionMaterial) target;
+
+        if (isSetConstructionMaterialTypeValue())
+            copy.setConstructionMaterialTypeValue((Code) copyBuilder.copy(constructionMaterialTypeValue));
+
+        if (isSetConstructionMaterialEndUseValue())
+            copy.setConstructionMaterialEndUseValue((Code) copyBuilder.copy(constructionMaterialEndUseValue));
+
+        return super.copyTo(copy, copyBuilder);
+    }
+
+    @Override
+    public void accept(FeatureVisitor featureVisitor) {
+        featureVisitor.visit(this);
+
+    }
+
+    @Override
+    public <T> T accept(FeatureFunctor<T> featureFunctor) {
+        return featureFunctor.apply(this);
+    }
+}

src/main/java/org/citygml4j/ade/energy/model/supportingClasses/ConstructionMaterialProperty.java

+package org.citygml4j.ade.energy.model.supportingClasses;
+
+import org.citygml4j.builder.copy.CopyBuilder;
+import org.citygml4j.model.citygml.ade.binding.ADEModelObject;
+import org.citygml4j.model.gml.base.AssociationByRepOrRef;
+
+public class ConstructionMaterialProperty extends AssociationByRepOrRef<ConstructionMaterial> implements ADEModelObject {
+
+    public ConstructionMaterialProperty() {
+    }
+
+    public ConstructionMaterialProperty(ConstructionMaterial constructionMaterial) {
+        super(constructionMaterial);
+    }
+
+    public ConstructionMaterialProperty(String href) {
+        super(href);
+    }
+
+    public ConstructionMaterial getConstructionMaterial() {
+        return super.getObject();
+    }
+
+    public boolean isSetConstructionMaterial() {
+        return super.isSetObject();
+    }
+
+    public void setConstructionMaterial(ConstructionMaterial constructionMaterial) {
+        super.setObject(constructionMaterial);
+    }
+
+    public void unsetConstructionMaterial() {
+        super.unsetObject();
+    }
+
+    @Override
+    public Class<ConstructionMaterial> getAssociableClass() {
+        return ConstructionMaterial.class;
+    }
+
+    @Override
+    public Object copy(CopyBuilder copyBuilder) {
+        return copyTo(new ConstructionMaterialProperty(), copyBuilder);
+    }
+
+    @Override
+    public Object copyTo(Object target, CopyBuilder copyBuilder) {
+        ConstructionMaterialProperty copy = (target == null) ? new ConstructionMaterialProperty() : (ConstructionMaterialProperty) target;
+        return super.copyTo(copy, copyBuilder);
+    }
+}

src/main/java/org/citygml4j/ade/energy/model/supportingClasses/DualValueSchedule.java

+package org.citygml4j.ade.energy.model.supportingClasses;
+
+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.Measure;
+import org.citygml4j.model.gml.feature.AbstractFeature;
+
+import javax.xml.datatype.XMLGregorianCalendar;
+
+public class DualValueSchedule extends AbstractFeature implements ADEModelObject {
+
+    private Measure idleValue;
+    private Measure usageValue;
+    private XMLGregorianCalendar startUsageTime;
+    private XMLGregorianCalendar endUsageTime;
+
+    public XMLGregorianCalendar getEndUsageTime() {
+        return endUsageTime;
+    }
+
+    public void setEndUsageTime(XMLGregorianCalendar endUsageTime) {
+        this.endUsageTime = endUsageTime;
+    }
+
+    public XMLGregorianCalendar getStartUsageTime() {
+        return startUsageTime;
+    }
+
+    public void setStartUsageTime(XMLGregorianCalendar startUsageTime) {
+        this.startUsageTime = startUsageTime;
+    }
+
+    public Measure getUsageValue() {
+        return usageValue;
+    }
+
+    public void setUsageValue(Measure usageValue) {
+        this.usageValue = usageValue;
+    }
+
+    public Measure getIdleValue() {
+        return idleValue;
+    }
+
+    public void setIdleValue(Measure idleValue) {
+        this.idleValue = idleValue;
+    }
+
+    public boolean isSetIdleValue() {
+        return idleValue != null;
+    }
+    public boolean isSetUsageValue() {
+        return usageValue != null;
+    }
+    public boolean isSetStartUsageTime() {
+        return startUsageTime != null;
+    }
+    public boolean isSetEndUsageTime() {
+        return endUsageTime != null;
+    }
+
+    @Override
+    public void accept(FeatureVisitor featureVisitor) {
+        featureVisitor.visit(this);
+    }
+
+    @Override
+    public <T> T accept(FeatureFunctor<T> featureFunctor) {
+        return featureFunctor.apply(this);
+    }
+
+    @Override
+    public void accept(GMLVisitor gmlVisitor) {
+        gmlVisitor.visit(this);
+    }
+
+    @Override
+    public <T> T accept(GMLFunctor<T> gmlFunctor) {
+        return gmlFunctor.apply(this);
+    }
+
+    @Override
+    public Object copy(CopyBuilder copyBuilder) {
+        return copyTo(new DualValueSchedule(), copyBuilder);
+    }
+
+}