import ninja.leaping.configurate.objectmapping.serialize.TypeSerializerCollection; //导入依赖的package包/类
private TestConfigurationLoader getSetTestLoader() {
    TestConfigurationLoader.Builder tclb = TestConfigurationLoader.builder();
    TypeSerializerCollection tsc = tclb.getDefaultOptions().getSerializers();
    tsc.registerPredicate(
            typeToken -> Set.class.isAssignableFrom(typeToken.getRawType()),
            new SetTypeSerialiser()
    );

    tclb.setDefaultOptions(tclb.getDefaultOptions().setSerializers(tsc));
    return tclb.build();
}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializerCollection; //导入依赖的package包/类
private TestConfigurationLoader getArrayTestLoader() {
    TestConfigurationLoader.Builder tclb = TestConfigurationLoader.builder();
    TypeSerializerCollection tsc = tclb.getDefaultOptions().getSerializers();
    tsc.registerType(new TypeToken<byte[]>() {}, new ByteArrayTypeSerialiser());
    tsc.registerType(new TypeToken<short[]>() {}, new ShortArrayTypeSerialiser());
    tsc.registerType(new TypeToken<int[]>() {}, new IntArrayTypeSerialiser());

    tclb.setDefaultOptions(tclb.getDefaultOptions().setSerializers(tsc)
        .setAcceptedTypes(Sets.newHashSet(Byte.class, Integer.class, Short.class)));
    return tclb.build();
}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializerCollection; //导入依赖的package包/类
private ConfigurationOptions initConfigurationOptions() {
    ConfigurationOptions defaults = ConfigurationOptions.defaults();
    TypeSerializerCollection serializers = defaults.getSerializers().newChild();

    serializers.registerType(TypeToken.of(SkinRecord.class), new SkinRecordSerializer());

    return defaults.setShouldCopyDefaults(true)
            .setSerializers(serializers);
}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializerCollection; //导入依赖的package包/类
public static void init(File rootDir) throws IOException
{
	carrotshopsFile = new File(rootDir, "shops.json");
	rootDir.mkdirs();
	carrotshopsFile.createNewFile();

	TypeSerializerCollection serializers = TypeSerializers.getDefaultSerializers().newChild();
	serializers.registerType(TypeToken.of(Inventory.class), new InventorySerializer());
	serializers.registerType(TypeToken.of(Currency.class), new CurrencySerializer());
	ConfigurationOptions options = ConfigurationOptions.defaults().setSerializers(serializers);

	loader = HoconConfigurationLoader.builder().setFile(carrotshopsFile).build();
	shopsNode = loader.load(options);
}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializerCollection; //导入依赖的package包/类
@Override
public ConfigurationOptions apply(ConfigurationOptions configurationOptions) {
    if (!set) {
        return configurationOptions;
    }

    TypeSerializerCollection tsc = configurationOptions.getSerializers();
    tsc.registerType(TypeToken.of(Dummy.class), new DummySerialiser());
    configurationOptions.setSerializers(tsc);
    return configurationOptions;
}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializerCollection; //导入依赖的package包/类
@Override
public <T extends FilteredTriggerConfiguration> Trigger.Builder<T> typeSerializableConfig(Class<T> configClass,
        TypeSerializerCollection typeSerializerCollection) {
    checkNotNull(configClass, "configClass");
    checkNotNull(typeSerializerCollection, "typeSerializerCollection");
    this.configType = (Class<C>) configClass;
    this.constructor = new ConfigurateConstructor(configClass, typeSerializerCollection);
    return (Trigger.Builder<T>) this;
}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializerCollection; //导入依赖的package包/类
private ConfigurationOptions(MapFactory mapSupplier, String header,
                             TypeSerializerCollection serializers, Set<Class<?>> acceptedTypes, ObjectMapperFactory objectMapperFactory, boolean shouldCopyDefaults) {
    this.mapSupplier = mapSupplier;
    this.header = header;
    this.serializers = serializers;
    this.acceptedTypes = acceptedTypes == null ? null : ImmutableSet.copyOf(acceptedTypes);
    this.objectMapperFactory = objectMapperFactory;
    this.shouldCopyDefaults = shouldCopyDefaults;
}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializerCollection; //导入依赖的package包/类
private static void setup() {

        // cache main thread in this class
        getMainThread();

        // register configurate serializers

        TypeSerializerCollection defs = TypeSerializers.getDefaultSerializers();

        defs.registerType(TypeToken.of(JsonArray.class), JsonArraySerializer.INSTANCE);
        defs.registerType(TypeToken.of(JsonObject.class), JsonObjectSerializer.INSTANCE);
        defs.registerType(TypeToken.of(JsonPrimitive.class), JsonPrimitiveSerializer.INSTANCE);
        defs.registerType(TypeToken.of(JsonNull.class), JsonNullSerializer.INSTANCE);

        defs.registerType(TypeToken.of(GsonSerializable.class), GsonSerializableConfigurateProxy.INSTANCE);

    }
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializerCollection; //导入依赖的package包/类
private ConfigurateConstructor(Class<C> typeToken, TypeSerializerCollection typeSerializerCollection) {
    this.typeToken = TypeToken.of(typeToken);
    this.typeSerializerCollection = typeSerializerCollection;
}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializerCollection; //导入依赖的package包/类
public TypeSerializerCollection getSerializers() {
    return this.serializers;
}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializerCollection; //导入依赖的package包/类
/**
 * Set the collection of TypeSerializers to be used for lookups
 *
 * @param serializers The serializers to use
 * @return updated options object
 */
public ConfigurationOptions setSerializers(TypeSerializerCollection serializers) {
    return new ConfigurationOptions(mapSupplier, header, serializers, acceptedTypes, objectMapperFactory, shouldCopyDefaults);
}