Module org.opengis.geoapi
Package org.opengis.feature

Interface FeatureType

All Superinterfaces:
IdentifiedType
@Classifier(METACLASS) @UML(identifier="FeatureType", specification=ISO_19109) public interface FeatureType extends IdentifiedType
Abstraction of a real-world phenomena. A FeatureType instance describes the class of all Feature instances of that type.
Analogy with Java reflection: compared to the Java language, FeatureType is equivalent to Class while Feature instances are equivalent to Object instances of that class.

Naming

The feature type name is mandatory and should be unique. Names can be ScopedName for avoiding name collision.

Properties and inheritance

Each feature type can provide descriptions for the following properties: In addition, a feature type can inherit the properties of one or more other feature types. Properties defined in the sub-type can override properties of the same name defined in the super-types, provided that values of the sub-type property are assignable to the super-type property.
Analogy with Java language: compared to the Java language, the above rule is similar to overriding a method with a more specific return type (a.k.a. covariant return type). This is also similar to Java arrays, which are implicitly covariant (i.e. String[] can be casted to CharSequence[], which is safe for read operations but not for write operations — the latter may throw ArrayStoreException).
Since:
3.1
See Also:

  • Method Details

    • getName

      @UML(identifier="name", obligation=MANDATORY, specification=ISO_19109) GenericName getName()
      Returns the name of this feature type. For FeatureType, the name is mandatory. The feature name is often an instance of TypeName, but this is not mandatory.
      Specified by:
      getName in interface IdentifiedType
      Returns:
      the feature type name.

    • isAbstract

      @UML(identifier="isAbstract", obligation=MANDATORY, specification=ISO_19109) boolean isAbstract()
      Returns true if the feature type acts as an abstract super-type. Abstract types cannot be instantiated.
      Returns:
      true if the feature type acts as an abstract super-type.

    • isSimple

      boolean isSimple()
      Returns true if this feature type contains only attributes constrained to the [1 … 1] multiplicity, or operations (no feature association). Such feature types can be handled as a RecordType instances.
      Returns:
      true if this feature type contains only simple attributes or operations.

    • getProperty

      PropertyType getProperty(String name) throws PropertyNotFoundException
      Returns the attribute, operation or association role for the given name.
      Parameters:
      name - the name of the property to search.
      Returns:
      the property for the given name.
      Throws:
      PropertyNotFoundException - if the given argument is not a property name of this feature type.
      See Also:

    • getProperties

      @UML(identifier="carrierOfCharacteristics", obligation=OPTIONAL, specification=ISO_19109) Collection<? extends PropertyType> getProperties(boolean includeSuperTypes)
      Returns any feature operation, any feature attribute type and any feature association role that carries characteristics of a feature type. The returned collection will include the properties inherited from the super-types only if includeSuperTypes is true.
      Parameters:
      includeSuperTypes - true for including the properties inherited from the super-types, or false for returning only the properties defined explicitly in this type.
      Returns:
      Feature operation, attribute type and association role that carries characteristics of this feature type (not including parent types).

    • getSuperTypes

      @UML(identifier="superType", obligation=OPTIONAL, specification=ISO_19109) Set<? extends FeatureType> getSuperTypes()
      Returns the direct parents of this feature type.
      Analogy with Java reflection: if we compare FeatureType to Class in the Java language, then this method is equivalent to Class.getSuperclass() except that feature types allow multi-inheritance.
      Returns:
      the parents of this feature type, or an empty set if none.

    • isAssignableFrom

      boolean isAssignableFrom(FeatureType type)
      Returns true if this type is same or a super-type of the given type. Implementations should ensure that the following constraints are met:
      • If A is assignable from B and B is assignable from C, then A is assignable from C.
      Analogy with Java reflection: if we compare FeatureType to Class in the Java language, then this method is equivalent to Class.isAssignableFrom(Class).
      Parameters:
      type - the type to be checked.
      Returns:
      true if instances of the given type can be assigned to association of this type.

    • newInstance

      Feature newInstance() throws FeatureInstantiationException, UnsupportedOperationException
      Creates a new feature instance of this type.
      Analogy with Java reflection: if we compare FeatureType to Class and Feature to Object in the Java language, then this method is equivalent to Class.newInstance().
      Returns:
      a new feature instance.
      Throws:
      FeatureInstantiationException - if this feature type is abstract or cannot be instantiated for some other reason.
      UnsupportedOperationException - if this type does not support new instance creation.