Class Types

  • Direct Known Subclasses:
    Types

    public class Types
    extends Object
    This is a set of utility methods used when implementing types.

    This set of classes captures the all important how does it work questions, particularly with respect to super types. FIXME: These methods need a Q&A check to confirm correct use of Super TODO: Cannot tell the difference in intent from FeatureTypes

    Author:
    Jody Garnett, LISAsoft, Justin Deoliveira, The Open Planning Project
    • Field Detail

      • DECLARED_NAMESPACES_MAP

        public static final String DECLARED_NAMESPACES_MAP
        Key for AppSchema declared namespaces on FeatureType user data Map. Value is a Map<String, String>
        See Also:
        Constant Field Values
    • Constructor Detail

      • Types

        public Types()
    • Method Detail

      • isValid

        public static boolean isValid​(Attribute attribute)
        Ensures an attribute value is withing the restrictions of the AttributeDescriptor and AttributeType.
        Returns:
        true if the attribute value is valid
      • validate

        public static void validate​(Attribute attribute,
                                    Object attributeContent)
                             throws IllegalAttributeException
        Validates content against an attribute.
        Parameters:
        attribute - The attribute.
        attributeContent - Content of attribute (often attribute.getValue()
        Throws:
        IllegalAttributeException - In the event that content violates any restrictions specified by the attribute.
      • validate

        protected static void validate​(AttributeType type,
                                       Attribute attribute,
                                       Object attributeContent,
                                       boolean isSuper)
                                throws IllegalAttributeException
        Parameters:
        type - AttributeType (often attribute.getType() )
        attribute - Attribute being tested
        attributeContent - Content of the attribute (often attribute.getValue() )
        isSuper - True if super type is being checked
        Throws:
        IllegalAttributeException
      • parse

        public static Object parse​(AttributeDescriptor descriptor,
                                   Object value)
                            throws IllegalArgumentException
        Do our best to make the provided value line up with the needs of descriptor.

        This helper method uses the Coverters api to convert the provided value into the required class. If the value is null (and the attribute is not nillable) a default value will be returned.

        Parameters:
        descriptor - Attribute descriptor we need to supply a value for.
        value - The provided value
        Returns:
        Our best attempt to make a valid value
        Throws:
        IllegalArgumentException - if we really could not do it.
      • assertNameAssignable

        public static void assertNameAssignable​(FeatureType expected,
                                                FeatureType actual)
        FeatureType comparison indicating if the description provided by two FeatureTypes is similar to the point data can be exchanged. This comparison is really very focused on the name / value contract and is willing to overlook details like length restrictions.

        When creating compatible FeatureTypes you will find some systems have different abilities which is reflected in how well they support a given FeatureType.

        As an example databases traditionally support variable length strings with a limit of 32 k; while a shapefile is limited to 256 characters. When working with data from both these data sources you will need to make adjustments based on these abilities. If true is returned data conforming to the expected FeatureType can be used with the actual FeatureType.

        After assertOrderCovered returns without error the following code will work:

        
         for( Property property : feature.getProperties() ){
             Object value = property.getValue();
        
             Property target = newFeature.getProperty( property.getName().getLocalPart() );
             target.setValue( value );
         }
         
        Specifically this says that between the two feature types data is assignable on a name by name basis.
        Parameters:
        expected - Expected FeatureType being used to compare against
        actual - Actual FeatureType
      • assertOrderAssignable

        public static void assertOrderAssignable​(SimpleFeatureType expected,
                                                 SimpleFeatureType actual)
        SimpleFeatureType comparison indicating that data from one FeatureType can be exchanged with another - specifically ensuring that the order / value is a reasonable match with the expected number of attributes on each side and the values correctly assignable.

        After assertOrderCovered returns without error the following code will work:

        
         List values = feature.getAttributes();
         newFeature.setAttributes( values );
         
        
        
        
        
        
        
        • names

          public static Name[] names​(ComplexType type)
          Returns The name of attributes defined in the type.
          Parameters:
          type - The type.
        • typeName

          public static Name typeName​(String name)
          Creates a type name from a single non-qualified string.
          Parameters:
          name - The name, may be null
          Returns:
          The name in which getLocalPart() == name and getNamespaceURI() == null. Or null if name == null.
        • typeName

          public static Name typeName​(String namespace,
                                      String name)
          Creates an attribute name from a single non-qualified string.
          Parameters:
          name - The name, may be null
          namespace - The scope or namespace, may be null.
          Returns:
          The name in which getLocalPart() == name and getNamespaceURI() == namespace.
        • typeName

          public static Name typeName​(Name name)
          Creates a type name from another name.
          Parameters:
          name - The other name.
        • toNames

          public static Name[] toNames​(String... names)
          Creates a set of attribute names from a set of strings.

          This method returns null if names == null.

          The ith name has getLocalPart() == names[i] and getNamespaceURI() == null

        • toTypeNames

          public static Name[] toTypeNames​(String... names)
          Creates a set of type names from a set of strings.

          This method returns null if names == null.

          The ith name has getLocalPart() == names[i] and getNamespaceURI() == null

        • fromNames

          public static String[] fromNames​(Name... attributeNames)
          Convenience method for turning an array of qualified names into a list of non qualified names.
        • fromTypeNames

          public static String[] fromTypeNames​(Name... typeNames)
          Convenience method for turning an array of qualified names into a list of non qualified names.
        • toTypeName

          public static Name toTypeName​(QName name)
        • equals

          public static boolean equals​(Name name,
                                       QName qName)
        • degloseName

          public static Name degloseName​(String prefixedName,
                                         NamespaceSupport namespaces)
                                  throws IllegalArgumentException
          Takes a prefixed attribute name and returns an Name by looking which namespace belongs the prefix to in AppSchemaDataAccessDTO#getNamespaces().
          Parameters:
          prefixedName - , namespaces
          Throws:
          IllegalArgumentException - if prefixedName has no declared namespace in app-schema config file.
        • toQName

          public static QName toQName​(Name featurePath)
        • toPrefixedName

          public static String toPrefixedName​(Name name,
                                              NamespaceSupport ns)
          Converts a Name to a prefixed name (i.e. p:Foo), by looking up the right prefix in the provided NamespaceSupport. If no prefix is found, the return value will be the same as that of Name.getLocalPart().
          Parameters:
          name - the name to translate in prefixed form
          ns - namespace context, relates namespaces to prefixes
        • validate

          public static void validate​(Attribute attribute)
                               throws IllegalAttributeException
          Validates anattribute.

          Same result as calling:

            <code>
           validate(attribute.type(), attribute)
           </code>
           
          Parameters:
          attribute - The attribute.
          Throws:
          IllegalAttributeException - In the event that content violates any restrictions specified by the attribute.
        • isSuperType

          public static boolean isSuperType​(PropertyType type,
                                            PropertyType parent)
          Determines if parent is a super type of type
          Parameters:
          type - The type in question.
          parent - The possible parent type.
        • descriptor

          public static PropertyDescriptor descriptor​(ComplexType type,
                                                      String name)
          Returns the first descriptor matching the given local name within the given type.
          Parameters:
          type - The type, non null.
          name - The name, non null.
          Returns:
          The first descriptor, or null if no match.
        • descriptor

          public static PropertyDescriptor descriptor​(ComplexType type,
                                                      String name,
                                                      String namespace)
          Returns the first descriptor matching the given name + namespace within the given type.
          Parameters:
          type - The type, non null.
          name - The name, non null.
          namespace - The namespace, non null.
          Returns:
          The first descriptor, or null if no match.
        • descriptor

          public static PropertyDescriptor descriptor​(ComplexType type,
                                                      Name name)
          Returns the first descriptor matching the given name within the given type.
          Parameters:
          type - The type, non null.
          name - The name, non null.
          Returns:
          The first descriptor, or null if no match.
        • descriptors

          public static List<PropertyDescriptor> descriptors​(ComplexType type,
                                                             String name)
          Returns the set of descriptors matching the given local name within the given type.
          Parameters:
          type - The type, non null.
          name - The name, non null.
          Returns:
          The list of descriptors named 'name', or an empty list if none such match.
        • descriptors

          public static List<PropertyDescriptor> descriptors​(ComplexType type,
                                                             Name name)
          Returns the set of descriptors matching the given name.
          Parameters:
          type - The type, non null.
          name - The name, non null.
          Returns:
          The list of descriptors named 'name', or an empty list if none such match.
        • descriptors

          public static List<PropertyDescriptor> descriptors​(ComplexType type)
          Returns the set of all descriptors of a complex type, including from supertypes.
          Parameters:
          type - The type, non null.
          Returns:
          The list of all descriptors.
        • findDescriptor

          public static PropertyDescriptor findDescriptor​(ComplexType parentType,
                                                          Name name)
          Find a descriptor, taking in to account supertypes AND substitution groups
          Parameters:
          parentType - type
          name - name of descriptor
          Returns:
          descriptor, null if not found
        • findDescriptor

          public static PropertyDescriptor findDescriptor​(ComplexType parentType,
                                                          String name)
          Find a descriptor, taking in to account supertypes AND substitution groups
          Parameters:
          parentType - type
          name - name of descriptor
          Returns:
          descriptor, null if not found