com.kscs.jaxb2.contract.test.Import Maven / Gradle / Ivy

Go to download
//
// Diese Datei wurde mit der Eclipse Implementation of JAXB, v4.0.2 generiert 
// Siehe https://eclipse-ee4j.github.io/jaxb-ri 
// Änderungen an dieser Datei gehen bei einer Neukompilierung des Quellschemas verloren. 
//


package com.kscs.jaxb2.contract.test;

import java.util.HashMap;
import java.util.Map;
import javax.xml.namespace.QName;
import com.kscs.util.jaxb.Buildable;
import com.kscs.util.jaxb.PropertyTree;
import com.kscs.util.jaxb.PropertyTreeUse;
import com.kscs.util.jaxb.PropertyVisitor;
import com.kscs.util.jaxb.SingleProperty;
import com.kscs.util.jaxb.SinglePropertyInfo;
import com.kscs.util.jaxb.SinglePropertyInfo;
import jakarta.xml.bind.annotation.XmlAccessType;
import jakarta.xml.bind.annotation.XmlAccessorType;
import jakarta.xml.bind.annotation.XmlElement;
import jakarta.xml.bind.annotation.XmlType;


/**
 * import complex type annotation. And this is some extra text to test that line breaking is working correctly.
 * 
 * Java-Klasse für import complex type.
 * 
 * 
Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist.
 * 
 * 
{@code
 * 
 *   
 *     
 *       
 *         
 *       
 *     
 *   
 * 
 * }
 * 
 * 
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "import", propOrder = {
    "_import"
})
public class Import implements Cloneable
{

    @XmlElement(name = "import", required = true)
    protected String _import;
    protected transient Import.Modifier __cachedModifier__;

    /**
     * Ruft den Wert der import-Eigenschaft ab.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getImport() {
        return _import;
    }

    /**
     * Legt den Wert der import-Eigenschaft fest.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    protected void setImport(String value) {
        this._import = value;
    }

    @Override
    public Import clone() {
        final Import _newObject;
        try {
            _newObject = ((Import) super.clone());
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
        return _newObject;
    }

    /**
     * Copies all state of this object to a builder. This method is used by the copyOf
     * method and should not be called directly by client code.
     * 
     * @param _other
     *     A builder instance to which the state of this object will be copied.
     */
    public<_B >void copyTo(final Import.Builder<_B> _other) {
        _other._import = this._import;
    }

    public<_B >Import.Builder<_B> newCopyBuilder(final _B _parentBuilder) {
        return new Import.Builder<_B>(_parentBuilder, this, true);
    }

    public Import.Builder newCopyBuilder() {
        return newCopyBuilder(null);
    }

    public static Import.Builder builder() {
        return new Import.Builder<>(null, null, false);
    }

    public static<_B >Import.Builder<_B> copyOf(final Import _other) {
        final Import.Builder<_B> _newBuilder = new Import.Builder<>(null, null, false);
        _other.copyTo(_newBuilder);
        return _newBuilder;
    }

    /**
     * Copies all state of this object to a builder. This method is used by the copyOf
     * method and should not be called directly by client code.
     * 
     * @param _other
     *     A builder instance to which the state of this object will be copied.
     */
    public<_B >void copyTo(final Import.Builder<_B> _other, final PropertyTree _propertyTree, final PropertyTreeUse _propertyTreeUse) {
        final PropertyTree _importPropertyTree = ((_propertyTree == null)?null:_propertyTree.get("_import"));
        if (((_propertyTreeUse == PropertyTreeUse.INCLUDE)?(_importPropertyTree!= null):((_importPropertyTree == null)||(!_importPropertyTree.isLeaf())))) {
            _other._import = this._import;
        }
    }

    public<_B >Import.Builder<_B> newCopyBuilder(final _B _parentBuilder, final PropertyTree _propertyTree, final PropertyTreeUse _propertyTreeUse) {
        return new Import.Builder<_B>(_parentBuilder, this, true, _propertyTree, _propertyTreeUse);
    }

    public Import.Builder newCopyBuilder(final PropertyTree _propertyTree, final PropertyTreeUse _propertyTreeUse) {
        return newCopyBuilder(null, _propertyTree, _propertyTreeUse);
    }

    public static<_B >Import.Builder<_B> copyOf(final Import _other, final PropertyTree _propertyTree, final PropertyTreeUse _propertyTreeUse) {
        final Import.Builder<_B> _newBuilder = new Import.Builder<>(null, null, false);
        _other.copyTo(_newBuilder, _propertyTree, _propertyTreeUse);
        return _newBuilder;
    }

    public static Import.Builder copyExcept(final Import _other, final PropertyTree _propertyTree) {
        return copyOf(_other, _propertyTree, PropertyTreeUse.EXCLUDE);
    }

    public static Import.Builder copyOnly(final Import _other, final PropertyTree _propertyTree) {
        return copyOf(_other, _propertyTree, PropertyTreeUse.INCLUDE);
    }

    public Import.Modifier modifier() {
        if (null == this.__cachedModifier__) {
            this.__cachedModifier__ = new Import.Modifier();
        }
        return ((Import.Modifier) this.__cachedModifier__);
    }

    public Import visit(final PropertyVisitor _visitor_) {
        _visitor_.visit(this);
        _visitor_.visit(new SingleProperty<>(Import.PropInfo._import, this));
        return this;
    }

    public static class Builder<_B >implements Buildable
    {

        protected final _B _parentBuilder;
        protected final Import _storedValue;
        private String _import;

        public Builder(final _B _parentBuilder, final Import _other, final boolean _copy) {
            this._parentBuilder = _parentBuilder;
            if (_other!= null) {
                if (_copy) {
                    _storedValue = null;
                    this._import = _other._import;
                } else {
                    _storedValue = _other;
                }
            } else {
                _storedValue = null;
            }
        }

        public Builder(final _B _parentBuilder, final Import _other, final boolean _copy, final PropertyTree _propertyTree, final PropertyTreeUse _propertyTreeUse) {
            this._parentBuilder = _parentBuilder;
            if (_other!= null) {
                if (_copy) {
                    _storedValue = null;
                    final PropertyTree _importPropertyTree = ((_propertyTree == null)?null:_propertyTree.get("_import"));
                    if (((_propertyTreeUse == PropertyTreeUse.INCLUDE)?(_importPropertyTree!= null):((_importPropertyTree == null)||(!_importPropertyTree.isLeaf())))) {
                        this._import = _other._import;
                    }
                } else {
                    _storedValue = _other;
                }
            } else {
                _storedValue = null;
            }
        }

        public _B end() {
            return this._parentBuilder;
        }

        protected<_P extends Import >_P init(final _P _product) {
            _product._import = this._import;
            return _product;
        }

        /**
         * Setzt den neuen Wert der Eigenschaft "_import" (Vorher zugewiesener Wert wird
         * ersetzt)
         * 
         * @param _import
         *     Neuer Wert der Eigenschaft "_import".
         */
        public Import.Builder<_B> withImport(final String _import) {
            this._import = _import;
            return this;
        }

        @Override
        public Import build() {
            if (_storedValue == null) {
                return this.init(new Import());
            } else {
                return ((Import) _storedValue);
            }
        }

        public Import.Builder<_B> copyOf(final Import _other) {
            _other.copyTo(this);
            return this;
        }

        public Import.Builder<_B> copyOf(final Import.Builder _other) {
            return copyOf(_other.build());
        }

    }

    public class Modifier {


        public void setImport(final String _import) {
            Import.this.setImport(_import);
        }

    }

    public static class PropInfo {

        public static final transient SinglePropertyInfo _import = new SinglePropertyInfo("_import", Import.class, String.class, false, null, new QName("http://www.kscs.com/jaxb2/contract/test", "import"), new QName("http://www.w3.org/2001/XMLSchema", "string"), false) {


            @Override
            public String get(final Import _instance_) {
                return ((_instance_ == null)?null:_instance_._import);
            }

            @Override
            public void set(final Import _instance_, final String _value_) {
                if (_instance_!= null) {
                    _instance_._import = _value_;
                }
            }

        }
        ;

    }

    public static class Select
        extends Import.Selector
    {


        Select() {
            super(null, null, null);
        }

        public static Import.Select _root() {
            return new Import.Select();
        }

    }

    public static class Selector , TParent >
        extends com.kscs.util.jaxb.Selector
    {

        private com.kscs.util.jaxb.Selector> _import = null;

        public Selector(final TRoot root, final TParent parent, final String propertyName) {
            super(root, parent, propertyName);
        }

        @Override
        public Map buildChildren() {
            final Map products = new HashMap<>();
            products.putAll(super.buildChildren());
            if (this._import!= null) {
                products.put("_import", this._import.init());
            }
            return products;
        }

        public com.kscs.util.jaxb.Selector> _import() {
            return ((this._import == null)?this._import = new com.kscs.util.jaxb.Selector<>(this._root, this, "_import"):this._import);
        }

    }

}