com.mojang.datafixers.schemas.Schema Java Examples

public DataFixer build(final Executor executor) {
    final DataFixerUpper fixerUpper = new DataFixerUpper(new Int2ObjectAVLTreeMap<>(schemas), new ArrayList<>(globalList), new IntAVLTreeSet(fixerVersions));

    final IntBidirectionalIterator iterator = fixerUpper.fixerVersions().iterator();
    while (iterator.hasNext()) {
        final int versionKey = iterator.nextInt();
        final Schema schema = schemas.get(versionKey);
        for (final String typeName : schema.types()) {
            CompletableFuture.runAsync(() -> {
                final Type<?> dataType = schema.getType(() -> typeName);
                final TypeRewriteRule rule = fixerUpper.getRule(DataFixUtils.getVersion(versionKey), dataVersion);
                dataType.rewrite(rule, DataFixerUpper.OPTIMIZATION_RULE);
            }, executor).exceptionally(e -> {
                LOGGER.error("Unable to build datafixers", e);
                Runtime.getRuntime().exit(1);
                return null;
            });
        }
    }

    return fixerUpper;
}
 

/**
 * Fixes MC-170128: Cannot build an EntityType without a datafixer due to an IllegalArgumentException.
 */
@Redirect(method = "build", at = @At(value = "INVOKE", target = "Lcom/mojang/datafixers/schemas/Schema;getChoiceType(Lcom/mojang/datafixers/DSL$TypeReference;Ljava/lang/String;)Lcom/mojang/datafixers/types/Type;", remap = false))
public Type catchIllegalArgumentExceptionForDataFixers(Schema schema, DSL.TypeReference type, String choiceName) {
	try {
		return schema.getChoiceType(type, choiceName);
	} catch (IllegalArgumentException ex) {
		LOGGER.warn("No data fixer registered for entity {}", choiceName);
	}

	// This return result is ignored
	return null;
}
 

public Schema addSchema(final int version, final int subVersion, final BiFunction<Integer, Schema, Schema> factory) {
    final int key = DataFixUtils.makeKey(version, subVersion);
    final Schema parent = schemas.isEmpty() ? null : schemas.get(DataFixerUpper.getLowestSchemaSameVersion(schemas, key - 1));
    final Schema schema = factory.apply(DataFixUtils.makeKey(version, subVersion), parent);
    addSchema(schema);
    return schema;
}
 

protected static int getLowestSchemaSameVersion(final Int2ObjectSortedMap<Schema> schemas, final int versionKey) {
    if (versionKey < schemas.firstIntKey()) {
        // can't have a data type before anything else
        return schemas.firstIntKey();
    }
    return schemas.subMap(0, versionKey + 1).lastIntKey();
}
 

@Override
public Schema getSchema(int i) {
    return realFixer.getSchema(i);
}
 

@Override
public Schema getSchema(int i) {
    return realFixer.getSchema(i);
}
 

@Override
public Schema getSchema(int i) {
    return realFixer.getSchema(i);
}
 

@Override
public Schema getSchema(int i) {
    return realFixer.getSchema(i);
}
 

default TypeTemplate in(final Schema schema) {
    return schema.id(typeName());
}
 

@Override
public Schema getSchema(final int key) {
    return schemas.get(getLowestSchemaSameVersion(schemas, key));
}
 

protected DataFixerUpper(final Int2ObjectSortedMap<Schema> schemas, final List<DataFix> globalList, final IntSortedSet fixerVersions) {
    this.schemas = schemas;
    this.globalList = globalList;
    this.fixerVersions = fixerVersions;
}
 

public void addSchema(final Schema schema) {
    schemas.put(schema.getVersionKey(), schema);
}
 

public Schema addSchema(final int version, final BiFunction<Integer, Schema, Schema> factory) {
    return addSchema(version, 0, factory);
}
 

protected Schema getOutputSchema() {
    return outputSchema;
}
 

protected Schema getInputSchema() {
    if (changesType) {
        return outputSchema.getParent();
    }
    return getOutputSchema();
}
 

public DataFix(final Schema outputSchema, final boolean changesType) {
    this.outputSchema = outputSchema;
    this.changesType = changesType;
}
 

Schema getSchema(int key);