Upgrade to beta 8

src/main/java/org/citygml4j/ade/energy3/bind/EnergyADEMarshaller.java

@@ -2029,6 +2029,9 @@ public class EnergyADEMarshaller implements ADEMarshaller {
         if (src.isSetYieldsMoney()) {
             dest.setYieldsMoney(helper.getGMLMarshaller().marshalMeasure(src.getYieldsMoney()));
         }
+        if (src.isReferencePeriod()){
+            dest.setReferencePeriod(helper.getGMLMarshaller().marshalCode(src.getReferencePeriodValue()));
+        }
 
         return dest;
     }
@@ -2071,6 +2074,122 @@ public class EnergyADEMarshaller implements ADEMarshaller {
         return dest;
     }
 
+    /*
+     * Does marshalling of AbstractADEFeature.
+     */
+    private AbstractADEFeatureType marshalAbstractADEFeature(AbstractADEFeature src, AbstractADEFeatureType dest) {
+
+        helper.getGMLMarshaller().marshalAbstractGML(src, dest);
+
+        if (src.isCreationDate())
+        {
+            dest.setCreationDate(src.getCreationDate());
+        }
+        if (src.isTerminationDate())
+        {
+            dest.setTerminationDate(src.getTerminationDate());
+        }
+        return dest;
+    }
+
+    /*
+     * Convert AbstractADEFeatureProperty to AbstractADEFeaturePropertyType.
+     */
+    private AbstractADEFeaturePropertyType marshalAbstractADEFeatureProperty(AbstractADEFeatureProperty src) {
+        AbstractADEFeaturePropertyType dest = factory.createAbstractADEFeaturePropertyType();
+
+        if (src.isSetAbstractADEFeature()) {
+            JAXBElement<?> elem = helper.getJAXBMarshaller().marshalJAXBElement(src.getAbstractADEFeature());
+            if (elem != null && elem.getValue() instanceof AbstractADEFeatureType)
+                dest.setAbstractADEFeature((JAXBElement<? extends AbstractADEFeatureType>) elem);
+        }
+        if (src.isSetRemoteSchema())
+            dest.setRemoteSchema(src.getRemoteSchema());
+
+        if (src.isSetType())
+            dest.setType(TypeType.fromValue(src.getType().getValue()));
+
+        if (src.isSetHref())
+            dest.setHref(src.getHref());
+
+        if (src.isSetRole())
+            dest.setRole(src.getRole());
+
+        if (src.isSetArcrole())
+            dest.setArcrole(src.getArcrole());
+
+        if (src.isSetTitle())
+            dest.setTitle(src.getTitle());
+
+        if (src.isSetShow())
+            dest.setShow(ShowType.fromValue(src.getShow().getValue()));
+
+        if (src.isSetActuate())
+            dest.setActuate(ActuateType.fromValue(src.getActuate().getValue()));
+
+        return dest;
+    }
+
+
+    /*
+     * Does marshalling of AbstractFeatureWithLifeSpan.
+     */
+    private AbstractFeatureWithLifeSpanType marshalAbstractFeatureWithLifeSpan(AbstractFeatureWithLifeSpan src, AbstractFeatureWithLifeSpanType dest) {
+
+        helper.getGMLMarshaller().marshalAbstractGML(src, dest);
+
+        if (src.isIdentifier())
+        {
+            dest.setIdentifier(helper.getGMLMarshaller().marshalCode(src.getIdentifier()));
+        }
+        if (src.isValidFrom())
+        {
+            dest.setValidFrom(src.getValidFrom());
+        }
+        if (src.isValidTo()){
+            dest.setValidTo(src.getValidTo());
+        }
+        return dest;
+    }
+
+    /*
+     * Convert AbstractFeatureWithLifeSpanProperty to AbstractFeatureWithLifeSpanPropertyType.
+     */
+    private AbstractFeatureWithLifeSpanPropertyType marshalAbstractFeatureWithLifeSpanProperty(AbstractFeatureWithLifeSpanProperty src) {
+        AbstractFeatureWithLifeSpanPropertyType dest = factory.createAbstractFeatureWithLifeSpanPropertyType();
+
+        if (src.isSetAbstractFeatureWithLifeSpan()) {
+            JAXBElement<?> elem = helper.getJAXBMarshaller().marshalJAXBElement(src.getAbstractFeatureWithLifeSpan());
+            if (elem != null && elem.getValue() instanceof AbstractFeatureWithLifeSpanType)
+                dest.setAbstractFeatureWithLifeSpan((JAXBElement<? extends AbstractFeatureWithLifeSpanType>) elem);
+        }
+        if (src.isSetRemoteSchema())
+            dest.setRemoteSchema(src.getRemoteSchema());
+
+        if (src.isSetType())
+            dest.setType(TypeType.fromValue(src.getType().getValue()));
+
+        if (src.isSetHref())
+            dest.setHref(src.getHref());
+
+        if (src.isSetRole())
+            dest.setRole(src.getRole());
+
+        if (src.isSetArcrole())
+            dest.setArcrole(src.getArcrole());
+
+        if (src.isSetTitle())
+            dest.setTitle(src.getTitle());
+
+        if (src.isSetShow())
+            dest.setShow(ShowType.fromValue(src.getShow().getValue()));
+
+        if (src.isSetActuate())
+            dest.setActuate(ActuateType.fromValue(src.getActuate().getValue()));
+
+        return dest;
+    }
+
     private QualifiedAreaType marshalQualifiedArea(QualifiedArea src) {
         QualifiedAreaType dest = new QualifiedAreaType();
         if (src.getDescription() != null && src.getDescription().getValue() != null && !src.getDescription().getValue().trim().isEmpty()) {

src/main/java/org/citygml4j/ade/energy3/bind/EnergyADEUnmarshaller.java

@@ -1308,11 +1308,135 @@ public class EnergyADEUnmarshaller implements ADEUnmarshaller {
         if (src.isSetYieldsMoney()){
             dest.setYieldsMoney(helper.getGMLUnmarshaller().unmarshalMeasure(src.getYieldsMoney()));
         }
+        if (src.isSetReferencePeriod()){
+            dest.setReferencePeriodValue(helper.getGMLUnmarshaller().unmarshalCode(src.getReferencePeriod()));
+        }
+
+        return dest;
+
+    }
+
+    /*
+     * Convert AbstractADEFeatureType to AbstractADEFeature.
+     */
+    private AbstractADEFeature unmarshalAbstractADEFeature(AbstractADEFeatureType src, AbstractADEFeature dest) throws MissingADESchemaException {
+
+        helper.getGMLUnmarshaller().unmarshalAbstractGML(src, dest);
+        if( src.isSetCreationDate()){
+            dest.setCreationDate(src.getCreationDate());
+        }
+        if(src.isSetTerminationDate()){
+            dest.setTerminationDate(src.getTerminationDate());
+        }
+        if (src.isSetExternalReference()){
+            dest.setExternalReference(src.getExternalReference());
+        }
+
+        return dest;
+
+    }
+
+    /*
+     * Convert AbstractADEFeaturePropertyType to AbstractADEFeatureProperty.
+     */
+    private AbstractADEFeatureProperty unmarshalAbstractADEFeatureProperty(AbstractADEFeaturePropertyType src) throws MissingADESchemaException {
+        AbstractADEFeatureProperty dest = new AbstractADEFeatureProperty();
+
+        if (src.isSetAbstractADEFeature()) {
+            ADEModelObject temp = unmarshal(src.getAbstractADEFeature());
+            if (temp instanceof AbstractADEFeature) {
+                dest.setAbstractADEFeature((AbstractADEFeature) temp);
+            }
+        }
+
+        if (src.isSetRemoteSchema())
+            dest.setRemoteSchema(src.getRemoteSchema());
+
+        if (src.isSetType())
+            dest.setType(XLinkType.fromValue(src.getType().value()));
+
+        if (src.isSetHref())
+            dest.setHref(src.getHref());
+
+        if (src.isSetRole())
+            dest.setRole(src.getRole());
+
+        if (src.isSetArcrole())
+            dest.setArcrole(src.getArcrole());
+
+        if (src.isSetTitle())
+            dest.setTitle(src.getTitle());
+
+        if (src.isSetShow())
+            dest.setShow(XLinkShow.fromValue(src.getShow().value()));
+
+        if (src.isSetActuate())
+            dest.setActuate(XLinkActuate.fromValue(src.getActuate().value()));
+
+        return dest;
+    }
+
+    /*
+     * Convert AbstractFeatureWithLifeSpanType to AbstractFeatureWithLifeSpan.
+     */
+    private AbstractFeatureWithLifeSpan unmarshalAbstractFeatureWithLifeSpan(AbstractFeatureWithLifeSpanType src, AbstractFeatureWithLifeSpan dest) throws MissingADESchemaException {
+
+        helper.getGMLUnmarshaller().unmarshalAbstractGML(src, dest);
+        if( src.isSetIdentifier()){
+            dest.setIdentifier(helper.getGMLUnmarshaller().unmarshalCode(src.getIdentifier()));
+        }
+        if(src.isSetValidFrom()){
+            dest.setValidFrom(src.getValidFrom());
+        }
+        if (src.isSetValidTo()){
+            dest.setValidTo(src.getValidTo());
+        }
 
         return dest;
 
     }
 
+    /*
+     * Convert AbstractFeatureWithLifeSpanPropertyType to AbstractFeatureWithLifeSpanProperty.
+     */
+    private AbstractFeatureWithLifeSpanProperty AbstractFeatureWithLifeSpanProperty(AbstractFeatureWithLifeSpanPropertyType src) throws MissingADESchemaException {
+        AbstractFeatureWithLifeSpanProperty dest = new AbstractFeatureWithLifeSpanProperty();
+
+        if (src.isSetAbstractFeatureWithLifeSpan()) {
+            ADEModelObject temp = unmarshal(src.getAbstractFeatureWithLifeSpan());
+            if (temp instanceof AbstractFeatureWithLifeSpan) {
+                dest.setAbstractFeatureWithLifeSpan((AbstractFeatureWithLifeSpan) temp);
+            }
+        }
+
+        if (src.isSetRemoteSchema())
+            dest.setRemoteSchema(src.getRemoteSchema());
+
+        if (src.isSetType())
+            dest.setType(XLinkType.fromValue(src.getType().value()));
+
+        if (src.isSetHref())
+            dest.setHref(src.getHref());
+
+        if (src.isSetRole())
+            dest.setRole(src.getRole());
+
+        if (src.isSetArcrole())
+            dest.setArcrole(src.getArcrole());
+
+        if (src.isSetTitle())
+            dest.setTitle(src.getTitle());
+
+        if (src.isSetShow())
+            dest.setShow(XLinkShow.fromValue(src.getShow().value()));
+
+        if (src.isSetActuate())
+            dest.setActuate(XLinkActuate.fromValue(src.getActuate().value()));
+
+        return dest;
+    }
+
+
     private WeatherData unmarshalWeatherData(WeatherDataType src) throws MissingADESchemaException {
         WeatherData dest = new WeatherData();
         if (src.isSetType())

src/main/java/org/citygml4j/ade/energy3/model/core/AbstractResource.java

 package org.citygml4j.ade.energy3.model.core;
 
+import org.citygml4j.ade.energy3.model.supportingClasses.AbstractFeatureWithLifeSpan;
+import org.citygml4j.ade.energy3.model.supportingClasses.AbstractFeatureWithLifeSpanProperty;
 import org.citygml4j.ade.energy3.model.supportingClasses.AbstractTimeSeriesProperty;
 import org.citygml4j.builder.copy.CopyBuilder;
 import org.citygml4j.model.citygml.ade.binding.ADEModelObject;
@@ -9,10 +11,9 @@ 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.basicTypes.Measure;
-import org.citygml4j.model.gml.feature.AbstractFeature;
 import org.sig3d.citygml.energyADE3beta8.ResourceStatusValueType;
 
-public abstract class AbstractResource extends AbstractFeature implements ADEModelObject {
+public abstract class AbstractResource extends AbstractFeatureWithLifeSpan implements ADEModelObject {
 
     private ResourceStatusValueType status;
     private Code operationType;
@@ -22,10 +23,19 @@ public abstract class AbstractResource extends AbstractFeature implements ADEMod
     private Boolean isAmountNormalized;
     private Measure normalizationValue;
     private String normalizationParameter;
-    private  Measure co2Equivalent;
+    private Measure co2Equivalent;
     private Integer year;
-    private  Measure costsMoney;
-    private  Measure yieldsMoney;
+    private Measure costsMoney;
+    private Measure yieldsMoney;
+    private Code referencePeriodValue;
+
+    public Code getReferencePeriodValue() {
+        return referencePeriodValue;
+    }
+
+    public void setReferencePeriodValue(Code referencePeriodValue) {
+        referencePeriodValue = referencePeriodValue;
+    }
 
     public Measure getCo2Equivalent() {
         return co2Equivalent;
@@ -124,40 +134,55 @@ public abstract class AbstractResource extends AbstractFeature implements ADEMod
     }
 
     public boolean isSetStatus() {
-        return  status!= null;
+        return status != null;
     }
+
     public boolean isSetOperationType() {
-        return  operationType != null;
+        return operationType != null;
     }
+
     public boolean isSetAmountType() {
-        return  amountType != null;
+        return amountType != null;
     }
-    public boolean isSetAmountNormalized(){
+
+    public boolean isSetAmountNormalized() {
         return isAmountNormalized;
     }
+
     public boolean isSetNormalizationValue() {
         return normalizationValue != null;
     }
+
     public boolean isSetCo2Equivalent() {
-        return  co2Equivalent != null;
+        return co2Equivalent != null;
     }
+
     public boolean isSetNormalizationParameter() {
         return normalizationParameter != null;
     }
+
     public boolean isSetYear() {
-        return  year != null;
+        return year != null;
     }
+
     public boolean isSetCostsMoney() {
-        return  costsMoney != null;
+        return costsMoney != null;
     }
+
     public boolean isSetYieldsMoney() {
-        return  yieldsMoney != null;
+        return yieldsMoney != null;
     }
+
     public boolean isSetTimeDependentAmount() {
-        return  timeDependentAmount != null;
+        return timeDependentAmount != null;
+    }
+
+    public boolean isSetAmount() {
+        return amount != null;
     }
-    public boolean isSetAmount(){
-        return  amount != null;
+
+    public boolean isReferencePeriod() {
+        return referencePeriodValue!=null;
     }
 
     @Override
@@ -172,7 +197,7 @@ public abstract class AbstractResource extends AbstractFeature implements ADEMod
 
     @Override
     public Object copy(CopyBuilder copyBuilder) {
-        return copyTo(new AbstractResourceProperty(), copyBuilder);
+        return copyTo(new AbstractFeatureWithLifeSpanProperty(), copyBuilder);
     }
 
     @Override

src/main/java/org/citygml4j/ade/energy3/model/supportingClasses/AbstractADEFeature.java

+package org.citygml4j.ade.energy3.model.supportingClasses;
+
+import net.opengis.citygml._2.ExternalReferenceType;
+import org.citygml4j.builder.copy.CopyBuilder;
+import org.citygml4j.model.citygml.ade.binding.ADEModelObject;
+import org.citygml4j.model.citygml.core.ExternalReference;
+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 javax.xml.datatype.XMLGregorianCalendar;
+import java.util.List;
+
+public class AbstractADEFeature extends AbstractFeature implements ADEModelObject {
+
+    private XMLGregorianCalendar creationDate;
+    private XMLGregorianCalendar terminationDate;
+    private List<ExternalReferenceType> externalReference;
+
+    public void setExternalReference(List<ExternalReferenceType> externalReference) {
+        this.externalReference = externalReference;
+    }
+
+    public  boolean isExternalReference() {
+        return !externalReference.isEmpty();
+    }
+    public List<ExternalReferenceType> getExternalReference() {
+        return externalReference;
+    }
+
+    public XMLGregorianCalendar getCreationDate() {
+        return creationDate;
+    }
+
+    public void setCreationDate(XMLGregorianCalendar creationDate) {
+        this.creationDate = creationDate;
+    }
+
+    public XMLGregorianCalendar getTerminationDate() {
+        return terminationDate;
+    }
+
+    public void setTerminationDate(XMLGregorianCalendar terminationDate) {
+        this.terminationDate = terminationDate;
+    }
+    public boolean isCreationDate() {
+        return creationDate != null;
+    }
+    public boolean isTerminationDate() {
+        return terminationDate != null;
+    }
+
+    @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 AbstractADEFeatureProperty(), 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/energy3/model/supportingClasses/AbstractADEFeatureProperty.java

+package org.citygml4j.ade.energy3.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 AbstractADEFeatureProperty extends AssociationByRepOrRef<AbstractADEFeature> implements ADEModelObject {
+
+    public AbstractADEFeatureProperty() {
+    }
+
+    public AbstractADEFeatureProperty(AbstractADEFeature abstractADEFeature) {
+        super(abstractADEFeature);
+    }
+
+    public AbstractADEFeatureProperty(String href) {
+        super(href);
+    }
+
+    public AbstractADEFeature getAbstractADEFeatureProperty() {
+        return super.getObject();
+    }
+    public boolean isSetAbstractADEFeatureProperty() {
+        return super.isSetObject();
+    }
+
+    public boolean isSetAbstractADEFeature() {
+        return super.isSetObject();
+    }
+    public AbstractADEFeature getAbstractADEFeature() {
+        return super.getObject();
+    }
+
+    public void setAbstractADEFeature(AbstractADEFeature abstractFeatureWithLifeSpan) {
+        super.setObject(abstractFeatureWithLifeSpan);
+    }
+
+    public void unsetAbstractADEFeature() {
+        super.unsetObject();
+    }
+
+    @Override
+    public Class<AbstractADEFeature> getAssociableClass() {
+        return AbstractADEFeature.class;
+    }
+
+    @Override
+    public Object copy(CopyBuilder copyBuilder) {
+        return copyTo(new AbstractADEFeatureProperty(), copyBuilder);
+    }
+
+    @Override
+    public Object copyTo(Object target, CopyBuilder copyBuilder) {
+        AbstractADEFeatureProperty copy = (target == null) ? new AbstractADEFeatureProperty() : (AbstractADEFeatureProperty) target;
+        return super.copyTo(copy, copyBuilder);
+    }
+}

src/main/java/org/citygml4j/ade/energy3/model/supportingClasses/AbstractFeatureWithLifeSpan.java

+package org.citygml4j.ade.energy3.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.Code;
+import org.citygml4j.model.gml.feature.AbstractFeature;
+
+import javax.xml.datatype.XMLGregorianCalendar;
+
+public class AbstractFeatureWithLifeSpan extends AbstractFeature implements ADEModelObject {
+
+    private Code identifier;
+    private XMLGregorianCalendar validFrom;
+    private XMLGregorianCalendar validTo;
+
+    public boolean isIdentifier(){
+        return identifier != null;
+    }
+    public boolean isValidFrom(){
+        return validFrom != null;
+    }
+    public boolean isValidTo(){
+        return validTo != null;
+    }
+    public Code getIdentifier() {
+        return identifier;
+    }
+
+    public void setIdentifier(Code identifier) {
+        this.identifier = identifier;
+    }
+
+    public XMLGregorianCalendar getValidFrom() {
+        return validFrom;
+    }
+
+    public void setValidFrom(XMLGregorianCalendar validFrom) {
+        this.validFrom = validFrom;
+    }
+
+    public XMLGregorianCalendar getValidTo() {
+        return validTo;
+    }
+
+    public void setValidTo(XMLGregorianCalendar validTo) {
+        this.validTo = validTo;
+    }
+
+    @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 AbstractFeatureWithLifeSpanProperty(), 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/energy3/model/supportingClasses/AbstractFeatureWithLifeSpanProperty.java

+package org.citygml4j.ade.energy3.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 AbstractFeatureWithLifeSpanProperty  extends AssociationByRepOrRef<AbstractFeatureWithLifeSpan> implements ADEModelObject {
+
+    public AbstractFeatureWithLifeSpanProperty() {
+    }
+
+    public AbstractFeatureWithLifeSpanProperty(AbstractFeatureWithLifeSpan abstractFeatureWithLifeSpan) {
+        super(abstractFeatureWithLifeSpan);
+    }
+
+    public AbstractFeatureWithLifeSpanProperty(String href) {
+        super(href);
+    }
+
+    public AbstractFeatureWithLifeSpan getAbstractFeatureWithLifeSpanProperty() {
+        return super.getObject();
+    }
+
+    public boolean isSetAbstractFeatureWithLifeSpan() {
+        return super.isSetObject();
+    }
+    public AbstractFeatureWithLifeSpan getAbstractFeatureWithLifeSpan() {
+        return super.getObject();
+    }
+
+    public void setAbstractFeatureWithLifeSpan(AbstractFeatureWithLifeSpan abstractFeatureWithLifeSpan) {
+        super.setObject(abstractFeatureWithLifeSpan);
+    }
+
+    public void unsetAbstractFeatureWithLifeSpan() {
+        super.unsetObject();
+    }
+
+    @Override
+    public Class<AbstractFeatureWithLifeSpan> getAssociableClass() {
+        return AbstractFeatureWithLifeSpan.class;
+    }
+
+    @Override
+    public Object copy(CopyBuilder copyBuilder) {
+        return copyTo(new AbstractFeatureWithLifeSpanProperty(), copyBuilder);
+    }
+
+    @Override
+    public Object copyTo(Object target, CopyBuilder copyBuilder) {
+        AbstractFeatureWithLifeSpanProperty copy = (target == null) ? new AbstractFeatureWithLifeSpanProperty() : (AbstractFeatureWithLifeSpanProperty) target;
+        return super.copyTo(copy, copyBuilder);
+    }
+}