Source Code Cross Referenced for GMLSchema.java in  » GIS » GeoTools-2.4.1 » org » geotools » gml2 » Java Source Code / Java DocumentationJava Source Code and Java Documentation

0001:        /*
0002:         *    GeoTools - OpenSource mapping toolkit
0003:         *    http://geotools.org
0004:         *    (C) 2002-2006, GeoTools Project Managment Committee (PMC)
0005:         *
0006:         *    This library is free software; you can redistribute it and/or
0007:         *    modify it under the terms of the GNU Lesser General Public
0008:         *    License as published by the Free Software Foundation;
0009:         *    version 2.1 of the License.
0010:         *
0011:         *    This library is distributed in the hope that it will be useful,
0012:         *    but WITHOUT ANY WARRANTY; without even the implied warranty of
0013:         *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
0014:         *    Lesser General Public License for more details.
0015:         */
0016:        package org.geotools.gml2;
0017:
0018:        import com.vividsolutions.jts.geom.Envelope;
0019:        import com.vividsolutions.jts.geom.LineString;
0020:        import com.vividsolutions.jts.geom.LinearRing;
0021:        import com.vividsolutions.jts.geom.MultiLineString;
0022:        import com.vividsolutions.jts.geom.MultiPoint;
0023:        import com.vividsolutions.jts.geom.MultiPolygon;
0024:        import com.vividsolutions.jts.geom.Point;
0025:        import com.vividsolutions.jts.geom.Polygon;
0026:        import org.geotools.feature.AttributeType;
0027:        import org.geotools.feature.AttributeTypeFactory;
0028:        import org.geotools.feature.Name;
0029:        import org.geotools.feature.type.SchemaImpl;
0030:
0031:        public class GMLSchema extends SchemaImpl {
0032:            /**
0033:             * <p>
0034:             *  <pre>
0035:             *   <code>
0036:             *  &lt;complexType name="LinearRingMemberType"&gt;
0037:             *      &lt;annotation&gt;
0038:             *          &lt;documentation&gt;Restricts the outer or inner boundary of a polygon instance
0039:             *                          to being a LinearRing.&lt;/documentation&gt;
0040:             *      &lt;/annotation&gt;
0041:             *      &lt;complexContent&gt;
0042:             *          &lt;restriction base="gml:GeometryAssociationType"&gt;
0043:             *              &lt;sequence minOccurs="0"&gt;
0044:             *                  &lt;element ref="gml:LinearRing"/&gt;
0045:             *              &lt;/sequence&gt;
0046:             *              &lt;attributeGroup ref="gml:AssociationAttributeGroup"/&gt;
0047:             *          &lt;/restriction&gt;
0048:             *      &lt;/complexContent&gt;
0049:             *  &lt;/complexType&gt;
0050:             *
0051:             *    </code>
0052:             *   </pre>
0053:             * </p>
0054:             *
0055:             * @generated
0056:             */
0057:            public static final AttributeType LINEARRINGMEMBERTYPE_TYPE = AttributeTypeFactory
0058:                    .newAttributeType("LinearRingMemberType", LinearRing.class);
0059:
0060:            /**
0061:             * <p>
0062:             *  <pre>
0063:             *   <code>
0064:             *  &lt;simpleType name="NullType"&gt;
0065:             *      &lt;annotation&gt;
0066:             *          &lt;documentation&gt;
0067:             *          If a bounding shape is not provided for a feature collection,
0068:             *          explain why. Allowable values are:
0069:             *          innapplicable - the features do not have geometry
0070:             *          unknown - the boundingBox cannot be computed
0071:             *          unavailable - there may be a boundingBox but it is not divulged
0072:             *          missing - there are no features
0073:             *        &lt;/documentation&gt;
0074:             *      &lt;/annotation&gt;
0075:             *      &lt;restriction base="string"&gt;
0076:             *          &lt;enumeration value="inapplicable"/&gt;
0077:             *          &lt;enumeration value="unknown"/&gt;
0078:             *          &lt;enumeration value="unavailable"/&gt;
0079:             *          &lt;enumeration value="missing"/&gt;
0080:             *      &lt;/restriction&gt;
0081:             *  &lt;/simpleType&gt;
0082:             *
0083:             *    </code>
0084:             *   </pre>
0085:             * </p>
0086:             *
0087:             * @generated
0088:             */
0089:            public static final AttributeType NULLTYPE_TYPE = AttributeTypeFactory
0090:                    .newAttributeType("NullType", java.lang.Object.class);
0091:
0092:            /**
0093:             * <p>
0094:             *  <pre>
0095:             *   <code>
0096:             *  &lt;complexType name="LineStringPropertyType"&gt;
0097:             *      &lt;annotation&gt;
0098:             *          &lt;documentation&gt;
0099:             *          Encapsulates a single LineString to represent centerLineOf or
0100:             *          edgeOf properties.
0101:             *        &lt;/documentation&gt;
0102:             *      &lt;/annotation&gt;
0103:             *      &lt;complexContent&gt;
0104:             *          &lt;restriction base="gml:GeometryAssociationType"&gt;
0105:             *              &lt;sequence minOccurs="0"&gt;
0106:             *                  &lt;element ref="gml:LineString"/&gt;
0107:             *              &lt;/sequence&gt;
0108:             *              &lt;attributeGroup ref="xlink:simpleLink"/&gt;
0109:             *              &lt;attribute ref="gml:remoteSchema" use="optional"/&gt;
0110:             *          &lt;/restriction&gt;
0111:             *      &lt;/complexContent&gt;
0112:             *  &lt;/complexType&gt;
0113:             *
0114:             *    </code>
0115:             *   </pre>
0116:             * </p>
0117:             *
0118:             * @generated
0119:             */
0120:            public static final AttributeType LINESTRINGPROPERTYTYPE_TYPE = AttributeTypeFactory
0121:                    .newAttributeType("LineStringPropertyType",
0122:                            LineString.class);
0123:
0124:            /**
0125:             * <p>
0126:             *  <pre>
0127:             *   <code>
0128:             *  &lt;complexType name="BoxType"&gt;
0129:             *      &lt;annotation&gt;
0130:             *          &lt;documentation&gt;
0131:             *          The Box structure defines an extent using a pair of coordinate tuples.
0132:             *        &lt;/documentation&gt;
0133:             *      &lt;/annotation&gt;
0134:             *      &lt;complexContent&gt;
0135:             *          &lt;extension base="gml:AbstractGeometryType"&gt;
0136:             *              &lt;sequence&gt;
0137:             *                  &lt;choice&gt;
0138:             *                      &lt;element maxOccurs="2" minOccurs="2" ref="gml:coord"/&gt;
0139:             *                      &lt;element ref="gml:coordinates"/&gt;
0140:             *                  &lt;/choice&gt;
0141:             *              &lt;/sequence&gt;
0142:             *          &lt;/extension&gt;
0143:             *      &lt;/complexContent&gt;
0144:             *  &lt;/complexType&gt;
0145:             *
0146:             *    </code>
0147:             *   </pre>
0148:             * </p>
0149:             *
0150:             * @generated
0151:             */
0152:            public static final AttributeType BOXTYPE_TYPE = AttributeTypeFactory
0153:                    .newAttributeType("BoxType", Envelope.class);
0154:
0155:            /**
0156:             * <p>
0157:             *  <pre>
0158:             *   <code>
0159:             *  &lt;complexType name="MultiPolygonType"&gt;
0160:             *      &lt;annotation&gt;
0161:             *          &lt;documentation&gt;
0162:             *          A MultiPolygon is defined by one or more Polygons, referenced through
0163:             *          polygonMember elements.
0164:             *        &lt;/documentation&gt;
0165:             *      &lt;/annotation&gt;
0166:             *      &lt;complexContent&gt;
0167:             *          &lt;restriction base="gml:GeometryCollectionType"&gt;
0168:             *              &lt;sequence&gt;
0169:             *                  &lt;element maxOccurs="unbounded" ref="gml:polygonMember"/&gt;
0170:             *              &lt;/sequence&gt;
0171:             *              &lt;attribute name="gid" type="ID" use="optional"/&gt;
0172:             *              &lt;attribute name="srsName" type="anyURI" use="required"/&gt;
0173:             *          &lt;/restriction&gt;
0174:             *      &lt;/complexContent&gt;
0175:             *  &lt;/complexType&gt;
0176:             *
0177:             *    </code>
0178:             *   </pre>
0179:             * </p>
0180:             *
0181:             * @generated
0182:             */
0183:            public static final AttributeType MULTIPOLYGONTYPE_TYPE = AttributeTypeFactory
0184:                    .newAttributeType("MultiPolygonType", MultiPolygon.class);
0185:
0186:            /**
0187:             * <p>
0188:             *  <pre>
0189:             *   <code>
0190:             *  &lt;complexType name="MultiPolygonPropertyType"&gt;
0191:             *      &lt;annotation&gt;
0192:             *          &lt;documentation&gt;
0193:             *          Encapsulates a MultiPolygon to represent the following discontiguous
0194:             *          geometric properties: multiCoverage, multiExtentOf.
0195:             *        &lt;/documentation&gt;
0196:             *      &lt;/annotation&gt;
0197:             *      &lt;complexContent&gt;
0198:             *          &lt;restriction base="gml:GeometryAssociationType"&gt;
0199:             *              &lt;sequence minOccurs="0"&gt;
0200:             *                  &lt;element ref="gml:MultiPolygon"/&gt;
0201:             *              &lt;/sequence&gt;
0202:             *              &lt;attributeGroup ref="xlink:simpleLink"/&gt;
0203:             *              &lt;attribute ref="gml:remoteSchema" use="optional"/&gt;
0204:             *          &lt;/restriction&gt;
0205:             *      &lt;/complexContent&gt;
0206:             *  &lt;/complexType&gt;
0207:             *
0208:             *    </code>
0209:             *   </pre>
0210:             * </p>
0211:             *
0212:             * @generated
0213:             */
0214:            public static final AttributeType MULTIPOLYGONPROPERTYTYPE_TYPE = AttributeTypeFactory
0215:                    .newAttributeType("MultiPolygonPropertyType",
0216:                            MultiPolygon.class);
0217:
0218:            /**
0219:             * <p>
0220:             *  <pre>
0221:             *   <code>
0222:             *  &lt;complexType name="PointMemberType"&gt;
0223:             *      &lt;annotation&gt;
0224:             *          &lt;documentation&gt;Restricts the geometry member to being a Point instance.&lt;/documentation&gt;
0225:             *      &lt;/annotation&gt;
0226:             *      &lt;complexContent&gt;
0227:             *          &lt;restriction base="gml:GeometryAssociationType"&gt;
0228:             *              &lt;sequence minOccurs="0"&gt;
0229:             *                  &lt;element ref="gml:Point"/&gt;
0230:             *              &lt;/sequence&gt;
0231:             *              &lt;attributeGroup ref="gml:AssociationAttributeGroup"/&gt;
0232:             *          &lt;/restriction&gt;
0233:             *      &lt;/complexContent&gt;
0234:             *  &lt;/complexType&gt;
0235:             *
0236:             *    </code>
0237:             *   </pre>
0238:             * </p>
0239:             *
0240:             * @generated
0241:             */
0242:            public static final AttributeType POINTMEMBERTYPE_TYPE = AttributeTypeFactory
0243:                    .newAttributeType("PointMemberType", Point.class);
0244:
0245:            /**
0246:             * <p>
0247:             *  <pre>
0248:             *   <code>
0249:             *  &lt;complexType name="BoundingShapeType"&gt;
0250:             *      &lt;annotation&gt;
0251:             *          &lt;documentation&gt;
0252:             *          Bounding shapes--a Box or a null element are currently allowed.
0253:             *        &lt;/documentation&gt;
0254:             *      &lt;/annotation&gt;
0255:             *      &lt;sequence&gt;
0256:             *          &lt;choice&gt;
0257:             *              &lt;element ref="gml:Box"/&gt;
0258:             *              &lt;element name="null" type="gml:NullType"/&gt;
0259:             *          &lt;/choice&gt;
0260:             *      &lt;/sequence&gt;
0261:             *  &lt;/complexType&gt;
0262:             *
0263:             *    </code>
0264:             *   </pre>
0265:             * </p>
0266:             *
0267:             * @generated
0268:             */
0269:            public static final AttributeType BOUNDINGSHAPETYPE_TYPE = AttributeTypeFactory
0270:                    .newAttributeType("BoundingShapeType",
0271:                            java.lang.Object.class);
0272:
0273:            /**
0274:             * <p>
0275:             *  <pre>
0276:             *   <code>
0277:             *  &lt;complexType name="MultiPointType"&gt;
0278:             *      &lt;annotation&gt;
0279:             *          &lt;documentation&gt;
0280:             *          A MultiPoint is defined by one or more Points, referenced through
0281:             *          pointMember elements.
0282:             *        &lt;/documentation&gt;
0283:             *      &lt;/annotation&gt;
0284:             *      &lt;complexContent&gt;
0285:             *          &lt;restriction base="gml:GeometryCollectionType"&gt;
0286:             *              &lt;sequence&gt;
0287:             *                  &lt;element maxOccurs="unbounded" ref="gml:pointMember"/&gt;
0288:             *              &lt;/sequence&gt;
0289:             *              &lt;attribute name="gid" type="ID" use="optional"/&gt;
0290:             *              &lt;attribute name="srsName" type="anyURI" use="required"/&gt;
0291:             *          &lt;/restriction&gt;
0292:             *      &lt;/complexContent&gt;
0293:             *  &lt;/complexType&gt;
0294:             *
0295:             *    </code>
0296:             *   </pre>
0297:             * </p>
0298:             *
0299:             * @generated
0300:             */
0301:            public static final AttributeType MULTIPOINTTYPE_TYPE = AttributeTypeFactory
0302:                    .newAttributeType("MultiPointType", MultiPoint.class);
0303:
0304:            /**
0305:             * <p>
0306:             *  <pre>
0307:             *   <code>
0308:             *  &lt;complexType name="MultiPointPropertyType"&gt;
0309:             *      &lt;annotation&gt;
0310:             *          &lt;documentation&gt;
0311:             *          Encapsulates a MultiPoint element to represent the following
0312:             *          discontiguous geometric properties: multiLocation, multiPosition,
0313:             *          multiCenterOf.
0314:             *        &lt;/documentation&gt;
0315:             *      &lt;/annotation&gt;
0316:             *      &lt;complexContent&gt;
0317:             *          &lt;restriction base="gml:GeometryAssociationType"&gt;
0318:             *              &lt;sequence minOccurs="0"&gt;
0319:             *                  &lt;element ref="gml:MultiPoint"/&gt;
0320:             *              &lt;/sequence&gt;
0321:             *              &lt;attributeGroup ref="xlink:simpleLink"/&gt;
0322:             *              &lt;attribute ref="gml:remoteSchema" use="optional"/&gt;
0323:             *          &lt;/restriction&gt;
0324:             *      &lt;/complexContent&gt;
0325:             *  &lt;/complexType&gt;
0326:             *
0327:             *    </code>
0328:             *   </pre>
0329:             * </p>
0330:             *
0331:             * @generated
0332:             */
0333:            public static final AttributeType MULTIPOINTPROPERTYTYPE_TYPE = AttributeTypeFactory
0334:                    .newAttributeType("MultiPointPropertyType",
0335:                            MultiPoint.class);
0336:
0337:            /**
0338:             * <p>
0339:             *  <pre>
0340:             *   <code>
0341:             *  &lt;complexType name="PolygonType"&gt;
0342:             *      &lt;annotation&gt;
0343:             *          &lt;documentation&gt;
0344:             *          A Polygon is defined by an outer boundary and zero or more inner
0345:             *          boundaries which are in turn defined by LinearRings.
0346:             *        &lt;/documentation&gt;
0347:             *      &lt;/annotation&gt;
0348:             *      &lt;complexContent&gt;
0349:             *          &lt;extension base="gml:AbstractGeometryType"&gt;
0350:             *              &lt;sequence&gt;
0351:             *                  &lt;element ref="gml:outerBoundaryIs"/&gt;
0352:             *                  &lt;element maxOccurs="unbounded" minOccurs="0" ref="gml:innerBoundaryIs"/&gt;
0353:             *              &lt;/sequence&gt;
0354:             *          &lt;/extension&gt;
0355:             *      &lt;/complexContent&gt;
0356:             *  &lt;/complexType&gt;
0357:             *
0358:             *    </code>
0359:             *   </pre>
0360:             * </p>
0361:             *
0362:             * @generated
0363:             */
0364:            public static final AttributeType POLYGONTYPE_TYPE = AttributeTypeFactory
0365:                    .newAttributeType("PolygonType", Polygon.class);
0366:
0367:            /**
0368:             * <p>
0369:             *  <pre>
0370:             *   <code>
0371:             *  &lt;complexType name="FeatureAssociationType"&gt;
0372:             *      &lt;annotation&gt;
0373:             *          &lt;documentation&gt;
0374:             *          An instance of this type (e.g. a featureMember) can either
0375:             *          enclose or point to a feature (or feature collection); this
0376:             *          type can be restricted in an application schema to allow only
0377:             *          specified features as valid participants in the association.
0378:             *          When serving as a simple link that references a remote feature
0379:             *          instance, the value of the gml:remoteSchema attribute can be
0380:             *          used to locate a schema fragment that constrains the target
0381:             *          instance.
0382:             *        &lt;/documentation&gt;
0383:             *      &lt;/annotation&gt;
0384:             *      &lt;sequence minOccurs="0"&gt;
0385:             *          &lt;element ref="gml:_Feature"/&gt;
0386:             *      &lt;/sequence&gt;
0387:             *      &lt;attributeGroup ref="xlink:simpleLink"/&gt;
0388:             *      &lt;attribute ref="gml:remoteSchema" use="optional"/&gt;
0389:             *  &lt;/complexType&gt;
0390:             *
0391:             *    </code>
0392:             *   </pre>
0393:             * </p>
0394:             *
0395:             * @generated
0396:             */
0397:            public static final AttributeType FEATUREASSOCIATIONTYPE_TYPE = AttributeTypeFactory
0398:                    .newAttributeType("FeatureAssociationType",
0399:                            java.lang.Object.class);
0400:
0401:            /**
0402:             * <p>
0403:             *  <pre>
0404:             *   <code>
0405:             *  &lt;complexType name="PolygonMemberType"&gt;
0406:             *      &lt;annotation&gt;
0407:             *          &lt;documentation&gt;Restricts the geometry member to being a Polygon instance.&lt;/documentation&gt;
0408:             *      &lt;/annotation&gt;
0409:             *      &lt;complexContent&gt;
0410:             *          &lt;restriction base="gml:GeometryAssociationType"&gt;
0411:             *              &lt;sequence minOccurs="0"&gt;
0412:             *                  &lt;element ref="gml:Polygon"/&gt;
0413:             *              &lt;/sequence&gt;
0414:             *              &lt;attributeGroup ref="gml:AssociationAttributeGroup"/&gt;
0415:             *          &lt;/restriction&gt;
0416:             *      &lt;/complexContent&gt;
0417:             *  &lt;/complexType&gt;
0418:             *
0419:             *    </code>
0420:             *   </pre>
0421:             * </p>
0422:             *
0423:             * @generated
0424:             */
0425:            public static final AttributeType POLYGONMEMBERTYPE_TYPE = AttributeTypeFactory
0426:                    .newAttributeType("PolygonMemberType", Polygon.class);
0427:
0428:            /**
0429:             * <p>
0430:             *  <pre>
0431:             *   <code>
0432:             *  &lt;complexType abstract="true" name="AbstractFeatureCollectionType"&gt;
0433:             *      &lt;annotation&gt;
0434:             *          &lt;documentation&gt;
0435:             *          A feature collection contains zero or more featureMember elements.
0436:             *        &lt;/documentation&gt;
0437:             *      &lt;/annotation&gt;
0438:             *      &lt;complexContent&gt;
0439:             *          &lt;extension base="gml:AbstractFeatureCollectionBaseType"&gt;
0440:             *              &lt;sequence&gt;
0441:             *                  &lt;element maxOccurs="unbounded" minOccurs="0" ref="gml:featureMember"/&gt;
0442:             *              &lt;/sequence&gt;
0443:             *          &lt;/extension&gt;
0444:             *      &lt;/complexContent&gt;
0445:             *  &lt;/complexType&gt;
0446:             *
0447:             *    </code>
0448:             *   </pre>
0449:             * </p>
0450:             *
0451:             * @generated
0452:             */
0453:            public static final AttributeType ABSTRACTFEATURECOLLECTIONTYPE_TYPE = AttributeTypeFactory
0454:                    .newAttributeType("AbstractFeatureCollectionType",
0455:                            java.lang.Object.class);
0456:
0457:            /**
0458:             * <p>
0459:             *  <pre>
0460:             *   <code>
0461:             *  &lt;complexType name="GeometryPropertyType"&gt;
0462:             *      &lt;annotation&gt;
0463:             *          &lt;documentation&gt;
0464:             *          A simple geometry property encapsulates a geometry element.
0465:             *          Alternatively, it can function as a pointer (simple-type link)
0466:             *          that refers to a remote geometry element.
0467:             *        &lt;/documentation&gt;
0468:             *      &lt;/annotation&gt;
0469:             *      &lt;sequence minOccurs="0"&gt;
0470:             *          &lt;element ref="gml:_Geometry"/&gt;
0471:             *      &lt;/sequence&gt;
0472:             *      &lt;attributeGroup ref="xlink:simpleLink"/&gt;
0473:             *      &lt;attribute ref="gml:remoteSchema" use="optional"/&gt;
0474:             *  &lt;/complexType&gt;
0475:             *
0476:             *    </code>
0477:             *   </pre>
0478:             * </p>
0479:             *
0480:             * @generated
0481:             */
0482:            public static final AttributeType GEOMETRYPROPERTYTYPE_TYPE = AttributeTypeFactory
0483:                    .newAttributeType("GeometryPropertyType",
0484:                            java.lang.Object.class);
0485:
0486:            /**
0487:             * <p>
0488:             *  <pre>
0489:             *   <code>
0490:             *  &lt;complexType name="MultiLineStringPropertyType"&gt;
0491:             *      &lt;annotation&gt;
0492:             *          &lt;documentation&gt;
0493:             *          Encapsulates a MultiLineString element to represent the following
0494:             *          discontiguous geometric properties: multiEdgeOf, multiCenterLineOf.
0495:             *        &lt;/documentation&gt;
0496:             *      &lt;/annotation&gt;
0497:             *      &lt;complexContent&gt;
0498:             *          &lt;restriction base="gml:GeometryAssociationType"&gt;
0499:             *              &lt;sequence minOccurs="0"&gt;
0500:             *                  &lt;element ref="gml:MultiLineString"/&gt;
0501:             *              &lt;/sequence&gt;
0502:             *              &lt;attributeGroup ref="xlink:simpleLink"/&gt;
0503:             *              &lt;attribute ref="gml:remoteSchema" use="optional"/&gt;
0504:             *          &lt;/restriction&gt;
0505:             *      &lt;/complexContent&gt;
0506:             *  &lt;/complexType&gt;
0507:             *
0508:             *    </code>
0509:             *   </pre>
0510:             * </p>
0511:             *
0512:             * @generated
0513:             */
0514:            public static final AttributeType MULTILINESTRINGPROPERTYTYPE_TYPE = AttributeTypeFactory
0515:                    .newAttributeType("MultiLineStringPropertyType",
0516:                            MultiLineString.class);
0517:
0518:            /**
0519:             * <p>
0520:             *  <pre>
0521:             *   <code>
0522:             *  &lt;complexType name="CoordType"&gt;
0523:             *      &lt;annotation&gt;
0524:             *          &lt;documentation&gt;
0525:             *          Represents a coordinate tuple in one, two, or three dimensions.
0526:             *        &lt;/documentation&gt;
0527:             *      &lt;/annotation&gt;
0528:             *      &lt;sequence&gt;
0529:             *          &lt;element name="X" type="decimal"/&gt;
0530:             *          &lt;element minOccurs="0" name="Y" type="decimal"/&gt;
0531:             *          &lt;element minOccurs="0" name="Z" type="decimal"/&gt;
0532:             *      &lt;/sequence&gt;
0533:             *  &lt;/complexType&gt;
0534:             *
0535:             *    </code>
0536:             *   </pre>
0537:             * </p>
0538:             *
0539:             * @generated
0540:             */
0541:            public static final AttributeType COORDTYPE_TYPE = AttributeTypeFactory
0542:                    .newAttributeType("CoordType", java.lang.Object.class);
0543:
0544:            /**
0545:             * <p>
0546:             *  <pre>
0547:             *   <code>
0548:             *  &lt;complexType abstract="true" name="AbstractFeatureType"&gt;
0549:             *      &lt;annotation&gt;
0550:             *          &lt;documentation&gt;
0551:             *          An abstract feature provides a set of common properties. A concrete
0552:             *          feature type must derive from this type and specify additional
0553:             *          properties in an application schema. A feature may optionally
0554:             *          possess an identifying attribute ('fid').
0555:             *        &lt;/documentation&gt;
0556:             *      &lt;/annotation&gt;
0557:             *      &lt;sequence&gt;
0558:             *          &lt;element minOccurs="0" ref="gml:description"/&gt;
0559:             *          &lt;element minOccurs="0" ref="gml:name"/&gt;
0560:             *          &lt;element minOccurs="0" ref="gml:boundedBy"/&gt;
0561:             *          &lt;!-- additional properties must be specified in an application schema --&gt;
0562:             *      &lt;/sequence&gt;
0563:             *      &lt;attribute name="fid" type="ID" use="optional"/&gt;
0564:             *  &lt;/complexType&gt;
0565:             *
0566:             *    </code>
0567:             *   </pre>
0568:             * </p>
0569:             *
0570:             * @generated
0571:             */
0572:            public static final AttributeType ABSTRACTFEATURETYPE_TYPE = AttributeTypeFactory
0573:                    .newAttributeType("AbstractFeatureType",
0574:                            java.lang.Object.class);
0575:
0576:            /**
0577:             * <p>
0578:             *  <pre>
0579:             *   <code>
0580:             *  &lt;complexType abstract="true" name="AbstractFeatureCollectionBaseType"&gt;
0581:             *      &lt;annotation&gt;
0582:             *          &lt;documentation&gt;
0583:             *          This abstract base type just makes the boundedBy element mandatory
0584:             *          for a feature collection.
0585:             *        &lt;/documentation&gt;
0586:             *      &lt;/annotation&gt;
0587:             *      &lt;complexContent&gt;
0588:             *          &lt;restriction base="gml:AbstractFeatureType"&gt;
0589:             *              &lt;sequence&gt;
0590:             *                  &lt;element minOccurs="0" ref="gml:description"/&gt;
0591:             *                  &lt;element minOccurs="0" ref="gml:name"/&gt;
0592:             *                  &lt;element ref="gml:boundedBy"/&gt;
0593:             *              &lt;/sequence&gt;
0594:             *              &lt;attribute name="fid" type="ID" use="optional"/&gt;
0595:             *          &lt;/restriction&gt;
0596:             *      &lt;/complexContent&gt;
0597:             *  &lt;/complexType&gt;
0598:             *
0599:             *    </code>
0600:             *   </pre>
0601:             * </p>
0602:             *
0603:             * @generated
0604:             */
0605:            public static final AttributeType ABSTRACTFEATURECOLLECTIONBASETYPE_TYPE = AttributeTypeFactory
0606:                    .newAttributeType("AbstractFeatureCollectionBaseType",
0607:                            java.lang.Object.class);
0608:
0609:            /**
0610:             * <p>
0611:             *  <pre>
0612:             *   <code>
0613:             *  &lt;complexType name="MultiLineStringType"&gt;
0614:             *      &lt;annotation&gt;
0615:             *          &lt;documentation&gt;
0616:             *          A MultiLineString is defined by one or more LineStrings, referenced
0617:             *          through lineStringMember elements.
0618:             *        &lt;/documentation&gt;
0619:             *      &lt;/annotation&gt;
0620:             *      &lt;complexContent&gt;
0621:             *          &lt;restriction base="gml:GeometryCollectionType"&gt;
0622:             *              &lt;sequence&gt;
0623:             *                  &lt;element maxOccurs="unbounded" ref="gml:lineStringMember"/&gt;
0624:             *              &lt;/sequence&gt;
0625:             *              &lt;attribute name="gid" type="ID" use="optional"/&gt;
0626:             *              &lt;attribute name="srsName" type="anyURI" use="required"/&gt;
0627:             *          &lt;/restriction&gt;
0628:             *      &lt;/complexContent&gt;
0629:             *  &lt;/complexType&gt;
0630:             *
0631:             *    </code>
0632:             *   </pre>
0633:             * </p>
0634:             *
0635:             * @generated
0636:             */
0637:            public static final AttributeType MULTILINESTRINGTYPE_TYPE = AttributeTypeFactory
0638:                    .newAttributeType("MultiLineStringType",
0639:                            MultiLineString.class);
0640:
0641:            /**
0642:             * <p>
0643:             *  <pre>
0644:             *   <code>
0645:             *  &lt;complexType name="GeometryAssociationType"&gt;
0646:             *      &lt;annotation&gt;
0647:             *          &lt;documentation&gt;
0648:             *          An instance of this type (e.g. a geometryMember) can either
0649:             *          enclose or point to a primitive geometry element. When serving
0650:             *          as a simple link that references a remote geometry instance,
0651:             *          the value of the gml:remoteSchema attribute can be used to
0652:             *          locate a schema fragment that constrains the target instance.
0653:             *        &lt;/documentation&gt;
0654:             *      &lt;/annotation&gt;
0655:             *      &lt;sequence minOccurs="0"&gt;
0656:             *          &lt;element ref="gml:_Geometry"/&gt;
0657:             *      &lt;/sequence&gt;optional
0658:             *
0659:             *      &lt;!-- &lt;attributeGroup ref="gml:AssociationAttributeGroup"/&gt; --&gt;
0660:             *      &lt;attributeGroup ref="xlink:simpleLink"/&gt;
0661:             *      &lt;attribute ref="gml:remoteSchema" use="optional"/&gt;
0662:             *  &lt;/complexType&gt;
0663:             *
0664:             *    </code>
0665:             *   </pre>
0666:             * </p>
0667:             *
0668:             * @generated
0669:             */
0670:            public static final AttributeType GEOMETRYASSOCIATIONTYPE_TYPE = AttributeTypeFactory
0671:                    .newAttributeType("GeometryAssociationType",
0672:                            java.lang.Object.class);
0673:
0674:            /**
0675:             * <p>
0676:             *  <pre>
0677:             *   <code>
0678:             *  &lt;complexType name="GeometryCollectionType"&gt;
0679:             *      &lt;annotation&gt;
0680:             *          &lt;documentation&gt;
0681:             *          A geometry collection must include one or more geometries, referenced
0682:             *          through geometryMember elements. User-defined geometry collections
0683:             *          that accept GML geometry classes as members must instantiate--or
0684:             *          derive from--this type.
0685:             *        &lt;/documentation&gt;
0686:             *      &lt;/annotation&gt;
0687:             *      &lt;complexContent&gt;
0688:             *          &lt;extension base="gml:AbstractGeometryCollectionBaseType"&gt;
0689:             *              &lt;sequence&gt;
0690:             *                  &lt;element maxOccurs="unbounded" ref="gml:geometryMember"/&gt;
0691:             *              &lt;/sequence&gt;
0692:             *          &lt;/extension&gt;
0693:             *      &lt;/complexContent&gt;
0694:             *  &lt;/complexType&gt;
0695:             *
0696:             *    </code>
0697:             *   </pre>
0698:             * </p>
0699:             *
0700:             * @generated
0701:             */
0702:            public static final AttributeType GEOMETRYCOLLECTIONTYPE_TYPE = AttributeTypeFactory
0703:                    .newAttributeType("GeometryCollectionType",
0704:                            java.lang.Object.class);
0705:
0706:            /**
0707:             * <p>
0708:             *  <pre>
0709:             *   <code>
0710:             *  &lt;complexType name="CoordinatesType"&gt;
0711:             *      &lt;annotation&gt;
0712:             *          &lt;documentation&gt;
0713:             *          Coordinates can be included in a single string, but there is no
0714:             *          facility for validating string content. The value of the 'cs' attribute
0715:             *          is the separator for coordinate values, and the value of the 'ts'
0716:             *          attribute gives the tuple separator (a single space by default); the
0717:             *          default values may be changed to reflect local usage.
0718:             *        &lt;/documentation&gt;
0719:             *      &lt;/annotation&gt;
0720:             *      &lt;simpleContent&gt;
0721:             *          &lt;extension base="string"&gt;
0722:             *              &lt;attribute default="." name="decimal" type="string" use="optional"/&gt;
0723:             *              &lt;attribute default="," name="cs" type="string" use="optional"/&gt;
0724:             *              &lt;attribute default=" " name="ts" type="string" use="optional"/&gt;
0725:             *          &lt;/extension&gt;
0726:             *      &lt;/simpleContent&gt;
0727:             *  &lt;/complexType&gt;
0728:             *
0729:             *    </code>
0730:             *   </pre>
0731:             * </p>
0732:             *
0733:             * @generated
0734:             */
0735:            public static final AttributeType COORDINATESTYPE_TYPE = AttributeTypeFactory
0736:                    .newAttributeType("CoordinatesType", java.lang.Object.class);
0737:
0738:            /**
0739:             * <p>
0740:             *  <pre>
0741:             *   <code>
0742:             *  &lt;complexType name="LineStringType"&gt;
0743:             *      &lt;annotation&gt;
0744:             *          &lt;documentation&gt;
0745:             *          A LineString is defined by two or more coordinate tuples, with
0746:             *          linear interpolation between them.
0747:             *        &lt;/documentation&gt;
0748:             *      &lt;/annotation&gt;
0749:             *      &lt;complexContent&gt;
0750:             *          &lt;extension base="gml:AbstractGeometryType"&gt;
0751:             *              &lt;sequence&gt;
0752:             *                  &lt;choice&gt;
0753:             *                      &lt;element maxOccurs="unbounded" minOccurs="2" ref="gml:coord"/&gt;
0754:             *                      &lt;element ref="gml:coordinates"/&gt;
0755:             *                  &lt;/choice&gt;
0756:             *              &lt;/sequence&gt;
0757:             *          &lt;/extension&gt;
0758:             *      &lt;/complexContent&gt;
0759:             *  &lt;/complexType&gt;
0760:             *
0761:             *    </code>
0762:             *   </pre>
0763:             * </p>
0764:             *
0765:             * @generated
0766:             */
0767:            public static final AttributeType LINESTRINGTYPE_TYPE = AttributeTypeFactory
0768:                    .newAttributeType("LineStringType", LineString.class);
0769:
0770:            /**
0771:             * <p>
0772:             *  <pre>
0773:             *   <code>
0774:             *  &lt;complexType name="LineStringMemberType"&gt;
0775:             *      &lt;annotation&gt;
0776:             *          &lt;documentation&gt;Restricts the geometry member to being a LineString instance.&lt;/documentation&gt;
0777:             *      &lt;/annotation&gt;
0778:             *      &lt;complexContent&gt;
0779:             *          &lt;restriction base="gml:GeometryAssociationType"&gt;
0780:             *              &lt;sequence minOccurs="0"&gt;
0781:             *                  &lt;element ref="gml:LineString"/&gt;
0782:             *              &lt;/sequence&gt;
0783:             *              &lt;attributeGroup ref="gml:AssociationAttributeGroup"/&gt;
0784:             *          &lt;/restriction&gt;
0785:             *      &lt;/complexContent&gt;
0786:             *  &lt;/complexType&gt;
0787:             *
0788:             *    </code>
0789:             *   </pre>
0790:             * </p>
0791:             *
0792:             * @generated
0793:             */
0794:            public static final AttributeType LINESTRINGMEMBERTYPE_TYPE = AttributeTypeFactory
0795:                    .newAttributeType("LineStringMemberType", LineString.class);
0796:
0797:            /**
0798:             * <p>
0799:             *  <pre>
0800:             *   <code>
0801:             *  &lt;complexType name="MultiGeometryPropertyType"&gt;
0802:             *      &lt;annotation&gt;
0803:             *          &lt;documentation&gt;Encapsulates a MultiGeometry element.&lt;/documentation&gt;
0804:             *      &lt;/annotation&gt;
0805:             *      &lt;complexContent&gt;
0806:             *          &lt;restriction base="gml:GeometryAssociationType"&gt;
0807:             *              &lt;sequence minOccurs="0"&gt;
0808:             *                  &lt;element ref="gml:MultiGeometry"/&gt;
0809:             *              &lt;/sequence&gt;
0810:             *              &lt;attributeGroup ref="xlink:simpleLink"/&gt;
0811:             *              &lt;attribute ref="gml:remoteSchema" use="optional"/&gt;
0812:             *          &lt;/restriction&gt;
0813:             *      &lt;/complexContent&gt;
0814:             *  &lt;/complexType&gt;
0815:             *
0816:             *    </code>
0817:             *   </pre>
0818:             * </p>
0819:             *
0820:             * @generated
0821:             */
0822:            public static final AttributeType MULTIGEOMETRYPROPERTYTYPE_TYPE = AttributeTypeFactory
0823:                    .newAttributeType("MultiGeometryPropertyType",
0824:                            java.lang.Object.class);
0825:
0826:            /**
0827:             * <p>
0828:             *  <pre>
0829:             *   <code>
0830:             *  &lt;complexType name="PointPropertyType"&gt;
0831:             *      &lt;annotation&gt;
0832:             *          &lt;documentation&gt;
0833:             *          Encapsulates a single point to represent position, location, or
0834:             *          centerOf properties.
0835:             *        &lt;/documentation&gt;
0836:             *      &lt;/annotation&gt;
0837:             *      &lt;complexContent&gt;
0838:             *          &lt;restriction base="gml:GeometryAssociationType"&gt;
0839:             *              &lt;sequence minOccurs="0"&gt;
0840:             *                  &lt;element ref="gml:Point"/&gt;
0841:             *              &lt;/sequence&gt;
0842:             *              &lt;attributeGroup ref="xlink:simpleLink"/&gt;
0843:             *              &lt;attribute ref="gml:remoteSchema" use="optional"/&gt;
0844:             *          &lt;/restriction&gt;
0845:             *      &lt;/complexContent&gt;
0846:             *  &lt;/complexType&gt;
0847:             *
0848:             *    </code>
0849:             *   </pre>
0850:             * </p>
0851:             *
0852:             * @generated
0853:             */
0854:            public static final AttributeType POINTPROPERTYTYPE_TYPE = AttributeTypeFactory
0855:                    .newAttributeType("PointPropertyType", Point.class);
0856:
0857:            /**
0858:             * <p>
0859:             *  <pre>
0860:             *   <code>
0861:             *  &lt;complexType abstract="true" name="AbstractGeometryType"&gt;
0862:             *      &lt;annotation&gt;
0863:             *          &lt;documentation&gt;
0864:             *          All geometry elements are derived from this abstract supertype;
0865:             *          a geometry element may have an identifying attribute (gid).
0866:             *          It may be associated with a spatial reference system.
0867:             *        &lt;/documentation&gt;
0868:             *      &lt;/annotation&gt;
0869:             *      &lt;complexContent&gt;
0870:             *          &lt;restriction base="anyType"&gt;
0871:             *              &lt;attribute name="gid" type="ID" use="optional"/&gt;
0872:             *              &lt;attribute name="srsName" type="anyURI" use="optional"/&gt;
0873:             *          &lt;/restriction&gt;
0874:             *      &lt;/complexContent&gt;
0875:             *  &lt;/complexType&gt;
0876:             *
0877:             *    </code>
0878:             *   </pre>
0879:             * </p>
0880:             *
0881:             * @generated
0882:             */
0883:            public static final AttributeType ABSTRACTGEOMETRYTYPE_TYPE = AttributeTypeFactory
0884:                    .newAttributeType("AbstractGeometryType",
0885:                            java.lang.Object.class);
0886:
0887:            /**
0888:             * <p>
0889:             *  <pre>
0890:             *   <code>
0891:             *  &lt;complexType abstract="true" name="AbstractGeometryCollectionBaseType"&gt;
0892:             *      &lt;annotation&gt;
0893:             *          &lt;documentation&gt;
0894:             *          This abstract base type for geometry collections just makes the
0895:             *          srsName attribute mandatory.
0896:             *        &lt;/documentation&gt;
0897:             *      &lt;/annotation&gt;
0898:             *      &lt;complexContent&gt;
0899:             *          &lt;restriction base="gml:AbstractGeometryType"&gt;
0900:             *              &lt;attribute name="gid" type="ID" use="optional"/&gt;
0901:             *              &lt;attribute name="srsName" type="anyURI" use="required"/&gt;
0902:             *          &lt;/restriction&gt;
0903:             *      &lt;/complexContent&gt;
0904:             *  &lt;/complexType&gt;
0905:             *
0906:             *    </code>
0907:             *   </pre>
0908:             * </p>
0909:             *
0910:             * @generated
0911:             */
0912:            public static final AttributeType ABSTRACTGEOMETRYCOLLECTIONBASETYPE_TYPE = AttributeTypeFactory
0913:                    .newAttributeType("AbstractGeometryCollectionBaseType",
0914:                            java.lang.Object.class);
0915:
0916:            /**
0917:             * <p>
0918:             *  <pre>
0919:             *   <code>
0920:             *  &lt;complexType name="PointType"&gt;
0921:             *      &lt;annotation&gt;
0922:             *          &lt;documentation&gt;
0923:             *          A Point is defined by a single coordinate tuple.
0924:             *        &lt;/documentation&gt;
0925:             *      &lt;/annotation&gt;
0926:             *      &lt;complexContent&gt;
0927:             *          &lt;extension base="gml:AbstractGeometryType"&gt;
0928:             *              &lt;sequence&gt;
0929:             *                  &lt;choice&gt;
0930:             *                      &lt;element ref="gml:coord"/&gt;
0931:             *                      &lt;element ref="gml:coordinates"/&gt;
0932:             *                  &lt;/choice&gt;
0933:             *              &lt;/sequence&gt;
0934:             *          &lt;/extension&gt;
0935:             *      &lt;/complexContent&gt;
0936:             *  &lt;/complexType&gt;
0937:             *
0938:             *    </code>
0939:             *   </pre>
0940:             * </p>
0941:             *
0942:             * @generated
0943:             */
0944:            public static final AttributeType POINTTYPE_TYPE = AttributeTypeFactory
0945:                    .newAttributeType("PointType", Point.class);
0946:
0947:            /**
0948:             * <p>
0949:             *  <pre>
0950:             *   <code>
0951:             *  &lt;complexType name="PolygonPropertyType"&gt;
0952:             *      &lt;annotation&gt;
0953:             *          &lt;documentation&gt;
0954:             *          Encapsulates a single polygon to represent coverage or extentOf
0955:             *          properties.
0956:             *        &lt;/documentation&gt;
0957:             *      &lt;/annotation&gt;
0958:             *      &lt;complexContent&gt;
0959:             *          &lt;restriction base="gml:GeometryAssociationType"&gt;
0960:             *              &lt;sequence minOccurs="0"&gt;
0961:             *                  &lt;element ref="gml:Polygon"/&gt;
0962:             *              &lt;/sequence&gt;
0963:             *              &lt;attributeGroup ref="xlink:simpleLink"/&gt;
0964:             *              &lt;attribute ref="gml:remoteSchema" use="optional"/&gt;
0965:             *          &lt;/restriction&gt;
0966:             *      &lt;/complexContent&gt;
0967:             *  &lt;/complexType&gt;
0968:             *
0969:             *    </code>
0970:             *   </pre>
0971:             * </p>
0972:             *
0973:             * @generated
0974:             */
0975:            public static final AttributeType POLYGONPROPERTYTYPE_TYPE = AttributeTypeFactory
0976:                    .newAttributeType("PolygonPropertyType", Polygon.class);
0977:
0978:            /**
0979:             * <p>
0980:             *  <pre>
0981:             *   <code>
0982:             *  &lt;complexType name="LinearRingType"&gt;
0983:             *      &lt;annotation&gt;
0984:             *          &lt;documentation&gt;
0985:             *          A LinearRing is defined by four or more coordinate tuples, with
0986:             *          linear interpolation between them; the first and last coordinates
0987:             *          must be coincident.
0988:             *        &lt;/documentation&gt;
0989:             *      &lt;/annotation&gt;
0990:             *      &lt;complexContent&gt;
0991:             *          &lt;extension base="gml:AbstractGeometryType"&gt;
0992:             *              &lt;sequence&gt;
0993:             *                  &lt;choice&gt;
0994:             *                      &lt;element maxOccurs="unbounded" minOccurs="4" ref="gml:coord"/&gt;
0995:             *                      &lt;element ref="gml:coordinates"/&gt;
0996:             *                  &lt;/choice&gt;
0997:             *              &lt;/sequence&gt;
0998:             *          &lt;/extension&gt;
0999:             *      &lt;/complexContent&gt;
1000:             *  &lt;/complexType&gt;
1001:             *
1002:             *    </code>
1003:             *   </pre>
1004:             * </p>
1005:             *
1006:             * @generated
1007:             */
1008:            public static final AttributeType LINEARRINGTYPE_TYPE = AttributeTypeFactory
1009:                    .newAttributeType("LinearRingType", LinearRing.class);
1010:
1011:            public GMLSchema() {
1012:                super ("http://www.opengis.net/gml");
1013:
1014:                put(new Name("http://www.opengis.net/gml",
1015:                        "LinearRingMemberType"), LINEARRINGMEMBERTYPE_TYPE);
1016:                put(new Name("http://www.opengis.net/gml", "NullType"),
1017:                        NULLTYPE_TYPE);
1018:                put(new Name("http://www.opengis.net/gml",
1019:                        "LineStringPropertyType"), LINESTRINGPROPERTYTYPE_TYPE);
1020:                put(new Name("http://www.opengis.net/gml", "BoxType"),
1021:                        BOXTYPE_TYPE);
1022:                put(new Name("http://www.opengis.net/gml", "MultiPolygonType"),
1023:                        MULTIPOLYGONTYPE_TYPE);
1024:                put(new Name("http://www.opengis.net/gml",
1025:                        "MultiPolygonPropertyType"),
1026:                        MULTIPOLYGONPROPERTYTYPE_TYPE);
1027:                put(new Name("http://www.opengis.net/gml", "PointMemberType"),
1028:                        POINTMEMBERTYPE_TYPE);
1029:                put(
1030:                        new Name("http://www.opengis.net/gml",
1031:                                "BoundingShapeType"), BOUNDINGSHAPETYPE_TYPE);
1032:                put(new Name("http://www.opengis.net/gml", "MultiPointType"),
1033:                        MULTIPOINTTYPE_TYPE);
1034:                put(new Name("http://www.opengis.net/gml",
1035:                        "MultiPointPropertyType"), MULTIPOINTPROPERTYTYPE_TYPE);
1036:                put(new Name("http://www.opengis.net/gml", "PolygonType"),
1037:                        POLYGONTYPE_TYPE);
1038:                put(new Name("http://www.opengis.net/gml",
1039:                        "FeatureAssociationType"), FEATUREASSOCIATIONTYPE_TYPE);
1040:                put(
1041:                        new Name("http://www.opengis.net/gml",
1042:                                "PolygonMemberType"), POLYGONMEMBERTYPE_TYPE);
1043:                put(new Name("http://www.opengis.net/gml",
1044:                        "AbstractFeatureCollectionType"),
1045:                        ABSTRACTFEATURECOLLECTIONTYPE_TYPE);
1046:                put(new Name("http://www.opengis.net/gml",
1047:                        "GeometryPropertyType"), GEOMETRYPROPERTYTYPE_TYPE);
1048:                put(new Name("http://www.opengis.net/gml",
1049:                        "MultiLineStringPropertyType"),
1050:                        MULTILINESTRINGPROPERTYTYPE_TYPE);
1051:                put(new Name("http://www.opengis.net/gml", "CoordType"),
1052:                        COORDTYPE_TYPE);
1053:                put(new Name("http://www.opengis.net/gml",
1054:                        "AbstractFeatureType"), ABSTRACTFEATURETYPE_TYPE);
1055:                put(new Name("http://www.opengis.net/gml",
1056:                        "AbstractFeatureCollectionBaseType"),
1057:                        ABSTRACTFEATURECOLLECTIONBASETYPE_TYPE);
1058:                put(new Name("http://www.opengis.net/gml",
1059:                        "MultiLineStringType"), MULTILINESTRINGTYPE_TYPE);
1060:                put(new Name("http://www.opengis.net/gml",
1061:                        "GeometryAssociationType"),
1062:                        GEOMETRYASSOCIATIONTYPE_TYPE);
1063:                put(new Name("http://www.opengis.net/gml",
1064:                        "GeometryCollectionType"), GEOMETRYCOLLECTIONTYPE_TYPE);
1065:                put(new Name("http://www.opengis.net/gml", "CoordinatesType"),
1066:                        COORDINATESTYPE_TYPE);
1067:                put(new Name("http://www.opengis.net/gml", "LineStringType"),
1068:                        LINESTRINGTYPE_TYPE);
1069:                put(new Name("http://www.opengis.net/gml",
1070:                        "LineStringMemberType"), LINESTRINGMEMBERTYPE_TYPE);
1071:                put(new Name("http://www.opengis.net/gml",
1072:                        "MultiGeometryPropertyType"),
1073:                        MULTIGEOMETRYPROPERTYTYPE_TYPE);
1074:                put(
1075:                        new Name("http://www.opengis.net/gml",
1076:                                "PointPropertyType"), POINTPROPERTYTYPE_TYPE);
1077:                put(new Name("http://www.opengis.net/gml",
1078:                        "AbstractGeometryType"), ABSTRACTGEOMETRYTYPE_TYPE);
1079:                put(new Name("http://www.opengis.net/gml",
1080:                        "AbstractGeometryCollectionBaseType"),
1081:                        ABSTRACTGEOMETRYCOLLECTIONBASETYPE_TYPE);
1082:                put(new Name("http://www.opengis.net/gml", "PointType"),
1083:                        POINTTYPE_TYPE);
1084:                put(new Name("http://www.opengis.net/gml",
1085:                        "PolygonPropertyType"), POLYGONPROPERTYTYPE_TYPE);
1086:                put(new Name("http://www.opengis.net/gml", "LinearRingType"),
1087:                        LINEARRINGTYPE_TYPE);
1088:            }
1089:        }