Class Gml311Validator

  • All Implemented Interfaces:
    EValidator

    public class Gml311Validator
    extends EObjectValidator
    The Validator for the model.
    See Also:
    Gml311Package
    • Constructor Detail

      • Gml311Validator

        public Gml311Validator()
        Creates an instance of the switch.
    • Method Detail

      • getEPackage

        protected EPackage getEPackage()
        Returns the package of this validator switch.
        Overrides:
        getEPackage in class EObjectValidator
      • validate

        protected boolean validate​(int classifierID,
                                   Object value,
                                   DiagnosticChain diagnostics,
                                   Map<Object,​Object> context)
        Calls validateXXX for the corresponding classifier of the model.
        Overrides:
        validate in class EObjectValidator
      • validateAbstractContinuousCoverageType

        public boolean validateAbstractContinuousCoverageType​(AbstractContinuousCoverageType abstractContinuousCoverageType,
                                                              DiagnosticChain diagnostics,
                                                              Map<Object,​Object> context)
      • validateAbstractCoordinateSystemType

        public boolean validateAbstractCoordinateSystemType​(AbstractCoordinateSystemType abstractCoordinateSystemType,
                                                            DiagnosticChain diagnostics,
                                                            Map<Object,​Object> context)
      • validateAbstractCoverageType

        public boolean validateAbstractCoverageType​(AbstractCoverageType abstractCoverageType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateAbstractCurveSegmentType

        public boolean validateAbstractCurveSegmentType​(AbstractCurveSegmentType abstractCurveSegmentType,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
      • validateAbstractCurveType

        public boolean validateAbstractCurveType​(AbstractCurveType abstractCurveType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateAbstractDatumBaseType

        public boolean validateAbstractDatumBaseType​(AbstractDatumBaseType abstractDatumBaseType,
                                                     DiagnosticChain diagnostics,
                                                     Map<Object,​Object> context)
      • validateAbstractDatumType

        public boolean validateAbstractDatumType​(AbstractDatumType abstractDatumType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateAbstractDiscreteCoverageType

        public boolean validateAbstractDiscreteCoverageType​(AbstractDiscreteCoverageType abstractDiscreteCoverageType,
                                                            DiagnosticChain diagnostics,
                                                            Map<Object,​Object> context)
      • validateAbstractFeatureCollectionType

        public boolean validateAbstractFeatureCollectionType​(AbstractFeatureCollectionType abstractFeatureCollectionType,
                                                             DiagnosticChain diagnostics,
                                                             Map<Object,​Object> context)
      • validateAbstractFeatureType

        public boolean validateAbstractFeatureType​(AbstractFeatureType abstractFeatureType,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
      • validateAbstractGeneralConversionType

        public boolean validateAbstractGeneralConversionType​(AbstractGeneralConversionType abstractGeneralConversionType,
                                                             DiagnosticChain diagnostics,
                                                             Map<Object,​Object> context)
      • validateAbstractGeneralDerivedCRSType

        public boolean validateAbstractGeneralDerivedCRSType​(AbstractGeneralDerivedCRSType abstractGeneralDerivedCRSType,
                                                             DiagnosticChain diagnostics,
                                                             Map<Object,​Object> context)
      • validateAbstractGeometricAggregateType

        public boolean validateAbstractGeometricAggregateType​(AbstractGeometricAggregateType abstractGeometricAggregateType,
                                                              DiagnosticChain diagnostics,
                                                              Map<Object,​Object> context)
      • validateAbstractGeometricPrimitiveType

        public boolean validateAbstractGeometricPrimitiveType​(AbstractGeometricPrimitiveType abstractGeometricPrimitiveType,
                                                              DiagnosticChain diagnostics,
                                                              Map<Object,​Object> context)
      • validateAbstractGeometryType

        public boolean validateAbstractGeometryType​(AbstractGeometryType abstractGeometryType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateAbstractGMLType

        public boolean validateAbstractGMLType​(AbstractGMLType abstractGMLType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateAbstractGriddedSurfaceType

        public boolean validateAbstractGriddedSurfaceType​(AbstractGriddedSurfaceType abstractGriddedSurfaceType,
                                                          DiagnosticChain diagnostics,
                                                          Map<Object,​Object> context)
      • validateAbstractMetaDataType

        public boolean validateAbstractMetaDataType​(AbstractMetaDataType abstractMetaDataType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateAbstractPositionalAccuracyType

        public boolean validateAbstractPositionalAccuracyType​(AbstractPositionalAccuracyType abstractPositionalAccuracyType,
                                                              DiagnosticChain diagnostics,
                                                              Map<Object,​Object> context)
      • validateAbstractReferenceSystemType

        public boolean validateAbstractReferenceSystemType​(AbstractReferenceSystemType abstractReferenceSystemType,
                                                           DiagnosticChain diagnostics,
                                                           Map<Object,​Object> context)
      • validateAbstractRingPropertyType

        public boolean validateAbstractRingPropertyType​(AbstractRingPropertyType abstractRingPropertyType,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
      • validateAbstractRingType

        public boolean validateAbstractRingType​(AbstractRingType abstractRingType,
                                                DiagnosticChain diagnostics,
                                                Map<Object,​Object> context)
      • validateAbstractSolidType

        public boolean validateAbstractSolidType​(AbstractSolidType abstractSolidType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateAbstractStyleType

        public boolean validateAbstractStyleType​(AbstractStyleType abstractStyleType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateAbstractSurfacePatchType

        public boolean validateAbstractSurfacePatchType​(AbstractSurfacePatchType abstractSurfacePatchType,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
      • validateAbstractSurfaceType

        public boolean validateAbstractSurfaceType​(AbstractSurfaceType abstractSurfaceType,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
      • validateAbstractTimeComplexType

        public boolean validateAbstractTimeComplexType​(AbstractTimeComplexType abstractTimeComplexType,
                                                       DiagnosticChain diagnostics,
                                                       Map<Object,​Object> context)
      • validateAbstractTimeObjectType

        public boolean validateAbstractTimeObjectType​(AbstractTimeObjectType abstractTimeObjectType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateAbstractTimePrimitiveType

        public boolean validateAbstractTimePrimitiveType​(AbstractTimePrimitiveType abstractTimePrimitiveType,
                                                         DiagnosticChain diagnostics,
                                                         Map<Object,​Object> context)
      • validateAbstractTimeSliceType

        public boolean validateAbstractTimeSliceType​(AbstractTimeSliceType abstractTimeSliceType,
                                                     DiagnosticChain diagnostics,
                                                     Map<Object,​Object> context)
      • validateAbstractTopologyType

        public boolean validateAbstractTopologyType​(AbstractTopologyType abstractTopologyType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateAbstractTopoPrimitiveType

        public boolean validateAbstractTopoPrimitiveType​(AbstractTopoPrimitiveType abstractTopoPrimitiveType,
                                                         DiagnosticChain diagnostics,
                                                         Map<Object,​Object> context)
      • validateAffinePlacementType

        public boolean validateAffinePlacementType​(AffinePlacementType affinePlacementType,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
      • validateAngleChoiceType

        public boolean validateAngleChoiceType​(AngleChoiceType angleChoiceType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateAngleType

        public boolean validateAngleType​(AngleType angleType,
                                         DiagnosticChain diagnostics,
                                         Map<Object,​Object> context)
      • validateArcByBulgeType

        public boolean validateArcByBulgeType​(ArcByBulgeType arcByBulgeType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateArcByCenterPointType

        public boolean validateArcByCenterPointType​(ArcByCenterPointType arcByCenterPointType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateArcStringByBulgeType

        public boolean validateArcStringByBulgeType​(ArcStringByBulgeType arcStringByBulgeType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateArcStringType

        public boolean validateArcStringType​(ArcStringType arcStringType,
                                             DiagnosticChain diagnostics,
                                             Map<Object,​Object> context)
      • validateArcType

        public boolean validateArcType​(ArcType arcType,
                                       DiagnosticChain diagnostics,
                                       Map<Object,​Object> context)
      • validateAreaType

        public boolean validateAreaType​(AreaType areaType,
                                        DiagnosticChain diagnostics,
                                        Map<Object,​Object> context)
      • validateArrayAssociationType

        public boolean validateArrayAssociationType​(ArrayAssociationType arrayAssociationType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateArrayType

        public boolean validateArrayType​(ArrayType arrayType,
                                         DiagnosticChain diagnostics,
                                         Map<Object,​Object> context)
      • validateAssociationType

        public boolean validateAssociationType​(AssociationType associationType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateBagType

        public boolean validateBagType​(BagType bagType,
                                       DiagnosticChain diagnostics,
                                       Map<Object,​Object> context)
      • validateBaseStyleDescriptorType

        public boolean validateBaseStyleDescriptorType​(BaseStyleDescriptorType baseStyleDescriptorType,
                                                       DiagnosticChain diagnostics,
                                                       Map<Object,​Object> context)
      • validateBaseUnitType

        public boolean validateBaseUnitType​(BaseUnitType baseUnitType,
                                            DiagnosticChain diagnostics,
                                            Map<Object,​Object> context)
      • validateBezierType

        public boolean validateBezierType​(BezierType bezierType,
                                          DiagnosticChain diagnostics,
                                          Map<Object,​Object> context)
      • validateBooleanPropertyType

        public boolean validateBooleanPropertyType​(BooleanPropertyType booleanPropertyType,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
      • validateBoundedFeatureType

        public boolean validateBoundedFeatureType​(BoundedFeatureType boundedFeatureType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateBoundingShapeType

        public boolean validateBoundingShapeType​(BoundingShapeType boundingShapeType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateBSplineType

        public boolean validateBSplineType​(BSplineType bSplineType,
                                           DiagnosticChain diagnostics,
                                           Map<Object,​Object> context)
      • validateCartesianCSRefType

        public boolean validateCartesianCSRefType​(CartesianCSRefType cartesianCSRefType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateCartesianCSType

        public boolean validateCartesianCSType​(CartesianCSType cartesianCSType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateCategoryExtentType

        public boolean validateCategoryExtentType​(CategoryExtentType categoryExtentType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateCategoryPropertyType

        public boolean validateCategoryPropertyType​(CategoryPropertyType categoryPropertyType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateCircleByCenterPointType

        public boolean validateCircleByCenterPointType​(CircleByCenterPointType circleByCenterPointType,
                                                       DiagnosticChain diagnostics,
                                                       Map<Object,​Object> context)
      • validateCircleType

        public boolean validateCircleType​(CircleType circleType,
                                          DiagnosticChain diagnostics,
                                          Map<Object,​Object> context)
      • validateClothoidType

        public boolean validateClothoidType​(ClothoidType clothoidType,
                                            DiagnosticChain diagnostics,
                                            Map<Object,​Object> context)
      • validateCodeListType

        public boolean validateCodeListType​(CodeListType codeListType,
                                            DiagnosticChain diagnostics,
                                            Map<Object,​Object> context)
      • validateCodeOrNullListType

        public boolean validateCodeOrNullListType​(CodeOrNullListType codeOrNullListType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateCodeType

        public boolean validateCodeType​(CodeType codeType,
                                        DiagnosticChain diagnostics,
                                        Map<Object,​Object> context)
      • validateCompositeCurvePropertyType

        public boolean validateCompositeCurvePropertyType​(CompositeCurvePropertyType compositeCurvePropertyType,
                                                          DiagnosticChain diagnostics,
                                                          Map<Object,​Object> context)
      • validateCompositeCurveType

        public boolean validateCompositeCurveType​(CompositeCurveType compositeCurveType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateCompositeSolidPropertyType

        public boolean validateCompositeSolidPropertyType​(CompositeSolidPropertyType compositeSolidPropertyType,
                                                          DiagnosticChain diagnostics,
                                                          Map<Object,​Object> context)
      • validateCompositeSolidType

        public boolean validateCompositeSolidType​(CompositeSolidType compositeSolidType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateCompositeSurfacePropertyType

        public boolean validateCompositeSurfacePropertyType​(CompositeSurfacePropertyType compositeSurfacePropertyType,
                                                            DiagnosticChain diagnostics,
                                                            Map<Object,​Object> context)
      • validateCompositeSurfaceType

        public boolean validateCompositeSurfaceType​(CompositeSurfaceType compositeSurfaceType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateCompositeValueType

        public boolean validateCompositeValueType​(CompositeValueType compositeValueType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateCompoundCRSRefType

        public boolean validateCompoundCRSRefType​(CompoundCRSRefType compoundCRSRefType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateCompoundCRSType

        public boolean validateCompoundCRSType​(CompoundCRSType compoundCRSType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateConcatenatedOperationRefType

        public boolean validateConcatenatedOperationRefType​(ConcatenatedOperationRefType concatenatedOperationRefType,
                                                            DiagnosticChain diagnostics,
                                                            Map<Object,​Object> context)
      • validateConcatenatedOperationType

        public boolean validateConcatenatedOperationType​(ConcatenatedOperationType concatenatedOperationType,
                                                         DiagnosticChain diagnostics,
                                                         Map<Object,​Object> context)
      • validateConeType

        public boolean validateConeType​(ConeType coneType,
                                        DiagnosticChain diagnostics,
                                        Map<Object,​Object> context)
      • validateContainerPropertyType

        public boolean validateContainerPropertyType​(ContainerPropertyType containerPropertyType,
                                                     DiagnosticChain diagnostics,
                                                     Map<Object,​Object> context)
      • validateControlPointType

        public boolean validateControlPointType​(ControlPointType controlPointType,
                                                DiagnosticChain diagnostics,
                                                Map<Object,​Object> context)
      • validateConventionalUnitType

        public boolean validateConventionalUnitType​(ConventionalUnitType conventionalUnitType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateConversionRefType

        public boolean validateConversionRefType​(ConversionRefType conversionRefType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateConversionToPreferredUnitType

        public boolean validateConversionToPreferredUnitType​(ConversionToPreferredUnitType conversionToPreferredUnitType,
                                                             DiagnosticChain diagnostics,
                                                             Map<Object,​Object> context)
      • validateConversionType

        public boolean validateConversionType​(ConversionType conversionType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateCoordinateOperationRefType

        public boolean validateCoordinateOperationRefType​(CoordinateOperationRefType coordinateOperationRefType,
                                                          DiagnosticChain diagnostics,
                                                          Map<Object,​Object> context)
      • validateCoordinatesType

        public boolean validateCoordinatesType​(CoordinatesType coordinatesType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateCoordinateSystemAxisBaseType

        public boolean validateCoordinateSystemAxisBaseType​(CoordinateSystemAxisBaseType coordinateSystemAxisBaseType,
                                                            DiagnosticChain diagnostics,
                                                            Map<Object,​Object> context)
      • validateCoordinateSystemAxisRefType

        public boolean validateCoordinateSystemAxisRefType​(CoordinateSystemAxisRefType coordinateSystemAxisRefType,
                                                           DiagnosticChain diagnostics,
                                                           Map<Object,​Object> context)
      • validateCoordinateSystemAxisType

        public boolean validateCoordinateSystemAxisType​(CoordinateSystemAxisType coordinateSystemAxisType,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
      • validateCoordinateSystemRefType

        public boolean validateCoordinateSystemRefType​(CoordinateSystemRefType coordinateSystemRefType,
                                                       DiagnosticChain diagnostics,
                                                       Map<Object,​Object> context)
      • validateCoordType

        public boolean validateCoordType​(CoordType coordType,
                                         DiagnosticChain diagnostics,
                                         Map<Object,​Object> context)
      • validateCountPropertyType

        public boolean validateCountPropertyType​(CountPropertyType countPropertyType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateCovarianceElementType

        public boolean validateCovarianceElementType​(CovarianceElementType covarianceElementType,
                                                     DiagnosticChain diagnostics,
                                                     Map<Object,​Object> context)
      • validateCovarianceMatrixType

        public boolean validateCovarianceMatrixType​(CovarianceMatrixType covarianceMatrixType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateCoverageFunctionType

        public boolean validateCoverageFunctionType​(CoverageFunctionType coverageFunctionType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateCRSRefType

        public boolean validateCRSRefType​(CRSRefType crsRefType,
                                          DiagnosticChain diagnostics,
                                          Map<Object,​Object> context)
      • validateCubicSplineType

        public boolean validateCubicSplineType​(CubicSplineType cubicSplineType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateCurveArrayPropertyType

        public boolean validateCurveArrayPropertyType​(CurveArrayPropertyType curveArrayPropertyType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateCurvePropertyType

        public boolean validateCurvePropertyType​(CurvePropertyType curvePropertyType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateCurveSegmentArrayPropertyType

        public boolean validateCurveSegmentArrayPropertyType​(CurveSegmentArrayPropertyType curveSegmentArrayPropertyType,
                                                             DiagnosticChain diagnostics,
                                                             Map<Object,​Object> context)
      • validateCurveType

        public boolean validateCurveType​(CurveType curveType,
                                         DiagnosticChain diagnostics,
                                         Map<Object,​Object> context)
      • validateCylinderType

        public boolean validateCylinderType​(CylinderType cylinderType,
                                            DiagnosticChain diagnostics,
                                            Map<Object,​Object> context)
      • validateCylindricalCSRefType

        public boolean validateCylindricalCSRefType​(CylindricalCSRefType cylindricalCSRefType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateCylindricalCSType

        public boolean validateCylindricalCSType​(CylindricalCSType cylindricalCSType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateDataBlockType

        public boolean validateDataBlockType​(DataBlockType dataBlockType,
                                             DiagnosticChain diagnostics,
                                             Map<Object,​Object> context)
      • validateDatumRefType

        public boolean validateDatumRefType​(DatumRefType datumRefType,
                                            DiagnosticChain diagnostics,
                                            Map<Object,​Object> context)
      • validateDefaultStylePropertyType

        public boolean validateDefaultStylePropertyType​(DefaultStylePropertyType defaultStylePropertyType,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
      • validateDefinitionProxyType

        public boolean validateDefinitionProxyType​(DefinitionProxyType definitionProxyType,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
      • validateDefinitionType

        public boolean validateDefinitionType​(DefinitionType definitionType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateDegreesType

        public boolean validateDegreesType​(DegreesType degreesType,
                                           DiagnosticChain diagnostics,
                                           Map<Object,​Object> context)
      • validateDerivationUnitTermType

        public boolean validateDerivationUnitTermType​(DerivationUnitTermType derivationUnitTermType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateDerivedCRSRefType

        public boolean validateDerivedCRSRefType​(DerivedCRSRefType derivedCRSRefType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateDerivedCRSType

        public boolean validateDerivedCRSType​(DerivedCRSType derivedCRSType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateDerivedCRSTypeType

        public boolean validateDerivedCRSTypeType​(DerivedCRSTypeType derivedCRSTypeType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateDerivedUnitType

        public boolean validateDerivedUnitType​(DerivedUnitType derivedUnitType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateDictionaryEntryType

        public boolean validateDictionaryEntryType​(DictionaryEntryType dictionaryEntryType,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
      • validateDictionaryType

        public boolean validateDictionaryType​(DictionaryType dictionaryType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateDirectedEdgePropertyType

        public boolean validateDirectedEdgePropertyType​(DirectedEdgePropertyType directedEdgePropertyType,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
      • validateDirectedFacePropertyType

        public boolean validateDirectedFacePropertyType​(DirectedFacePropertyType directedFacePropertyType,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
      • validateDirectedNodePropertyType

        public boolean validateDirectedNodePropertyType​(DirectedNodePropertyType directedNodePropertyType,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
      • validateDirectedObservationType

        public boolean validateDirectedObservationType​(DirectedObservationType directedObservationType,
                                                       DiagnosticChain diagnostics,
                                                       Map<Object,​Object> context)
      • validateDirectedTopoSolidPropertyType

        public boolean validateDirectedTopoSolidPropertyType​(DirectedTopoSolidPropertyType directedTopoSolidPropertyType,
                                                             DiagnosticChain diagnostics,
                                                             Map<Object,​Object> context)
      • validateDirectionPropertyType

        public boolean validateDirectionPropertyType​(DirectionPropertyType directionPropertyType,
                                                     DiagnosticChain diagnostics,
                                                     Map<Object,​Object> context)
      • validateDirectionVectorType

        public boolean validateDirectionVectorType​(DirectionVectorType directionVectorType,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
      • validateDirectPositionListType

        public boolean validateDirectPositionListType​(DirectPositionListType directPositionListType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateDirectPositionType

        public boolean validateDirectPositionType​(DirectPositionType directPositionType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateDMSAngleType

        public boolean validateDMSAngleType​(DMSAngleType dmsAngleType,
                                            DiagnosticChain diagnostics,
                                            Map<Object,​Object> context)
      • validateDocumentRoot

        public boolean validateDocumentRoot​(DocumentRoot documentRoot,
                                            DiagnosticChain diagnostics,
                                            Map<Object,​Object> context)
      • validateDomainSetType

        public boolean validateDomainSetType​(DomainSetType domainSetType,
                                             DiagnosticChain diagnostics,
                                             Map<Object,​Object> context)
      • validateDynamicFeatureCollectionType

        public boolean validateDynamicFeatureCollectionType​(DynamicFeatureCollectionType dynamicFeatureCollectionType,
                                                            DiagnosticChain diagnostics,
                                                            Map<Object,​Object> context)
      • validateDynamicFeatureType

        public boolean validateDynamicFeatureType​(DynamicFeatureType dynamicFeatureType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateEdgeType

        public boolean validateEdgeType​(EdgeType edgeType,
                                        DiagnosticChain diagnostics,
                                        Map<Object,​Object> context)
      • validateEllipsoidalCSRefType

        public boolean validateEllipsoidalCSRefType​(EllipsoidalCSRefType ellipsoidalCSRefType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateEllipsoidalCSType

        public boolean validateEllipsoidalCSType​(EllipsoidalCSType ellipsoidalCSType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateEllipsoidBaseType

        public boolean validateEllipsoidBaseType​(EllipsoidBaseType ellipsoidBaseType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateEllipsoidRefType

        public boolean validateEllipsoidRefType​(EllipsoidRefType ellipsoidRefType,
                                                DiagnosticChain diagnostics,
                                                Map<Object,​Object> context)
      • validateEllipsoidType

        public boolean validateEllipsoidType​(EllipsoidType ellipsoidType,
                                             DiagnosticChain diagnostics,
                                             Map<Object,​Object> context)
      • validateEngineeringCRSRefType

        public boolean validateEngineeringCRSRefType​(EngineeringCRSRefType engineeringCRSRefType,
                                                     DiagnosticChain diagnostics,
                                                     Map<Object,​Object> context)
      • validateEngineeringCRSType

        public boolean validateEngineeringCRSType​(EngineeringCRSType engineeringCRSType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateEngineeringDatumRefType

        public boolean validateEngineeringDatumRefType​(EngineeringDatumRefType engineeringDatumRefType,
                                                       DiagnosticChain diagnostics,
                                                       Map<Object,​Object> context)
      • validateEngineeringDatumType

        public boolean validateEngineeringDatumType​(EngineeringDatumType engineeringDatumType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateEnvelopeType

        public boolean validateEnvelopeType​(EnvelopeType envelopeType,
                                            DiagnosticChain diagnostics,
                                            Map<Object,​Object> context)
      • validateEnvelopeWithTimePeriodType

        public boolean validateEnvelopeWithTimePeriodType​(EnvelopeWithTimePeriodType envelopeWithTimePeriodType,
                                                          DiagnosticChain diagnostics,
                                                          Map<Object,​Object> context)
      • validateExtentType

        public boolean validateExtentType​(ExtentType extentType,
                                          DiagnosticChain diagnostics,
                                          Map<Object,​Object> context)
      • validateFaceType

        public boolean validateFaceType​(FaceType faceType,
                                        DiagnosticChain diagnostics,
                                        Map<Object,​Object> context)
      • validateFeatureArrayPropertyType

        public boolean validateFeatureArrayPropertyType​(FeatureArrayPropertyType featureArrayPropertyType,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
      • validateFeatureCollectionType

        public boolean validateFeatureCollectionType​(FeatureCollectionType featureCollectionType,
                                                     DiagnosticChain diagnostics,
                                                     Map<Object,​Object> context)
      • validateFeaturePropertyType

        public boolean validateFeaturePropertyType​(FeaturePropertyType featurePropertyType,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
      • validateFeatureStylePropertyType

        public boolean validateFeatureStylePropertyType​(FeatureStylePropertyType featureStylePropertyType,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
      • validateFeatureStyleType

        public boolean validateFeatureStyleType​(FeatureStyleType featureStyleType,
                                                DiagnosticChain diagnostics,
                                                Map<Object,​Object> context)
      • validateFileType

        public boolean validateFileType​(FileType fileType,
                                        DiagnosticChain diagnostics,
                                        Map<Object,​Object> context)
      • validateFormulaType

        public boolean validateFormulaType​(FormulaType formulaType,
                                           DiagnosticChain diagnostics,
                                           Map<Object,​Object> context)
      • validateGeneralConversionRefType

        public boolean validateGeneralConversionRefType​(GeneralConversionRefType generalConversionRefType,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
      • validateGeneralTransformationRefType

        public boolean validateGeneralTransformationRefType​(GeneralTransformationRefType generalTransformationRefType,
                                                            DiagnosticChain diagnostics,
                                                            Map<Object,​Object> context)
      • validateGenericMetaDataType

        public boolean validateGenericMetaDataType​(GenericMetaDataType genericMetaDataType,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
      • validateGeocentricCRSRefType

        public boolean validateGeocentricCRSRefType​(GeocentricCRSRefType geocentricCRSRefType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateGeocentricCRSType

        public boolean validateGeocentricCRSType​(GeocentricCRSType geocentricCRSType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateGeodesicStringType

        public boolean validateGeodesicStringType​(GeodesicStringType geodesicStringType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateGeodesicType

        public boolean validateGeodesicType​(GeodesicType geodesicType,
                                            DiagnosticChain diagnostics,
                                            Map<Object,​Object> context)
      • validateGeodeticDatumRefType

        public boolean validateGeodeticDatumRefType​(GeodeticDatumRefType geodeticDatumRefType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateGeodeticDatumType

        public boolean validateGeodeticDatumType​(GeodeticDatumType geodeticDatumType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateGeographicCRSRefType

        public boolean validateGeographicCRSRefType​(GeographicCRSRefType geographicCRSRefType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateGeographicCRSType

        public boolean validateGeographicCRSType​(GeographicCRSType geographicCRSType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateGeometricComplexPropertyType

        public boolean validateGeometricComplexPropertyType​(GeometricComplexPropertyType geometricComplexPropertyType,
                                                            DiagnosticChain diagnostics,
                                                            Map<Object,​Object> context)
      • validateGeometricComplexType

        public boolean validateGeometricComplexType​(GeometricComplexType geometricComplexType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateGeometricPrimitivePropertyType

        public boolean validateGeometricPrimitivePropertyType​(GeometricPrimitivePropertyType geometricPrimitivePropertyType,
                                                              DiagnosticChain diagnostics,
                                                              Map<Object,​Object> context)
      • validateGeometryArrayPropertyType

        public boolean validateGeometryArrayPropertyType​(GeometryArrayPropertyType geometryArrayPropertyType,
                                                         DiagnosticChain diagnostics,
                                                         Map<Object,​Object> context)
      • validateGeometryPropertyType

        public boolean validateGeometryPropertyType​(GeometryPropertyType geometryPropertyType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateGeometryStylePropertyType

        public boolean validateGeometryStylePropertyType​(GeometryStylePropertyType geometryStylePropertyType,
                                                         DiagnosticChain diagnostics,
                                                         Map<Object,​Object> context)
      • validateGeometryStyleType

        public boolean validateGeometryStyleType​(GeometryStyleType geometryStyleType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateGraphStylePropertyType

        public boolean validateGraphStylePropertyType​(GraphStylePropertyType graphStylePropertyType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateGraphStyleType

        public boolean validateGraphStyleType​(GraphStyleType graphStyleType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateGridCoverageType

        public boolean validateGridCoverageType​(GridCoverageType gridCoverageType,
                                                DiagnosticChain diagnostics,
                                                Map<Object,​Object> context)
      • validateGridDomainType

        public boolean validateGridDomainType​(GridDomainType gridDomainType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateGridEnvelopeType

        public boolean validateGridEnvelopeType​(GridEnvelopeType gridEnvelopeType,
                                                DiagnosticChain diagnostics,
                                                Map<Object,​Object> context)
      • validateGridFunctionType

        public boolean validateGridFunctionType​(GridFunctionType gridFunctionType,
                                                DiagnosticChain diagnostics,
                                                Map<Object,​Object> context)
      • validateGridLengthType

        public boolean validateGridLengthType​(GridLengthType gridLengthType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateGridLimitsType

        public boolean validateGridLimitsType​(GridLimitsType gridLimitsType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateGridType

        public boolean validateGridType​(GridType gridType,
                                        DiagnosticChain diagnostics,
                                        Map<Object,​Object> context)
      • validateHistoryPropertyType

        public boolean validateHistoryPropertyType​(HistoryPropertyType historyPropertyType,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
      • validateIdentifierType

        public boolean validateIdentifierType​(IdentifierType identifierType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateImageCRSRefType

        public boolean validateImageCRSRefType​(ImageCRSRefType imageCRSRefType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateImageCRSType

        public boolean validateImageCRSType​(ImageCRSType imageCRSType,
                                            DiagnosticChain diagnostics,
                                            Map<Object,​Object> context)
      • validateImageDatumRefType

        public boolean validateImageDatumRefType​(ImageDatumRefType imageDatumRefType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateImageDatumType

        public boolean validateImageDatumType​(ImageDatumType imageDatumType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateIndexMapType

        public boolean validateIndexMapType​(IndexMapType indexMapType,
                                            DiagnosticChain diagnostics,
                                            Map<Object,​Object> context)
      • validateIndirectEntryType

        public boolean validateIndirectEntryType​(IndirectEntryType indirectEntryType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateIsolatedPropertyType

        public boolean validateIsolatedPropertyType​(IsolatedPropertyType isolatedPropertyType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateKnotPropertyType

        public boolean validateKnotPropertyType​(KnotPropertyType knotPropertyType,
                                                DiagnosticChain diagnostics,
                                                Map<Object,​Object> context)
      • validateKnotType

        public boolean validateKnotType​(KnotType knotType,
                                        DiagnosticChain diagnostics,
                                        Map<Object,​Object> context)
      • validateLabelStylePropertyType

        public boolean validateLabelStylePropertyType​(LabelStylePropertyType labelStylePropertyType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateLabelStyleType

        public boolean validateLabelStyleType​(LabelStyleType labelStyleType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateLabelType

        public boolean validateLabelType​(LabelType labelType,
                                         DiagnosticChain diagnostics,
                                         Map<Object,​Object> context)
      • validateLengthType

        public boolean validateLengthType​(LengthType lengthType,
                                          DiagnosticChain diagnostics,
                                          Map<Object,​Object> context)
      • validateLinearCSRefType

        public boolean validateLinearCSRefType​(LinearCSRefType linearCSRefType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateLinearCSType

        public boolean validateLinearCSType​(LinearCSType linearCSType,
                                            DiagnosticChain diagnostics,
                                            Map<Object,​Object> context)
      • validateLinearRingPropertyType

        public boolean validateLinearRingPropertyType​(LinearRingPropertyType linearRingPropertyType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateLinearRingType

        public boolean validateLinearRingType​(LinearRingType linearRingType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateLineStringPropertyType

        public boolean validateLineStringPropertyType​(LineStringPropertyType lineStringPropertyType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateLineStringSegmentType

        public boolean validateLineStringSegmentType​(LineStringSegmentType lineStringSegmentType,
                                                     DiagnosticChain diagnostics,
                                                     Map<Object,​Object> context)
      • validateLineStringType

        public boolean validateLineStringType​(LineStringType lineStringType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateLocationPropertyType

        public boolean validateLocationPropertyType​(LocationPropertyType locationPropertyType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateMeasureListType

        public boolean validateMeasureListType​(MeasureListType measureListType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateMeasureOrNullListType

        public boolean validateMeasureOrNullListType​(MeasureOrNullListType measureOrNullListType,
                                                     DiagnosticChain diagnostics,
                                                     Map<Object,​Object> context)
      • validateMeasureType

        public boolean validateMeasureType​(MeasureType measureType,
                                           DiagnosticChain diagnostics,
                                           Map<Object,​Object> context)
      • validateMetaDataPropertyType

        public boolean validateMetaDataPropertyType​(MetaDataPropertyType metaDataPropertyType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateMovingObjectStatusType

        public boolean validateMovingObjectStatusType​(MovingObjectStatusType movingObjectStatusType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateMultiCurveCoverageType

        public boolean validateMultiCurveCoverageType​(MultiCurveCoverageType multiCurveCoverageType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateMultiCurveDomainType

        public boolean validateMultiCurveDomainType​(MultiCurveDomainType multiCurveDomainType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateMultiCurvePropertyType

        public boolean validateMultiCurvePropertyType​(MultiCurvePropertyType multiCurvePropertyType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateMultiCurveType

        public boolean validateMultiCurveType​(MultiCurveType multiCurveType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateMultiGeometryPropertyType

        public boolean validateMultiGeometryPropertyType​(MultiGeometryPropertyType multiGeometryPropertyType,
                                                         DiagnosticChain diagnostics,
                                                         Map<Object,​Object> context)
      • validateMultiGeometryType

        public boolean validateMultiGeometryType​(MultiGeometryType multiGeometryType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateMultiLineStringPropertyType

        public boolean validateMultiLineStringPropertyType​(MultiLineStringPropertyType multiLineStringPropertyType,
                                                           DiagnosticChain diagnostics,
                                                           Map<Object,​Object> context)
      • validateMultiLineStringType

        public boolean validateMultiLineStringType​(MultiLineStringType multiLineStringType,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
      • validateMultiPointCoverageType

        public boolean validateMultiPointCoverageType​(MultiPointCoverageType multiPointCoverageType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateMultiPointDomainType

        public boolean validateMultiPointDomainType​(MultiPointDomainType multiPointDomainType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateMultiPointPropertyType

        public boolean validateMultiPointPropertyType​(MultiPointPropertyType multiPointPropertyType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateMultiPointType

        public boolean validateMultiPointType​(MultiPointType multiPointType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateMultiPolygonPropertyType

        public boolean validateMultiPolygonPropertyType​(MultiPolygonPropertyType multiPolygonPropertyType,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
      • validateMultiPolygonType

        public boolean validateMultiPolygonType​(MultiPolygonType multiPolygonType,
                                                DiagnosticChain diagnostics,
                                                Map<Object,​Object> context)
      • validateMultiSolidCoverageType

        public boolean validateMultiSolidCoverageType​(MultiSolidCoverageType multiSolidCoverageType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateMultiSolidDomainType

        public boolean validateMultiSolidDomainType​(MultiSolidDomainType multiSolidDomainType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateMultiSolidPropertyType

        public boolean validateMultiSolidPropertyType​(MultiSolidPropertyType multiSolidPropertyType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateMultiSolidType

        public boolean validateMultiSolidType​(MultiSolidType multiSolidType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateMultiSurfaceCoverageType

        public boolean validateMultiSurfaceCoverageType​(MultiSurfaceCoverageType multiSurfaceCoverageType,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
      • validateMultiSurfaceDomainType

        public boolean validateMultiSurfaceDomainType​(MultiSurfaceDomainType multiSurfaceDomainType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateMultiSurfacePropertyType

        public boolean validateMultiSurfacePropertyType​(MultiSurfacePropertyType multiSurfacePropertyType,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
      • validateMultiSurfaceType

        public boolean validateMultiSurfaceType​(MultiSurfaceType multiSurfaceType,
                                                DiagnosticChain diagnostics,
                                                Map<Object,​Object> context)
      • validateNodeType

        public boolean validateNodeType​(NodeType nodeType,
                                        DiagnosticChain diagnostics,
                                        Map<Object,​Object> context)
      • validateObliqueCartesianCSRefType

        public boolean validateObliqueCartesianCSRefType​(ObliqueCartesianCSRefType obliqueCartesianCSRefType,
                                                         DiagnosticChain diagnostics,
                                                         Map<Object,​Object> context)
      • validateObliqueCartesianCSType

        public boolean validateObliqueCartesianCSType​(ObliqueCartesianCSType obliqueCartesianCSType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateObservationType

        public boolean validateObservationType​(ObservationType observationType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateOffsetCurveType

        public boolean validateOffsetCurveType​(OffsetCurveType offsetCurveType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateOperationMethodBaseType

        public boolean validateOperationMethodBaseType​(OperationMethodBaseType operationMethodBaseType,
                                                       DiagnosticChain diagnostics,
                                                       Map<Object,​Object> context)
      • validateOperationMethodRefType

        public boolean validateOperationMethodRefType​(OperationMethodRefType operationMethodRefType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateOperationMethodType

        public boolean validateOperationMethodType​(OperationMethodType operationMethodType,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
      • validateOperationParameterBaseType

        public boolean validateOperationParameterBaseType​(OperationParameterBaseType operationParameterBaseType,
                                                          DiagnosticChain diagnostics,
                                                          Map<Object,​Object> context)
      • validateOperationParameterGroupRefType

        public boolean validateOperationParameterGroupRefType​(OperationParameterGroupRefType operationParameterGroupRefType,
                                                              DiagnosticChain diagnostics,
                                                              Map<Object,​Object> context)
      • validateOperationParameterGroupType

        public boolean validateOperationParameterGroupType​(OperationParameterGroupType operationParameterGroupType,
                                                           DiagnosticChain diagnostics,
                                                           Map<Object,​Object> context)
      • validateOperationParameterRefType

        public boolean validateOperationParameterRefType​(OperationParameterRefType operationParameterRefType,
                                                         DiagnosticChain diagnostics,
                                                         Map<Object,​Object> context)
      • validateOperationParameterType

        public boolean validateOperationParameterType​(OperationParameterType operationParameterType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateOperationRefType

        public boolean validateOperationRefType​(OperationRefType operationRefType,
                                                DiagnosticChain diagnostics,
                                                Map<Object,​Object> context)
      • validateOrientableCurveType

        public boolean validateOrientableCurveType​(OrientableCurveType orientableCurveType,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
      • validateOrientableSurfaceType

        public boolean validateOrientableSurfaceType​(OrientableSurfaceType orientableSurfaceType,
                                                     DiagnosticChain diagnostics,
                                                     Map<Object,​Object> context)
      • validateParameterValueGroupType

        public boolean validateParameterValueGroupType​(ParameterValueGroupType parameterValueGroupType,
                                                       DiagnosticChain diagnostics,
                                                       Map<Object,​Object> context)
      • validateParameterValueType

        public boolean validateParameterValueType​(ParameterValueType parameterValueType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validatePassThroughOperationRefType

        public boolean validatePassThroughOperationRefType​(PassThroughOperationRefType passThroughOperationRefType,
                                                           DiagnosticChain diagnostics,
                                                           Map<Object,​Object> context)
      • validatePassThroughOperationType

        public boolean validatePassThroughOperationType​(PassThroughOperationType passThroughOperationType,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
      • validatePixelInCellType

        public boolean validatePixelInCellType​(PixelInCellType pixelInCellType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validatePointArrayPropertyType

        public boolean validatePointArrayPropertyType​(PointArrayPropertyType pointArrayPropertyType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validatePointPropertyType

        public boolean validatePointPropertyType​(PointPropertyType pointPropertyType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validatePointType

        public boolean validatePointType​(PointType pointType,
                                         DiagnosticChain diagnostics,
                                         Map<Object,​Object> context)
      • validatePolarCSRefType

        public boolean validatePolarCSRefType​(PolarCSRefType polarCSRefType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validatePolarCSType

        public boolean validatePolarCSType​(PolarCSType polarCSType,
                                           DiagnosticChain diagnostics,
                                           Map<Object,​Object> context)
      • validatePolygonPatchArrayPropertyType

        public boolean validatePolygonPatchArrayPropertyType​(PolygonPatchArrayPropertyType polygonPatchArrayPropertyType,
                                                             DiagnosticChain diagnostics,
                                                             Map<Object,​Object> context)
      • validatePolygonPatchType

        public boolean validatePolygonPatchType​(PolygonPatchType polygonPatchType,
                                                DiagnosticChain diagnostics,
                                                Map<Object,​Object> context)
      • validatePolygonPropertyType

        public boolean validatePolygonPropertyType​(PolygonPropertyType polygonPropertyType,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
      • validatePolygonType

        public boolean validatePolygonType​(PolygonType polygonType,
                                           DiagnosticChain diagnostics,
                                           Map<Object,​Object> context)
      • validatePolyhedralSurfaceType

        public boolean validatePolyhedralSurfaceType​(PolyhedralSurfaceType polyhedralSurfaceType,
                                                     DiagnosticChain diagnostics,
                                                     Map<Object,​Object> context)
      • validatePrimeMeridianBaseType

        public boolean validatePrimeMeridianBaseType​(PrimeMeridianBaseType primeMeridianBaseType,
                                                     DiagnosticChain diagnostics,
                                                     Map<Object,​Object> context)
      • validatePrimeMeridianRefType

        public boolean validatePrimeMeridianRefType​(PrimeMeridianRefType primeMeridianRefType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validatePrimeMeridianType

        public boolean validatePrimeMeridianType​(PrimeMeridianType primeMeridianType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validatePriorityLocationPropertyType

        public boolean validatePriorityLocationPropertyType​(PriorityLocationPropertyType priorityLocationPropertyType,
                                                            DiagnosticChain diagnostics,
                                                            Map<Object,​Object> context)
      • validateProjectedCRSRefType

        public boolean validateProjectedCRSRefType​(ProjectedCRSRefType projectedCRSRefType,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
      • validateProjectedCRSType

        public boolean validateProjectedCRSType​(ProjectedCRSType projectedCRSType,
                                                DiagnosticChain diagnostics,
                                                Map<Object,​Object> context)
      • validateQuantityExtentType

        public boolean validateQuantityExtentType​(QuantityExtentType quantityExtentType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateQuantityPropertyType

        public boolean validateQuantityPropertyType​(QuantityPropertyType quantityPropertyType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateRangeParametersType

        public boolean validateRangeParametersType​(RangeParametersType rangeParametersType,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
      • validateRangeSetType

        public boolean validateRangeSetType​(RangeSetType rangeSetType,
                                            DiagnosticChain diagnostics,
                                            Map<Object,​Object> context)
      • validateRectangleType

        public boolean validateRectangleType​(RectangleType rectangleType,
                                             DiagnosticChain diagnostics,
                                             Map<Object,​Object> context)
      • validateRectifiedGridCoverageType

        public boolean validateRectifiedGridCoverageType​(RectifiedGridCoverageType rectifiedGridCoverageType,
                                                         DiagnosticChain diagnostics,
                                                         Map<Object,​Object> context)
      • validateRectifiedGridDomainType

        public boolean validateRectifiedGridDomainType​(RectifiedGridDomainType rectifiedGridDomainType,
                                                       DiagnosticChain diagnostics,
                                                       Map<Object,​Object> context)
      • validateRectifiedGridType

        public boolean validateRectifiedGridType​(RectifiedGridType rectifiedGridType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateReferenceSystemRefType

        public boolean validateReferenceSystemRefType​(ReferenceSystemRefType referenceSystemRefType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateReferenceType

        public boolean validateReferenceType​(ReferenceType referenceType,
                                             DiagnosticChain diagnostics,
                                             Map<Object,​Object> context)
      • validateRefLocationType

        public boolean validateRefLocationType​(RefLocationType refLocationType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateRelatedTimeType

        public boolean validateRelatedTimeType​(RelatedTimeType relatedTimeType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateRingPropertyType

        public boolean validateRingPropertyType​(RingPropertyType ringPropertyType,
                                                DiagnosticChain diagnostics,
                                                Map<Object,​Object> context)
      • validateRingType

        public boolean validateRingType​(RingType ringType,
                                        DiagnosticChain diagnostics,
                                        Map<Object,​Object> context)
      • validateRowType

        public boolean validateRowType​(RowType rowType,
                                       DiagnosticChain diagnostics,
                                       Map<Object,​Object> context)
      • validateScalarValuePropertyType

        public boolean validateScalarValuePropertyType​(ScalarValuePropertyType scalarValuePropertyType,
                                                       DiagnosticChain diagnostics,
                                                       Map<Object,​Object> context)
      • validateScaleType

        public boolean validateScaleType​(ScaleType scaleType,
                                         DiagnosticChain diagnostics,
                                         Map<Object,​Object> context)
      • validateSecondDefiningParameterType

        public boolean validateSecondDefiningParameterType​(SecondDefiningParameterType secondDefiningParameterType,
                                                           DiagnosticChain diagnostics,
                                                           Map<Object,​Object> context)
      • validateSequenceRuleType

        public boolean validateSequenceRuleType​(SequenceRuleType sequenceRuleType,
                                                DiagnosticChain diagnostics,
                                                Map<Object,​Object> context)
      • validateSingleOperationRefType

        public boolean validateSingleOperationRefType​(SingleOperationRefType singleOperationRefType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateSolidArrayPropertyType

        public boolean validateSolidArrayPropertyType​(SolidArrayPropertyType solidArrayPropertyType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateSolidPropertyType

        public boolean validateSolidPropertyType​(SolidPropertyType solidPropertyType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateSolidType

        public boolean validateSolidType​(SolidType solidType,
                                         DiagnosticChain diagnostics,
                                         Map<Object,​Object> context)
      • validateSpeedType

        public boolean validateSpeedType​(SpeedType speedType,
                                         DiagnosticChain diagnostics,
                                         Map<Object,​Object> context)
      • validateSphereType

        public boolean validateSphereType​(SphereType sphereType,
                                          DiagnosticChain diagnostics,
                                          Map<Object,​Object> context)
      • validateSphericalCSRefType

        public boolean validateSphericalCSRefType​(SphericalCSRefType sphericalCSRefType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateSphericalCSType

        public boolean validateSphericalCSType​(SphericalCSType sphericalCSType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateStringOrRefType

        public boolean validateStringOrRefType​(StringOrRefType stringOrRefType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateStyleType

        public boolean validateStyleType​(StyleType styleType,
                                         DiagnosticChain diagnostics,
                                         Map<Object,​Object> context)
      • validateStyleVariationType

        public boolean validateStyleVariationType​(StyleVariationType styleVariationType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateSurfaceArrayPropertyType

        public boolean validateSurfaceArrayPropertyType​(SurfaceArrayPropertyType surfaceArrayPropertyType,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
      • validateSurfacePatchArrayPropertyType

        public boolean validateSurfacePatchArrayPropertyType​(SurfacePatchArrayPropertyType surfacePatchArrayPropertyType,
                                                             DiagnosticChain diagnostics,
                                                             Map<Object,​Object> context)
      • validateSurfacePropertyType

        public boolean validateSurfacePropertyType​(SurfacePropertyType surfacePropertyType,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
      • validateSurfaceType

        public boolean validateSurfaceType​(SurfaceType surfaceType,
                                           DiagnosticChain diagnostics,
                                           Map<Object,​Object> context)
      • validateSymbolType

        public boolean validateSymbolType​(SymbolType symbolType,
                                          DiagnosticChain diagnostics,
                                          Map<Object,​Object> context)
      • validateTargetPropertyType

        public boolean validateTargetPropertyType​(TargetPropertyType targetPropertyType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateTemporalCRSRefType

        public boolean validateTemporalCRSRefType​(TemporalCRSRefType temporalCRSRefType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateTemporalCRSType

        public boolean validateTemporalCRSType​(TemporalCRSType temporalCRSType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateTemporalCSRefType

        public boolean validateTemporalCSRefType​(TemporalCSRefType temporalCSRefType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateTemporalCSType

        public boolean validateTemporalCSType​(TemporalCSType temporalCSType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateTemporalDatumBaseType

        public boolean validateTemporalDatumBaseType​(TemporalDatumBaseType temporalDatumBaseType,
                                                     DiagnosticChain diagnostics,
                                                     Map<Object,​Object> context)
      • validateTemporalDatumRefType

        public boolean validateTemporalDatumRefType​(TemporalDatumRefType temporalDatumRefType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateTemporalDatumType

        public boolean validateTemporalDatumType​(TemporalDatumType temporalDatumType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateTimeCalendarEraPropertyType

        public boolean validateTimeCalendarEraPropertyType​(TimeCalendarEraPropertyType timeCalendarEraPropertyType,
                                                           DiagnosticChain diagnostics,
                                                           Map<Object,​Object> context)
      • validateTimeCalendarEraType

        public boolean validateTimeCalendarEraType​(TimeCalendarEraType timeCalendarEraType,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
      • validateTimeCalendarPropertyType

        public boolean validateTimeCalendarPropertyType​(TimeCalendarPropertyType timeCalendarPropertyType,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
      • validateTimeCalendarType

        public boolean validateTimeCalendarType​(TimeCalendarType timeCalendarType,
                                                DiagnosticChain diagnostics,
                                                Map<Object,​Object> context)
      • validateTimeClockPropertyType

        public boolean validateTimeClockPropertyType​(TimeClockPropertyType timeClockPropertyType,
                                                     DiagnosticChain diagnostics,
                                                     Map<Object,​Object> context)
      • validateTimeClockType

        public boolean validateTimeClockType​(TimeClockType timeClockType,
                                             DiagnosticChain diagnostics,
                                             Map<Object,​Object> context)
      • validateTimeCoordinateSystemType

        public boolean validateTimeCoordinateSystemType​(TimeCoordinateSystemType timeCoordinateSystemType,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
      • validateTimeEdgePropertyType

        public boolean validateTimeEdgePropertyType​(TimeEdgePropertyType timeEdgePropertyType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateTimeEdgeType

        public boolean validateTimeEdgeType​(TimeEdgeType timeEdgeType,
                                            DiagnosticChain diagnostics,
                                            Map<Object,​Object> context)
      • validateTimeInstantPropertyType

        public boolean validateTimeInstantPropertyType​(TimeInstantPropertyType timeInstantPropertyType,
                                                       DiagnosticChain diagnostics,
                                                       Map<Object,​Object> context)
      • validateTimeInstantType

        public boolean validateTimeInstantType​(TimeInstantType timeInstantType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateTimeIntervalLengthType

        public boolean validateTimeIntervalLengthType​(TimeIntervalLengthType timeIntervalLengthType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateTimeNodePropertyType

        public boolean validateTimeNodePropertyType​(TimeNodePropertyType timeNodePropertyType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateTimeNodeType

        public boolean validateTimeNodeType​(TimeNodeType timeNodeType,
                                            DiagnosticChain diagnostics,
                                            Map<Object,​Object> context)
      • validateTimeOrdinalEraPropertyType

        public boolean validateTimeOrdinalEraPropertyType​(TimeOrdinalEraPropertyType timeOrdinalEraPropertyType,
                                                          DiagnosticChain diagnostics,
                                                          Map<Object,​Object> context)
      • validateTimeOrdinalEraType

        public boolean validateTimeOrdinalEraType​(TimeOrdinalEraType timeOrdinalEraType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateTimeOrdinalReferenceSystemType

        public boolean validateTimeOrdinalReferenceSystemType​(TimeOrdinalReferenceSystemType timeOrdinalReferenceSystemType,
                                                              DiagnosticChain diagnostics,
                                                              Map<Object,​Object> context)
      • validateTimePeriodPropertyType

        public boolean validateTimePeriodPropertyType​(TimePeriodPropertyType timePeriodPropertyType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateTimePeriodType

        public boolean validateTimePeriodType​(TimePeriodType timePeriodType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateTimePositionType

        public boolean validateTimePositionType​(TimePositionType timePositionType,
                                                DiagnosticChain diagnostics,
                                                Map<Object,​Object> context)
      • validateTimePrimitivePropertyType

        public boolean validateTimePrimitivePropertyType​(TimePrimitivePropertyType timePrimitivePropertyType,
                                                         DiagnosticChain diagnostics,
                                                         Map<Object,​Object> context)
      • validateTimeTopologyComplexType

        public boolean validateTimeTopologyComplexType​(TimeTopologyComplexType timeTopologyComplexType,
                                                       DiagnosticChain diagnostics,
                                                       Map<Object,​Object> context)
      • validateTimeType

        public boolean validateTimeType​(TimeType timeType,
                                        DiagnosticChain diagnostics,
                                        Map<Object,​Object> context)
      • validateTinType

        public boolean validateTinType​(TinType tinType,
                                       DiagnosticChain diagnostics,
                                       Map<Object,​Object> context)
      • validateTopoComplexMemberType

        public boolean validateTopoComplexMemberType​(TopoComplexMemberType topoComplexMemberType,
                                                     DiagnosticChain diagnostics,
                                                     Map<Object,​Object> context)
      • validateTopoComplexType

        public boolean validateTopoComplexType​(TopoComplexType topoComplexType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateTopoCurvePropertyType

        public boolean validateTopoCurvePropertyType​(TopoCurvePropertyType topoCurvePropertyType,
                                                     DiagnosticChain diagnostics,
                                                     Map<Object,​Object> context)
      • validateTopoCurveType

        public boolean validateTopoCurveType​(TopoCurveType topoCurveType,
                                             DiagnosticChain diagnostics,
                                             Map<Object,​Object> context)
      • validateTopologyStylePropertyType

        public boolean validateTopologyStylePropertyType​(TopologyStylePropertyType topologyStylePropertyType,
                                                         DiagnosticChain diagnostics,
                                                         Map<Object,​Object> context)
      • validateTopologyStyleType

        public boolean validateTopologyStyleType​(TopologyStyleType topologyStyleType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateTopoPointPropertyType

        public boolean validateTopoPointPropertyType​(TopoPointPropertyType topoPointPropertyType,
                                                     DiagnosticChain diagnostics,
                                                     Map<Object,​Object> context)
      • validateTopoPointType

        public boolean validateTopoPointType​(TopoPointType topoPointType,
                                             DiagnosticChain diagnostics,
                                             Map<Object,​Object> context)
      • validateTopoPrimitiveMemberType

        public boolean validateTopoPrimitiveMemberType​(TopoPrimitiveMemberType topoPrimitiveMemberType,
                                                       DiagnosticChain diagnostics,
                                                       Map<Object,​Object> context)
      • validateTopoSolidType

        public boolean validateTopoSolidType​(TopoSolidType topoSolidType,
                                             DiagnosticChain diagnostics,
                                             Map<Object,​Object> context)
      • validateTopoSurfacePropertyType

        public boolean validateTopoSurfacePropertyType​(TopoSurfacePropertyType topoSurfacePropertyType,
                                                       DiagnosticChain diagnostics,
                                                       Map<Object,​Object> context)
      • validateTopoSurfaceType

        public boolean validateTopoSurfaceType​(TopoSurfaceType topoSurfaceType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateTopoVolumePropertyType

        public boolean validateTopoVolumePropertyType​(TopoVolumePropertyType topoVolumePropertyType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateTopoVolumeType

        public boolean validateTopoVolumeType​(TopoVolumeType topoVolumeType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateTrackType

        public boolean validateTrackType​(TrackType trackType,
                                         DiagnosticChain diagnostics,
                                         Map<Object,​Object> context)
      • validateTransformationRefType

        public boolean validateTransformationRefType​(TransformationRefType transformationRefType,
                                                     DiagnosticChain diagnostics,
                                                     Map<Object,​Object> context)
      • validateTransformationType

        public boolean validateTransformationType​(TransformationType transformationType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateTrianglePatchArrayPropertyType

        public boolean validateTrianglePatchArrayPropertyType​(TrianglePatchArrayPropertyType trianglePatchArrayPropertyType,
                                                              DiagnosticChain diagnostics,
                                                              Map<Object,​Object> context)
      • validateTriangleType

        public boolean validateTriangleType​(TriangleType triangleType,
                                            DiagnosticChain diagnostics,
                                            Map<Object,​Object> context)
      • validateTriangulatedSurfaceType

        public boolean validateTriangulatedSurfaceType​(TriangulatedSurfaceType triangulatedSurfaceType,
                                                       DiagnosticChain diagnostics,
                                                       Map<Object,​Object> context)
      • validateUnitDefinitionType

        public boolean validateUnitDefinitionType​(UnitDefinitionType unitDefinitionType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateUnitOfMeasureType

        public boolean validateUnitOfMeasureType​(UnitOfMeasureType unitOfMeasureType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateUserDefinedCSRefType

        public boolean validateUserDefinedCSRefType​(UserDefinedCSRefType userDefinedCSRefType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateUserDefinedCSType

        public boolean validateUserDefinedCSType​(UserDefinedCSType userDefinedCSType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateValueArrayPropertyType

        public boolean validateValueArrayPropertyType​(ValueArrayPropertyType valueArrayPropertyType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateValueArrayType

        public boolean validateValueArrayType​(ValueArrayType valueArrayType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateValuePropertyType

        public boolean validateValuePropertyType​(ValuePropertyType valuePropertyType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateVectorType

        public boolean validateVectorType​(VectorType vectorType,
                                          DiagnosticChain diagnostics,
                                          Map<Object,​Object> context)
      • validateVerticalCRSRefType

        public boolean validateVerticalCRSRefType​(VerticalCRSRefType verticalCRSRefType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateVerticalCRSType

        public boolean validateVerticalCRSType​(VerticalCRSType verticalCRSType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateVerticalCSRefType

        public boolean validateVerticalCSRefType​(VerticalCSRefType verticalCSRefType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateVerticalCSType

        public boolean validateVerticalCSType​(VerticalCSType verticalCSType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateVerticalDatumRefType

        public boolean validateVerticalDatumRefType​(VerticalDatumRefType verticalDatumRefType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateVerticalDatumType

        public boolean validateVerticalDatumType​(VerticalDatumType verticalDatumType,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateVerticalDatumTypeType

        public boolean validateVerticalDatumTypeType​(VerticalDatumTypeType verticalDatumTypeType,
                                                     DiagnosticChain diagnostics,
                                                     Map<Object,​Object> context)
      • validateVolumeType

        public boolean validateVolumeType​(VolumeType volumeType,
                                          DiagnosticChain diagnostics,
                                          Map<Object,​Object> context)
      • validateAesheticCriteriaType

        public boolean validateAesheticCriteriaType​(AesheticCriteriaType aesheticCriteriaType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateCompassPointEnumeration

        public boolean validateCompassPointEnumeration​(CompassPointEnumeration compassPointEnumeration,
                                                       DiagnosticChain diagnostics,
                                                       Map<Object,​Object> context)
      • validateCurveInterpolationType

        public boolean validateCurveInterpolationType​(CurveInterpolationType curveInterpolationType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateDirectionTypeMember0

        public boolean validateDirectionTypeMember0​(DirectionTypeMember0 directionTypeMember0,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateDrawingTypeType

        public boolean validateDrawingTypeType​(DrawingTypeType drawingTypeType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateFileValueModelType

        public boolean validateFileValueModelType​(FileValueModelType fileValueModelType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateGraphTypeType

        public boolean validateGraphTypeType​(GraphTypeType graphTypeType,
                                             DiagnosticChain diagnostics,
                                             Map<Object,​Object> context)
      • validateIncrementOrder

        public boolean validateIncrementOrder​(IncrementOrder incrementOrder,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateIsSphereType

        public boolean validateIsSphereType​(IsSphereType isSphereType,
                                            DiagnosticChain diagnostics,
                                            Map<Object,​Object> context)
      • validateKnotTypesType

        public boolean validateKnotTypesType​(KnotTypesType knotTypesType,
                                             DiagnosticChain diagnostics,
                                             Map<Object,​Object> context)
      • validateLineTypeType

        public boolean validateLineTypeType​(LineTypeType lineTypeType,
                                            DiagnosticChain diagnostics,
                                            Map<Object,​Object> context)
      • validateNullEnumerationMember0

        public boolean validateNullEnumerationMember0​(NullEnumerationMember0 nullEnumerationMember0,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateQueryGrammarEnumeration

        public boolean validateQueryGrammarEnumeration​(QueryGrammarEnumeration queryGrammarEnumeration,
                                                       DiagnosticChain diagnostics,
                                                       Map<Object,​Object> context)
      • validateRelativePositionType

        public boolean validateRelativePositionType​(RelativePositionType relativePositionType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateSequenceRuleNames

        public boolean validateSequenceRuleNames​(SequenceRuleNames sequenceRuleNames,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateSignType

        public boolean validateSignType​(SignType signType,
                                        DiagnosticChain diagnostics,
                                        Map<Object,​Object> context)
      • validateSuccessionType

        public boolean validateSuccessionType​(SuccessionType successionType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateSurfaceInterpolationType

        public boolean validateSurfaceInterpolationType​(SurfaceInterpolationType surfaceInterpolationType,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
      • validateSymbolTypeEnumeration

        public boolean validateSymbolTypeEnumeration​(SymbolTypeEnumeration symbolTypeEnumeration,
                                                     DiagnosticChain diagnostics,
                                                     Map<Object,​Object> context)
      • validateTimeIndeterminateValueType

        public boolean validateTimeIndeterminateValueType​(TimeIndeterminateValueType timeIndeterminateValueType,
                                                          DiagnosticChain diagnostics,
                                                          Map<Object,​Object> context)
      • validateTimeUnitTypeMember0

        public boolean validateTimeUnitTypeMember0​(TimeUnitTypeMember0 timeUnitTypeMember0,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
      • validateAesheticCriteriaTypeObject

        public boolean validateAesheticCriteriaTypeObject​(AesheticCriteriaType aesheticCriteriaTypeObject,
                                                          DiagnosticChain diagnostics,
                                                          Map<Object,​Object> context)
      • validateArcMinutesType

        public boolean validateArcMinutesType​(BigInteger arcMinutesType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateArcMinutesType_Max

        public boolean validateArcMinutesType_Max​(BigInteger arcMinutesType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
        Validates the Max constraint of 'Arc Minutes Type'.
      • validateArcSecondsType

        public boolean validateArcSecondsType​(BigDecimal arcSecondsType,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateArcSecondsType_Min

        public boolean validateArcSecondsType_Min​(BigDecimal arcSecondsType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
        Validates the Min constraint of 'Arc Seconds Type'.
      • validateArcSecondsType_Max

        public boolean validateArcSecondsType_Max​(BigDecimal arcSecondsType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
        Validates the Max constraint of 'Arc Seconds Type'.
      • validateBooleanList

        public boolean validateBooleanList​(List<?> booleanList,
                                           DiagnosticChain diagnostics,
                                           Map<Object,​Object> context)
      • validateBooleanList_ItemType

        public boolean validateBooleanList_ItemType​(List<?> booleanList,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
        Validates the ItemType constraint of 'Boolean List'.
      • validateBooleanOrNull

        public boolean validateBooleanOrNull​(Object booleanOrNull,
                                             DiagnosticChain diagnostics,
                                             Map<Object,​Object> context)
      • validateBooleanOrNull_MemberTypes

        public boolean validateBooleanOrNull_MemberTypes​(Object booleanOrNull,
                                                         DiagnosticChain diagnostics,
                                                         Map<Object,​Object> context)
        Validates the MemberTypes constraint of 'Boolean Or Null'.
      • validateBooleanOrNullList

        public boolean validateBooleanOrNullList​(List<?> booleanOrNullList,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateBooleanOrNullList_ItemType

        public boolean validateBooleanOrNullList_ItemType​(List<?> booleanOrNullList,
                                                          DiagnosticChain diagnostics,
                                                          Map<Object,​Object> context)
        Validates the ItemType constraint of 'Boolean Or Null List'.
      • validateCalDate_MemberTypes

        public boolean validateCalDate_MemberTypes​(XMLGregorianCalendar calDate,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
        Validates the MemberTypes constraint of 'Cal Date'.
      • validateCompassPointEnumerationObject

        public boolean validateCompassPointEnumerationObject​(CompassPointEnumeration compassPointEnumerationObject,
                                                             DiagnosticChain diagnostics,
                                                             Map<Object,​Object> context)
      • validateCountExtentType

        public boolean validateCountExtentType​(List<?> countExtentType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateCountExtentType_MinLength

        public boolean validateCountExtentType_MinLength​(List<?> countExtentType,
                                                         DiagnosticChain diagnostics,
                                                         Map<Object,​Object> context)
        Validates the MinLength constraint of 'Count Extent Type'.
      • validateCountExtentType_MaxLength

        public boolean validateCountExtentType_MaxLength​(List<?> countExtentType,
                                                         DiagnosticChain diagnostics,
                                                         Map<Object,​Object> context)
        Validates the MaxLength constraint of 'Count Extent Type'.
      • validateCurveInterpolationTypeObject

        public boolean validateCurveInterpolationTypeObject​(CurveInterpolationType curveInterpolationTypeObject,
                                                            DiagnosticChain diagnostics,
                                                            Map<Object,​Object> context)
      • validateDecimalMinutesType

        public boolean validateDecimalMinutesType​(BigDecimal decimalMinutesType,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateDecimalMinutesType_Min

        public boolean validateDecimalMinutesType_Min​(BigDecimal decimalMinutesType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
        Validates the Min constraint of 'Decimal Minutes Type'.
      • validateDecimalMinutesType_Max

        public boolean validateDecimalMinutesType_Max​(BigDecimal decimalMinutesType,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
        Validates the Max constraint of 'Decimal Minutes Type'.
      • validateDegreeValueType

        public boolean validateDegreeValueType​(BigInteger degreeValueType,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateDegreeValueType_Max

        public boolean validateDegreeValueType_Max​(BigInteger degreeValueType,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
        Validates the Max constraint of 'Degree Value Type'.
      • validateDirectionType

        public boolean validateDirectionType​(Enumerator directionType,
                                             DiagnosticChain diagnostics,
                                             Map<Object,​Object> context)
      • validateDirectionType_MemberTypes

        public boolean validateDirectionType_MemberTypes​(Enumerator directionType,
                                                         DiagnosticChain diagnostics,
                                                         Map<Object,​Object> context)
        Validates the MemberTypes constraint of 'Direction Type'.
      • validateDirectionTypeMember0Object

        public boolean validateDirectionTypeMember0Object​(DirectionTypeMember0 directionTypeMember0Object,
                                                          DiagnosticChain diagnostics,
                                                          Map<Object,​Object> context)
      • validateDirectionTypeMember1

        public boolean validateDirectionTypeMember1​(SignType directionTypeMember1,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateDoubleList

        public boolean validateDoubleList​(List<?> doubleList,
                                          DiagnosticChain diagnostics,
                                          Map<Object,​Object> context)
      • validateDoubleList_ItemType

        public boolean validateDoubleList_ItemType​(List<?> doubleList,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
        Validates the ItemType constraint of 'Double List'.
      • validateDoubleOrNull

        public boolean validateDoubleOrNull​(Object doubleOrNull,
                                            DiagnosticChain diagnostics,
                                            Map<Object,​Object> context)
      • validateDoubleOrNull_MemberTypes

        public boolean validateDoubleOrNull_MemberTypes​(Object doubleOrNull,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
        Validates the MemberTypes constraint of 'Double Or Null'.
      • validateDoubleOrNullList

        public boolean validateDoubleOrNullList​(List<?> doubleOrNullList,
                                                DiagnosticChain diagnostics,
                                                Map<Object,​Object> context)
      • validateDoubleOrNullList_ItemType

        public boolean validateDoubleOrNullList_ItemType​(List<?> doubleOrNullList,
                                                         DiagnosticChain diagnostics,
                                                         Map<Object,​Object> context)
        Validates the ItemType constraint of 'Double Or Null List'.
      • validateDrawingTypeTypeObject

        public boolean validateDrawingTypeTypeObject​(DrawingTypeType drawingTypeTypeObject,
                                                     DiagnosticChain diagnostics,
                                                     Map<Object,​Object> context)
      • validateFileValueModelTypeObject

        public boolean validateFileValueModelTypeObject​(FileValueModelType fileValueModelTypeObject,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
      • validateGraphTypeTypeObject

        public boolean validateGraphTypeTypeObject​(GraphTypeType graphTypeTypeObject,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
      • validateIncrementOrderObject

        public boolean validateIncrementOrderObject​(IncrementOrder incrementOrderObject,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateIntegerList

        public boolean validateIntegerList​(List<?> integerList,
                                           DiagnosticChain diagnostics,
                                           Map<Object,​Object> context)
      • validateIntegerList_ItemType

        public boolean validateIntegerList_ItemType​(List<?> integerList,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
        Validates the ItemType constraint of 'Integer List'.
      • validateIntegerOrNull

        public boolean validateIntegerOrNull​(Object integerOrNull,
                                             DiagnosticChain diagnostics,
                                             Map<Object,​Object> context)
      • validateIntegerOrNull_MemberTypes

        public boolean validateIntegerOrNull_MemberTypes​(Object integerOrNull,
                                                         DiagnosticChain diagnostics,
                                                         Map<Object,​Object> context)
        Validates the MemberTypes constraint of 'Integer Or Null'.
      • validateIntegerOrNullList

        public boolean validateIntegerOrNullList​(List<?> integerOrNullList,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateIntegerOrNullList_ItemType

        public boolean validateIntegerOrNullList_ItemType​(List<?> integerOrNullList,
                                                          DiagnosticChain diagnostics,
                                                          Map<Object,​Object> context)
        Validates the ItemType constraint of 'Integer Or Null List'.
      • validateIsSphereTypeObject

        public boolean validateIsSphereTypeObject​(IsSphereType isSphereTypeObject,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateKnotTypesTypeObject

        public boolean validateKnotTypesTypeObject​(KnotTypesType knotTypesTypeObject,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
      • validateLineTypeTypeObject

        public boolean validateLineTypeTypeObject​(LineTypeType lineTypeTypeObject,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
      • validateNameList

        public boolean validateNameList​(List<?> nameList,
                                        DiagnosticChain diagnostics,
                                        Map<Object,​Object> context)
      • validateNameList_ItemType

        public boolean validateNameList_ItemType​(List<?> nameList,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
        Validates the ItemType constraint of 'Name List'.
      • validateNameOrNull

        public boolean validateNameOrNull​(Object nameOrNull,
                                          DiagnosticChain diagnostics,
                                          Map<Object,​Object> context)
      • validateNameOrNull_MemberTypes

        public boolean validateNameOrNull_MemberTypes​(Object nameOrNull,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
        Validates the MemberTypes constraint of 'Name Or Null'.
      • validateNameOrNullList

        public boolean validateNameOrNullList​(List<?> nameOrNullList,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateNameOrNullList_ItemType

        public boolean validateNameOrNullList_ItemType​(List<?> nameOrNullList,
                                                       DiagnosticChain diagnostics,
                                                       Map<Object,​Object> context)
        Validates the ItemType constraint of 'Name Or Null List'.
      • validateNCNameList

        public boolean validateNCNameList​(List<?> ncNameList,
                                          DiagnosticChain diagnostics,
                                          Map<Object,​Object> context)
      • validateNCNameList_ItemType

        public boolean validateNCNameList_ItemType​(List<?> ncNameList,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
        Validates the ItemType constraint of 'NC Name List'.
      • validateNullEnumeration

        public boolean validateNullEnumeration​(Object nullEnumeration,
                                               DiagnosticChain diagnostics,
                                               Map<Object,​Object> context)
      • validateNullEnumeration_MemberTypes

        public boolean validateNullEnumeration_MemberTypes​(Object nullEnumeration,
                                                           DiagnosticChain diagnostics,
                                                           Map<Object,​Object> context)
        Validates the MemberTypes constraint of 'Null Enumeration'.
      • validateNullEnumerationMember0Object

        public boolean validateNullEnumerationMember0Object​(NullEnumerationMember0 nullEnumerationMember0Object,
                                                            DiagnosticChain diagnostics,
                                                            Map<Object,​Object> context)
      • validateNullEnumerationMember1

        public boolean validateNullEnumerationMember1​(String nullEnumerationMember1,
                                                      DiagnosticChain diagnostics,
                                                      Map<Object,​Object> context)
      • validateNullEnumerationMember1_Pattern

        public boolean validateNullEnumerationMember1_Pattern​(String nullEnumerationMember1,
                                                              DiagnosticChain diagnostics,
                                                              Map<Object,​Object> context)
        Validates the Pattern constraint of 'Null Enumeration Member1'.
      • validateNullType

        public boolean validateNullType​(Object nullType,
                                        DiagnosticChain diagnostics,
                                        Map<Object,​Object> context)
      • validateNullType_MemberTypes

        public boolean validateNullType_MemberTypes​(Object nullType,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
        Validates the MemberTypes constraint of 'Null Type'.
      • validateQNameList

        public boolean validateQNameList​(List<?> qNameList,
                                         DiagnosticChain diagnostics,
                                         Map<Object,​Object> context)
      • validateQNameList_ItemType

        public boolean validateQNameList_ItemType​(List<?> qNameList,
                                                  DiagnosticChain diagnostics,
                                                  Map<Object,​Object> context)
        Validates the ItemType constraint of 'QName List'.
      • validateQueryGrammarEnumerationObject

        public boolean validateQueryGrammarEnumerationObject​(QueryGrammarEnumeration queryGrammarEnumerationObject,
                                                             DiagnosticChain diagnostics,
                                                             Map<Object,​Object> context)
      • validateRelativePositionTypeObject

        public boolean validateRelativePositionTypeObject​(RelativePositionType relativePositionTypeObject,
                                                          DiagnosticChain diagnostics,
                                                          Map<Object,​Object> context)
      • validateSequenceRuleNamesObject

        public boolean validateSequenceRuleNamesObject​(SequenceRuleNames sequenceRuleNamesObject,
                                                       DiagnosticChain diagnostics,
                                                       Map<Object,​Object> context)
      • validateSignTypeObject

        public boolean validateSignTypeObject​(SignType signTypeObject,
                                              DiagnosticChain diagnostics,
                                              Map<Object,​Object> context)
      • validateStringOrNull

        public boolean validateStringOrNull​(Object stringOrNull,
                                            DiagnosticChain diagnostics,
                                            Map<Object,​Object> context)
      • validateStringOrNull_MemberTypes

        public boolean validateStringOrNull_MemberTypes​(Object stringOrNull,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
        Validates the MemberTypes constraint of 'String Or Null'.
      • validateSuccessionTypeObject

        public boolean validateSuccessionTypeObject​(SuccessionType successionTypeObject,
                                                    DiagnosticChain diagnostics,
                                                    Map<Object,​Object> context)
      • validateSurfaceInterpolationTypeObject

        public boolean validateSurfaceInterpolationTypeObject​(SurfaceInterpolationType surfaceInterpolationTypeObject,
                                                              DiagnosticChain diagnostics,
                                                              Map<Object,​Object> context)
      • validateSymbolTypeEnumerationObject

        public boolean validateSymbolTypeEnumerationObject​(SymbolTypeEnumeration symbolTypeEnumerationObject,
                                                           DiagnosticChain diagnostics,
                                                           Map<Object,​Object> context)
      • validateTimeIndeterminateValueTypeObject

        public boolean validateTimeIndeterminateValueTypeObject​(TimeIndeterminateValueType timeIndeterminateValueTypeObject,
                                                                DiagnosticChain diagnostics,
                                                                Map<Object,​Object> context)
      • validateTimePositionUnion

        public boolean validateTimePositionUnion​(Object timePositionUnion,
                                                 DiagnosticChain diagnostics,
                                                 Map<Object,​Object> context)
      • validateTimePositionUnion_MemberTypes

        public boolean validateTimePositionUnion_MemberTypes​(Object timePositionUnion,
                                                             DiagnosticChain diagnostics,
                                                             Map<Object,​Object> context)
        Validates the MemberTypes constraint of 'Time Position Union'.
      • validateTimeUnitType

        public boolean validateTimeUnitType​(Object timeUnitType,
                                            DiagnosticChain diagnostics,
                                            Map<Object,​Object> context)
      • validateTimeUnitType_MemberTypes

        public boolean validateTimeUnitType_MemberTypes​(Object timeUnitType,
                                                        DiagnosticChain diagnostics,
                                                        Map<Object,​Object> context)
        Validates the MemberTypes constraint of 'Time Unit Type'.
      • validateTimeUnitTypeMember0Object

        public boolean validateTimeUnitTypeMember0Object​(TimeUnitTypeMember0 timeUnitTypeMember0Object,
                                                         DiagnosticChain diagnostics,
                                                         Map<Object,​Object> context)
      • validateTimeUnitTypeMember1

        public boolean validateTimeUnitTypeMember1​(String timeUnitTypeMember1,
                                                   DiagnosticChain diagnostics,
                                                   Map<Object,​Object> context)
      • validateTimeUnitTypeMember1_Pattern

        public boolean validateTimeUnitTypeMember1_Pattern​(String timeUnitTypeMember1,
                                                           DiagnosticChain diagnostics,
                                                           Map<Object,​Object> context)
        Validates the Pattern constraint of 'Time Unit Type Member1'.
      • getResourceLocator

        public ResourceLocator getResourceLocator()
        Returns the resource locator that will be used to fetch messages for this validator's diagnostics.
        Overrides:
        getResourceLocator in class EObjectValidator