Package org.everit.json.schema

Class CombinedSchema

java.lang.Object
org.everit.json.schema.Schema
org.everit.json.schema.CombinedSchema
public class CombinedSchema extends Schema
Validator for allOf, oneOf, anyOf schemas.

  • Field Details

  • Constructor Details

    • CombinedSchema

      public CombinedSchema(CombinedSchema.Builder builder)
      Constructor.
      Parameters:
      builder - the builder containing the validation criterion and the subschemas to be checked

  • Method Details

    • allOf

      public static CombinedSchema.Builder allOf(Collection<Schema> schemas)

    • anyOf

      public static CombinedSchema.Builder anyOf(Collection<Schema> schemas)

    • builder

      public static CombinedSchema.Builder builder()

    • builder

      public static CombinedSchema.Builder builder(Collection<Schema> subschemas)

    • oneOf

      public static CombinedSchema.Builder oneOf(Collection<Schema> schemas)

    • getCriterion

      public CombinedSchema.ValidationCriterion getCriterion()

    • getSubschemas

      public Collection<Schema> getSubschemas()

    • definesProperty

      public boolean definesProperty(String field)
      Description copied from class: Schema
      Determines if this Schema instance defines any restrictions for the object property denoted by field. The field should be a JSON pointer, denoting the property to be queried.

      For example the field "#/rectangle/a" is defined by the following schema: 

       
 objectWithSchemaRectangleDep" : {
   "type" : "object",
   "dependencies" : {
       "d" : {
           "type" : "object",
           "properties" : {
               "rectangle" : {
                  "$ref" : "#/definitions/Rectangle"
               },
               "list": {
                   "type": "array",
                   "items": {
                       "properties": {
                          "prop": {}
                       }
                   },
                   "minItems": 2,
                   "maxItems: 3
               }
           }
       }
   },
   "definitions" : {
       "size" : {
           "type" : "number",
           "minimum" : 0
       },
       "Rectangle" : {
           "type" : "object",
           "properties" : {
               "a" : {"$ref" : "#/definitions/size"},
               "b" : {"$ref" : "#/definitions/size"}
           }
       }
    }
 }
      You can also check if a subschema of an array defines a property. In that case, to traverse the array, you can either use an integer array index, or the "all" or "any" meta-indexes. For example, in the above schema
      • definesProperty("#/list/any/prop") returns true
      • definesProperty("#/list/all/prop") returns true
      • definesProperty("#/list/1/prop") returns true
      • definesProperty("#/list/1/nonexistent") returns false (the property is not present in the subschema)
      • definesProperty("#/list/8/prop") returns false (the "list" does not define property 8, since "maxItems" is 3)
      The default implementation of this method always returns false.
      Overrides:
      definesProperty in class Schema
      Parameters:
      field - should be a JSON pointer in its string representation.
      Returns:
      true if the propertty denoted by field is defined by this schema instance

    • equals

      public boolean equals(Object o)
      Overrides:
      equals in class Schema

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Schema

    • canEqual

      protected boolean canEqual(Object other)
      Description copied from class: Schema
      Since we add state in subclasses, but want those subclasses to be non final, this allows us to have equals methods that satisfy the equals contract.

      http://www.artima.com/lejava/articles/equality.html

      Overrides:
      canEqual in class Schema
      Parameters:
      other - the subject of comparison
      Returns:
      true if this can be equal to other