    001    //$HeadURL: https://svn.wald.intevation.org/svn/deegree/base/branches/2.4_testing/src/org/deegree/model/feature/FeatureFactory.java $
    002    /*----------------------------------------------------------------------------
    003     This file is part of deegree, http://deegree.org/
    004     Copyright (C) 2001-2009 by:
    005       Department of Geography, University of Bonn
    006     and
    007       lat/lon GmbH
    008
    009     This library is free software; you can redistribute it and/or modify it under
    010     the terms of the GNU Lesser General Public License as published by the Free
    011     Software Foundation; either version 2.1 of the License, or (at your option)
    012     any later version.
    013     This library is distributed in the hope that it will be useful, but WITHOUT
    014     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    015     FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
    016     details.
    017     You should have received a copy of the GNU Lesser General Public License
    018     along with this library; if not, write to the Free Software Foundation, Inc.,
    019     59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
    020
    021     Contact information:
    022
    023     lat/lon GmbH
    024     Aennchenstr. 19, 53177 Bonn
    025     Germany
    026     http://lat-lon.de/
    027
    028     Department of Geography, University of Bonn
    029     Prof. Dr. Klaus Greve
    030     Postfach 1147, 53001 Bonn
    031     Germany
    032     http://www.geographie.uni-bonn.de/deegree/
    033
    034     e-mail: info@deegree.org
    035    ----------------------------------------------------------------------------*/
    036    package org.deegree.model.feature;
    037
    038    import java.net.URI;
    039    import java.util.List;
    040
    041    import org.deegree.datatypes.QualifiedName;
    042    import org.deegree.datatypes.Types;
    043    import org.deegree.datatypes.UnknownTypeException;
    044    import org.deegree.framework.log.ILogger;
    045    import org.deegree.framework.log.LoggerFactory;
    046    import org.deegree.model.feature.schema.DefaultFeatureType;
    047    import org.deegree.model.feature.schema.FeaturePropertyType;
    048    import org.deegree.model.feature.schema.FeatureType;
    049    import org.deegree.model.feature.schema.GeometryPropertyType;
    050    import org.deegree.model.feature.schema.MultiGeometryPropertyType;
    051    import org.deegree.model.feature.schema.PropertyType;
    052    import org.deegree.model.feature.schema.SimplePropertyType;
    053    import org.deegree.ogcbase.CommonNamespaces;
    054
    055    /**
    056     * This factory offers methods for creating Features, FeatureCollection and all direct related
    057     * classes/interfaces that are part of the org.deegree.model.feature package.
    058     *
    059     * @author <a href="mailto:poth@lat-lon.de">Andreas Poth</a>
    060     * @author last edited by: $Author: mschneider $
    061     *
    062     * @version $Revision: 18195 $, $Date: 2009-06-18 17:55:39 +0200 (Do, 18. Jun 2009) $
    063     */
    064    public class FeatureFactory {
    065
    066        private final static ILogger LOG = LoggerFactory.getLogger( FeatureFactory.class );
    067
    068        private static URI GMLNS = CommonNamespaces.GMLNS;
    069
    070        /**
    071         * Creates an instance of a <code>PropertyType</code> from the given parameters.
    072         * <p>
    073         * Determines the right type from the given type name.
    074         *
    075         * @param name
    076         *            name of the property type
    077         * @param typeName
    078         *            type name of the property type
    079         * @param nullable
    080         *            set to true, if property type may be omitted
    081         * @return corresponding PropertyType instance
    082         * @throws UnknownTypeException
    083         */
    084        public static PropertyType createPropertyType( QualifiedName name, QualifiedName typeName, boolean nullable )
    085                                throws UnknownTypeException {
    086            return createPropertyType( name, typeName, nullable ? 0 : 1, 1 );
    087        }
    088
    089        /**
    090         * Creates an instance of a <code>PropertyType</code> from the given parameters.
    091         * <p>
    092         * Determines the right type from the given type name.
    093         *
    094         * @param name
    095         *            name of the property type
    096         * @param typeName
    097         *            type name of the property type
    098         * @param minOccurs
    099         * @param maxOccurs
    100         * @return corresponding PropertyType instance
    101         * @throws UnknownTypeException
    102         */
    103        public static PropertyType createPropertyType( QualifiedName name, QualifiedName typeName, int minOccurs,
    104                                                       int maxOccurs )
    105                                throws UnknownTypeException {
    106
    107            PropertyType type = null;
    108
    109            int typeCode = determinePropertyType( typeName );
    110            switch ( typeCode ) {
    111            case Types.FEATURE: {
    112                type = new FeaturePropertyType( name, typeName, typeCode, minOccurs, maxOccurs );
    113                break;
    114            }
    115            case Types.GEOMETRY: {
    116                type = new GeometryPropertyType( name, typeName, typeCode, minOccurs, maxOccurs );
    117                break;
    118            }
    119            case Types.MULTIGEOMETRY: {
    120                type = new MultiGeometryPropertyType( name, typeName, typeCode, minOccurs, maxOccurs );
    121                break;
    122            }
    123            default: {
    124                type = new SimplePropertyType( name, typeCode, minOccurs, maxOccurs );
    125            }
    126            }
    127            return type;
    128        }
    129
    130        /**
    131         * Creates an instance of a <code>SimplePropertyType</code> from the given parameters.
    132         *
    133         * @param name
    134         *            name of the property type
    135         * @param typeCode
    136         *            type code of the property type
    137         * @param nullable
    138         *            set to true, if property type may be omitted
    139         * @return generated SimplePropertyType instance
    140         * @see Types
    141         */
    142        public static PropertyType createSimplePropertyType( QualifiedName name, int typeCode, boolean nullable ) {
    143            return createSimplePropertyType( name, typeCode, nullable ? 0 : 1, 1 );
    144        }
    145
    146        /**
    147         * Creates an instance of a <code>SimplePropertyType</code> from the given parameters.
    148         *
    149         * @param name
    150         *            name of the property type
    151         * @param typeCode
    152         *            type code of the property type
    153         * @param minOccurs
    154         * @param maxOccurs
    155         * @return generated SimplePropertyType instance
    156         * @see Types
    157         */
    158        public static SimplePropertyType createSimplePropertyType( QualifiedName name, int typeCode, int minOccurs,
    159                                                                   int maxOccurs ) {
    160            return new SimplePropertyType( name, typeCode, minOccurs, maxOccurs );
    161        }
    162
    163        /**
    164         * Creates an instance of a <code>GeometryPropertyType</code> from the given parameters.
    165         *
    166         * @param name
    167         *            name of the property type
    168         * @param typeName
    169         *            typeName of the property type
    170         * @param minOccurs
    171         * @param maxOccurs
    172         * @return generated GeometryPropertyType instance
    173         * @see Types
    174         */
    175        public static GeometryPropertyType createGeometryPropertyType( QualifiedName name, QualifiedName typeName,
    176                                                                       int minOccurs, int maxOccurs ) {
    177            return new GeometryPropertyType( name, typeName, Types.GEOMETRY, minOccurs, maxOccurs );
    178        }
    179
    180        /**
    181         * Creates an instance of a <code>FeaturePropertyType</code> from the given parameters.
    182         *
    183         * @param name
    184         *            name of the property type
    185         * @param minOccurs
    186         * @param maxOccurs
    187         * @return generated FeaturePropertyType instance
    188         * @see Types
    189         */
    190        public static FeaturePropertyType createFeaturePropertyType( QualifiedName name, int minOccurs, int maxOccurs ) {
    191            return new FeaturePropertyType( name, Types.FEATURE_PROPERTY_NAME, Types.FEATURE, minOccurs, maxOccurs );
    192        }
    193
    194        /**
    195         * Determines the type code for the given type name.
    196         *
    197         * @param typeName
    198         *            name to determine
    199         * @return type code for the given type name
    200         * @throws UnknownTypeException
    201         *             if the type name cannot be determined
    202         * @see Types
    203         */
    204        public static int determinePropertyType( QualifiedName typeName )
    205                                throws UnknownTypeException {
    206            LOG.logDebug( "Determining property type code for property type='" + typeName + "'..." );
    207            int type = Types.FEATURE;
    208            if ( typeName.isInNamespace( CommonNamespaces.XSNS ) ) {
    209                LOG.logDebug( "Must be a basic XSD type." );
    210                try {
    211                    type = Types.getJavaTypeForXSDType( typeName.getLocalName() );
    212                } catch ( UnknownTypeException e ) {
    213                    throw new UnknownTypeException( e );
    214                }
    215            } else if ( typeName.isInNamespace( GMLNS ) ) {
    216                LOG.logDebug( "Maybe a geometry property type?" );
    217                try {
    218                    type = Types.getJavaTypeForGMLType( typeName.getLocalName() );
    219                    LOG.logDebug( "Yes." );
    220                } catch ( UnknownTypeException e ) {
    221                    LOG.logDebug( "No. Should be a generic GML feature of some kind." );
    222                    // TODO check all possible GML types here, feature array property type
    223                }
    224            } else {
    225                throw new UnknownTypeException( "Cannot determine property type for type '" + typeName + "'." );
    226            }
    227            return type;
    228        }
    229
    230        /**
    231         * creates an instance of a FeatureType from an array of FeatureTypeProperties, and its name but
    232         * without parents and childs
    233         *
    234         * @param name
    235         *            name of the <code>FeatureType</code>
    236         * @param isAbstract
    237         *            <code>true</code> if the feature type to create is abstract, <code>false</code>
    238         *            otherwise
    239         * @param properties
    240         *            properties containing the <code>FeatureType</code>s content
    241         * @return instance of a <code>FeatureType</code>
    242         */
    243        public static FeatureType createFeatureType( QualifiedName name, boolean isAbstract, PropertyType[] properties ) {
    244            return new DefaultFeatureType( name, isAbstract, properties );
    245        }
    246
    247        /**
    248         * creates an instance of a FeatureType from an array of FeatureTypeProperties, and its name but
    249         * without parents and childs
    250         *
    251         * @param name
    252         *            name of the <code>FeatureType</code>
    253         * @param isAbstract
    254         *            <code>true</code> if the feature type to create is abstract, <code>false</code>
    255         *            otherwise
    256         * @param properties
    257         *            properties containing the <code>FeatureType</code>s content
    258         * @return instance of a <code>FeatureType</code>
    259         */
    260        public static FeatureType createFeatureType( String name, boolean isAbstract, PropertyType[] properties ) {
    261            return new DefaultFeatureType( new QualifiedName( name ), isAbstract, properties );
    262        }
    263
    264        /**
    265         * creates an instance of a FeatureType from an array of FeatureTypeProperties, and its name but
    266         * without parents and childs
    267         *
    268         * @param name
    269         *            name of the <code>FeatureType</code>
    270         * @param isAbstract
    271         *            <code>true</code> if the feature type to create is abstract, <code>false</code>
    272         *            otherwise
    273         * @param schemaLocation
    274         * @param properties
    275         *            properties containing the <code>FeatureType</code>s content
    276         * @return instance of a <code>FeatureType</code>
    277         */
    278        public static FeatureType createFeatureType( QualifiedName name, boolean isAbstract, URI schemaLocation,
    279                                                     PropertyType[] properties ) {
    280            return new DefaultFeatureType( name, isAbstract, schemaLocation, properties );
    281        }
    282
    283        /**
    284         * creates an instance of a FeatureType from an array of FeatureTypeProperties, and its name but
    285         * without parents and childs
    286         *
    287         * @param name
    288         *            name of the <code>FeatureType</code>
    289         * @param isAbstract
    290         *            <code>true</code> if the feature type to create is abstract, <code>false</code>
    291         *            otherwise
    292         * @param schemaLocation
    293         * @param properties
    294         *            properties containing the <code>FeatureType</code>s content
    295         * @return instance of a <code>FeatureType</code>
    296         */
    297        public static FeatureType createFeatureType( String name, boolean isAbstract, URI schemaLocation,
    298                                                     PropertyType[] properties ) {
    299            QualifiedName gName = new QualifiedName( name );
    300            return new DefaultFeatureType( gName, isAbstract, schemaLocation, properties );
    301        }
    302
    303        /**
    304         * creates an instance of a FeatureProperty from its name and the data (value) it contains
    305         *
    306         * @param name
    307         *            name of the <code>FeatureProperty</code>
    308         * @return an instance of a <code>FeatureProperty</code>
    309         * @param value
    310         *            value of the <code>FeatureProperty</code>
    311         */
    312        public static FeatureProperty createFeatureProperty( QualifiedName name, Object value ) {
    313            return new DefaultFeatureProperty( name, value );
    314        }
    315
    316        /**
    317         * creates an instance of a FeatureProperty from its name and the data (value) it contains
    318         *
    319         * @param name
    320         *            name of the <code>FeatureProperty</code>
    321         * @return an instance of a <code>FeatureProperty</code>
    322         * @param value
    323         *            value of the <code>FeatureProperty</code>
    324         * @deprecated use {@link #createFeatureProperty (QualifiedName, Object)} instead
    325         */
    326        @Deprecated
    327        public static FeatureProperty createFeatureProperty( String name, Object value ) {
    328            QualifiedName qn = new QualifiedName( name );
    329            return new DefaultFeatureProperty( qn, value );
    330        }
    331
    332        /**
    333         * creates an instance of a Feature from its FeatureType and an array of Objects that represents
    334         * it properties. It is assumed that the order of the properties is identical to the order of
    335         * the FeatureTypeProperties of the the FeatureType.
    336         *
    337         * @param id
    338         *            unique id of the <code>Feature</code>
    339         * @param featureType
    340         *            <code>FeatureType</code> of the <code>Feature</code>
    341         * @param properties
    342         *            properties (content) of the <code>Feature</code>
    343         * @return instance of a <code>Feature</code>
    344         */
    345        public static Feature createFeature( String id, FeatureType featureType, FeatureProperty[] properties ) {
    346            return new DefaultFeature( id, featureType, properties );
    347        }
    348
    349        /**
    350         * creates an instance of a Feature from its FeatureType and an array of Objects that represents
    351         * it properties. It is assumed that the order of the properties is identical to the order of
    352         * the FeatureTypeProperties of the the FeatureType.
    353         *
    354         * @param id
    355         *            unique id of the <code>Feature</code>
    356         * @param featureType
    357         *            <code>FeatureType</code> of the <code>Feature</code>
    358         * @param properties
    359         *            properties (content) of the <code>Feature</code>
    360         * @return instance of a <code>Feature</code>
    361         */
    362        public static Feature createFeature( String id, FeatureType featureType, List<FeatureProperty> properties ) {
    363            FeatureProperty[] fps = properties.toArray( new FeatureProperty[properties.size()] );
    364            return new DefaultFeature( id, featureType, fps );
    365        }
    366
    367        /**
    368         * creates an instance of a FeatureCollection with an initial capacity. The returned
    369         * FeatureCollection doesn't have a FeatureType nor properties. It is just a collection of
    370         * Features.
    371         *
    372         * @param id
    373         *            unique id of the <code>FeatureCollection</code>
    374         * @param initialCapacity
    375         *            initial capacity of the <code>FeatureCollection</code>
    376         * @return instance of an empty <code>FeatureCollection</code>
    377         */
    378        public static FeatureCollection createFeatureCollection( String id, int initialCapacity ) {
    379            return new DefaultFeatureCollection( id, initialCapacity );
    380        }
    381
    382        /**
    383         * creates an instance of a FeatureCollection from an array of Features. The returned
    384         * FeatureCollection doesn't have a FeatureType nor properties. It is just a collection of
    385         * Features.
    386         *
    387         * @param id
    388         *            unique id of the <code>FeatureCollection</code> instance
    389         * @param features
    390         *            <code>Feature</code>s to fill in into the <code>FeatureCollection</code>
    391         * @return instance of a <code>FeatureCollection</code> containing the submitted features
    392         */
    393        public static FeatureCollection createFeatureCollection( String id, Feature[] features ) {
    394            return new DefaultFeatureCollection( id, features );
    395        }
    396
    397        /**
    398         * creates an instance of a FeatureCollection from an array of Features. The returned
    399         * FeatureCollection doesn't have a FeatureType nor properties. It is just a collection of
    400         * Features. With it's name set to the given qualifiedName
    401         *
    402         * @param id
    403         *            unique id of the <code>FeatureCollection</code> instance
    404         * @param features
    405         *            <code>Feature</code>s to fill in into the <code>FeatureCollection</code>
    406         * @param qName
    407         *            name of the featureCollection
    408         * @return instance of a <code>FeatureCollection</code> containing the submitted features
    409         */
    410        public static FeatureCollection createFeatureCollection( String id, Feature[] features, QualifiedName qName ) {
    411            return new DefaultFeatureCollection( id, features, qName );
    412        }
    413
    414        /**
    415         * Creates a {@link FeatureTupleCollection} for the given feature tuples.
    416         *
    417         * @param id
    418         *            id for the <code>FeatureCollection</code> instance
    419         * @param featureTuples
    420         *            list of feature tuples (array length must match tupleLength parameter)
    421         * @param tupleLength
    422         *            number of features per tuple
    423         * @return <code>FeatureTupleCollection</code> containing the given feature tuples
    424         */
    425        public static FeatureTupleCollection createFeatureCollection( String id, List<Feature[]> featureTuples,
    426                                                                      int tupleLength ) {
    427            return new FeatureTupleCollection( id, featureTuples, tupleLength );
    428        }
    429    }