@Override
public void visitConstSchema(ConstSchemaWrapper schema) {
    Schema orig = original;

    if (orig instanceof FalseSchema)
        return; // FalseSchema matches nothing

    // Const and single-enum equivalency
    if (orig instanceof EnumSchema) {
        Set<Object> possibleValues = ((EnumSchema) orig).getPossibleValues();
        if (possibleValues.size() == 1) {
            orig = ConstSchema.builder()
                .permittedValue(possibleValues.stream().findAny().get())
                .build();
        }
    }

    if (!(orig instanceof ConstSchema)) {
        ctx.addDifference(SUBSCHEMA_TYPE_CHANGED, orig, schema);
        return;
    }
    schema.accept(new ConstSchemaDiffVisitor(ctx, (ConstSchema) orig));
}
 

@Override
public void visitEnumSchema(EnumSchemaWrapper schema) {
    Schema orig = original;

    if (orig instanceof FalseSchema)
        return; // FalseSchema matches nothing

    // Const and single-enum equivalency
    if (orig instanceof ConstSchema) {
        Object permittedValue = ((ConstSchema) orig).getPermittedValue();
        orig = EnumSchema.builder()
            .possibleValue(permittedValue)
            .build();
    }

    if (!(orig instanceof EnumSchema)) {
        ctx.addDifference(SUBSCHEMA_TYPE_CHANGED, orig, schema);
        return;
    }
    schema.accept(new EnumSchemaDiffVisitor(ctx, (EnumSchema) orig));
}
 

public static SchemaWrapper wrap(Schema schema) {
    if (schema == null)
        return null;

    if (schema instanceof ObjectSchema) {
        return new ObjectSchemaWrapper((ObjectSchema) schema);
    } else if (schema instanceof ArraySchema) {
        return new ArraySchemaWrapper((ArraySchema) schema);
    } else if (schema instanceof StringSchema) {
        return new StringSchemaWrapper((StringSchema) schema);
    } else if (schema instanceof EmptySchema && !(schema instanceof TrueSchema)) {
        return new EmptySchemaWrapper((EmptySchema) schema);
    } else if (schema instanceof TrueSchema) {
        return new TrueSchemaWrapper((TrueSchema) schema);
    } else if (schema instanceof FalseSchema) {
        return new FalseSchemaWrapper((FalseSchema) schema);
    } else if (schema instanceof BooleanSchema) {
        return new BooleanSchemaWrapper((BooleanSchema) schema);
    } else if (schema instanceof ConstSchema) {
        return new ConstSchemaWrapper((ConstSchema) schema);
    } else if (schema instanceof EnumSchema) {
        return new EnumSchemaWrapper((EnumSchema) schema);
    } else if (schema instanceof NullSchema) {
        return new NullSchemaWrapper((NullSchema) schema);
    } else if (schema instanceof NotSchema) {
        return new NotSchemaWrapper((NotSchema) schema);
    } else if (schema instanceof ReferenceSchema) {
        return new ReferenceSchemaWrapper((ReferenceSchema) schema);
    } else if (schema instanceof CombinedSchema) {
        return new CombinedSchemaWrapper((CombinedSchema) schema);
    } else if (schema instanceof ConditionalSchema) {
        return new ConditionalSchemaWrapper((ConditionalSchema) schema);
    } else if (schema instanceof NumberSchema) {
        return new NumberSchemaWrapper((NumberSchema) schema);
    } else {
        throw new IllegalStateException("No wrapper for an underlying schema type '" + schema.getClass() + "': " + schema);
    }
}
 

@Override List<Schema.Builder<?>> extract() {
    if (!containsKey("enum")) {
        return emptyList();
    }
    EnumSchema.Builder builder = EnumSchema.builder();
    List<Object> possibleValues = new ArrayList<>();
    require("enum").requireArray().forEach((i, item) -> possibleValues.add(item.unwrap()));
    builder.possibleValues(possibleValues);
    return singletonList(builder);
}
 

@Test
public void enumSchema() {
    EnumSchema actual = (EnumSchema) SchemaLoader.load(get("enumSchema"));
    Map<String, Object> expectedObject = new HashMap<>();
    expectedObject.put("a", "b");
    assertEquals(new HashSet<>(asList(1, 2, "a", expectedObject, null)), new HashSet<>(actual.getPossibleValues()));
}
 

public EnumSchemaDiffVisitor(DiffContext ctx, EnumSchema original) {
    this.ctx = ctx;
    this.original = original;
}
 

public EnumSchemaWrapper(EnumSchema wrapped) {
    this.wrapped = wrapped;
}
 

static void recursiveCheck(
        final Schema originalIn,
        final Schema updateIn,
        final SchemaDiffState state) {

    if (originalIn == null && updateIn == null) {
        return;
    }

    if (updateIn == null) {
        state.addChange(SCHEMA_REMOVED);
        return;
    }

    if (originalIn == null) {
        state.addChange(SCHEMA_REMOVED);
        return;
    }

    final Schema original;
    final Schema update;
    if (!originalIn.getClass().equals(updateIn.getClass())) {
        // Tricky part. EmptySchema is the same as an empty ObjectSchema.
        if (originalIn instanceof EmptySchema && updateIn instanceof ObjectSchema) {
            original = replaceWithEmptyObjectSchema(originalIn);
            update = updateIn;
        } else if (typeNarrowed(originalIn, updateIn)) {
            state.addChange(TYPE_NARROWED);
            return;
        } else {
            state.addChange(TYPE_CHANGED);
            return;
        }
    } else {
        original = originalIn;
        update = updateIn;
    }

    state.analyzeSchema(originalIn, () -> {
        if (!Objects.equals(original.getId(), update.getId())) {
            state.addChange(ID_CHANGED);
        }

        if (!Objects.equals(original.getTitle(), update.getTitle())) {
            state.addChange(TITLE_CHANGED);
        }

        if (!Objects.equals(original.getDescription(), update.getDescription())) {
            state.addChange(DESCRIPTION_CHANGED);
        }

        if (original instanceof StringSchema) {
            StringSchemaDiff.recursiveCheck((StringSchema) original, (StringSchema) update, state);
        } else if (original instanceof NumberSchema) {
            NumberSchemaDiff.recursiveCheck((NumberSchema) original, (NumberSchema) update, state);
        } else if (original instanceof EnumSchema) {
            EnumSchemaDiff.recursiveCheck((EnumSchema) original, (EnumSchema) update, state);
        } else if (original instanceof CombinedSchema) {
            CombinedSchemaDiff.recursiveCheck((CombinedSchema) original, (CombinedSchema) update, state);
        } else if (original instanceof ObjectSchema) {
            ObjectSchemaDiff.recursiveCheck((ObjectSchema) original, (ObjectSchema) update, state);
        } else if (original instanceof ArraySchema) {
            ArraySchemaDiff.recursiveCheck((ArraySchema) original, (ArraySchema) update, state);
        } else if (original instanceof ReferenceSchema) {
            ReferenceSchemaDiff.recursiveCheck((ReferenceSchema) original, (ReferenceSchema) update, state);
        }
    });
}
 

static void recursiveCheck(
        final EnumSchema enumSchemaOriginal, final EnumSchema enumSchemaUpdate, final SchemaDiffState state) {
    if (!enumSchemaOriginal.getPossibleValues().equals(enumSchemaUpdate.getPossibleValues())) {
        state.addChange("enum", ENUM_ARRAY_CHANGED);
    }
}