import org.spongepowered.api.data.manipulator.ImmutableDataManipulator; //导入依赖的package包/类
@Override
default List<ImmutableDataManipulator<?, ?>> getContainers() {
    final ImmutableList.Builder<ImmutableDataManipulator<?, ?>> builder = ImmutableList.builder();
    for (DataManipulatorRegistration registration : DataManipulatorRegistry.get().getAll()) {
        final ImmutableDataManipulator manipulator = (ImmutableDataManipulator) ImmutableContainerCache.get(
                this, registration, registration.getImmutableManipulatorClass()).orElse(null);
        if (manipulator != null) {
            builder.add(manipulator);
        }
    }

    if (this instanceof AdditionalContainerHolder) {
        final AdditionalContainerCollection<ImmutableDataManipulator<?, ?>> manipulators =
                ((AdditionalContainerHolder<ImmutableDataManipulator<?, ?>>) this).getAdditionalContainers();
        manipulators.getAll().forEach(builder::add);
    }

    return builder.build();
}
 

import org.spongepowered.api.data.manipulator.ImmutableDataManipulator; //导入依赖的package包/类
@Override
default <T extends DataManipulator<?,?>> Optional<T> get(Class<T> containerClass) {
    checkNotNull(containerClass, "containerClass");

    // Check default registrations
    final Optional<DataManipulatorRegistration> optRegistration = DataManipulatorRegistry.get().getBy(containerClass);
    if (optRegistration.isPresent()) {
        final DataManipulator manipulator = DataHelper.create(this, optRegistration.get());
        return manipulator == null ? Optional.empty() : Optional.of(
                (T) (ImmutableDataManipulator.class.isAssignableFrom(containerClass) ? manipulator.asImmutable() : manipulator));
    }

    // Try the additional containers if they are supported
    if (this instanceof AdditionalContainerHolder) {
        final AdditionalContainerCollection<DataManipulator<?,?>> containers =
                ((AdditionalContainerHolder<DataManipulator<?,?>>) this).getAdditionalContainers();
        return containers.get(containerClass);
    }

    return Optional.empty();
}
 

import org.spongepowered.api.data.manipulator.ImmutableDataManipulator; //导入依赖的package包/类
@Override
public BlockState merge(BlockState that) {
    if (!getType().equals(that.getType())) {
        return this;
    } else {
        BlockState temp = this;
        for (ImmutableDataManipulator<?, ?> manipulator : that.getManipulators()) {
            Optional<BlockState> optional = temp.with(manipulator);
            if (optional.isPresent()) {
                temp = optional.get();
            } else {
                return temp;
            }
        }
        return temp;
    }
}
 

import org.spongepowered.api.data.manipulator.ImmutableDataManipulator; //导入依赖的package包/类
@Override
public AdditionalContainerCollection<ImmutableDataManipulator<?, ?>> getAdditionalContainers() {
    if (this.additionalContainers == null) {
        this.additionalContainers = new MutableToImmutableManipulatorCollection(this.fluidStack.getAdditionalContainers());
    }
    return this.additionalContainers;
}
 

import org.spongepowered.api.data.manipulator.ImmutableDataManipulator; //导入依赖的package包/类
@Override
public Optional<FluidStackSnapshot> with(ImmutableDataManipulator<?, ?> valueContainer) {
    final LanternFluidStack copy = this.fluidStack.copy();
    if (copy.offerFast(valueContainer.asMutable())) {
        return Optional.of(new LanternFluidStackSnapshot(copy));
    }
    return Optional.empty();
}
 

import org.spongepowered.api.data.manipulator.ImmutableDataManipulator; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public Optional<FluidStackSnapshot> without(Class<? extends ImmutableDataManipulator<?, ?>> containerClass) {
    final LanternFluidStack copy = this.fluidStack.copy();
    final DataRegistration registration = Lantern.getGame().getDataManager().get(containerClass)
            .orElseThrow(() -> new IllegalStateException("The container class " + containerClass.getName() + " isn't registered."));
    if (copy.removeFast(registration.getManipulatorClass())) {
        return Optional.of(new LanternFluidStackSnapshot(copy));
    }
    return Optional.empty();
}
 

import org.spongepowered.api.data.manipulator.ImmutableDataManipulator; //导入依赖的package包/类
@Override
default boolean supports(Class<? extends ImmutableDataManipulator<?, ?>> containerClass) {
    // Offer all the default key values as long if they are supported
    // Support all the additional manipulators
    return DataManipulatorRegistry.get().getBy(containerClass)
            .map(registration -> DataHelper.supports(this, registration))
            .orElse(this instanceof AdditionalContainerHolder);
}
 

import org.spongepowered.api.data.manipulator.ImmutableDataManipulator; //导入依赖的package包/类
default boolean removeFastNoEvents(Key<?> key) {
    checkNotNull(key, "key");
    // Check the local key registration
    final KeyRegistration<?, ?> localKeyRegistration = (KeyRegistration<?, ?>) getValueCollection().get((Key) key).orElse(null);
    if (localKeyRegistration != null) {
        return ((Processor<BaseValue<?>, ?>) localKeyRegistration).removeFastFrom(this);
    }

    // Check for a global registration
    final Optional<ValueProcessorKeyRegistration> globalRegistration = LanternValueFactory.get().getKeyRegistration((Key) key);
    if (globalRegistration.isPresent()) {
        return ((Processor<BaseValue<?>, ?>) globalRegistration.get()).removeFastFrom(this);
    }

    // Check if custom data is supported by this container
    if (this instanceof AdditionalContainerHolder) {
        // Check for the custom value containers
        final AdditionalContainerCollection<H> containers = ((AdditionalContainerHolder<H>) this).getAdditionalContainers();
        for (H valueContainer : containers.getAll()) {
            if (valueContainer.supports(key)) {
                if (valueContainer instanceof ICompositeValueStore) {
                    return ((ICompositeValueStore) valueContainer).removeFastNoEvents(key);
                } else if (valueContainer instanceof CompositeValueStore) {
                    return ((CompositeValueStore) valueContainer).remove(key).isSuccessful();
                } else if (valueContainer instanceof DataManipulator ||
                        valueContainer instanceof ImmutableDataManipulator) {
                    return false;
                }
                return false;
            }
        }
    }

    return false;
}
 

import org.spongepowered.api.data.manipulator.ImmutableDataManipulator; //导入依赖的package包/类
@SuppressWarnings({"unchecked", "ConstantConditions"})
static <I extends ImmutableDataManipulator<I, M>, M extends DataManipulator<M, I>> Optional<I> get(
        IImmutableDataHolderBase<?> dataHolder, DataManipulatorRegistration<M, I> registration, Class<?> containerClass) {
    final DataManipulator manipulator = registration.createMutable();
    final ImmutableContainerCache cache = dataHolder.getContainerCache();
    if (cache != null && cache.manipulators == null) {
        cache.manipulators = new HashMap<>();
    }
    for (Key key : registration.getRequiredKeys()) {
        final Optional value = dataHolder.getValue(key);
        if (!value.isPresent()) {
            if (cache != null) {
                cache.manipulators.put(containerClass, ImmutableContainerCache.NONE);
            }
            return Optional.empty();
        }
        manipulator.set(key, value.get());
    }
    final I immutable = (I) manipulator.asImmutable();
    if (cache != null) {
        cache.manipulators.put(containerClass, immutable);
        // In case they are different, unlikely
        if (registration.getImmutableManipulatorClass() != containerClass) {
            cache.manipulators.put(registration.getImmutableManipulatorClass(), immutable);
        }
    }
    return Optional.of(immutable);
}
 

import org.spongepowered.api.data.manipulator.ImmutableDataManipulator; //导入依赖的package包/类
<M extends DataManipulator<M, I>, I extends ImmutableDataManipulator<I, M>> void validateRegistration(
        LanternDataRegistration<M, I> registration) {
    checkState(this.allowRegistrations, "Registrations are no longer allowed");
    final Class<M> manipulatorClass = registration.getManipulatorClass();
    final Class<I> immutableClass = registration.getImmutableManipulatorClass();
    final DataManipulatorBuilder<M, I> manipulatorBuilder = registration.getDataManipulatorBuilder();
    checkState(!this.builders.containsKey(manipulatorClass), "DataManipulator already registered!");
    checkState(!this.builderMap.containsKey(manipulatorClass), "DataManipulator already registered!");
    checkState(!this.builderMap.containsValue(manipulatorBuilder), "DataManipulatorBuilder already registered!");
    checkState(!this.builders.containsKey(immutableClass), "ImmutableDataManipulator already registered!");
    checkState(!this.immutableBuilderMap.containsKey(immutableClass), "ImmutableDataManipulator already registered!");
    checkState(!this.immutableBuilderMap.containsValue(manipulatorBuilder), "DataManipulatorBuilder already registered!");
    checkState(!DataManipulatorRegistryModule.get().getById(registration.getId()).isPresent(),
            "There is already a DataRegistration registered with the ID: " + registration.getId());
}
 

import org.spongepowered.api.data.manipulator.ImmutableDataManipulator; //导入依赖的package包/类
@SuppressWarnings("unchecked")
<M extends DataManipulator<M, I>, I extends ImmutableDataManipulator<I, M>> void register(LanternDataRegistration<M, I> registration) {
    checkNotNull(registration, "registration");
    if (registration instanceof DataManipulatorRegistration) {
        registerBuilder(registration.getImmutableManipulatorClass(),
                ((DataManipulatorRegistration) registration).getImmutableDataBuilder());
    }
    this.registrationsByPlugin.put(registration.getPluginContainer(), registration.getManipulatorClass());
    this.registrations.put(registration.getManipulatorClass(), registration);
    this.registrations.put(registration.getImmutableManipulatorClass(), registration);
    registerBuilder(registration.getManipulatorClass(), registration.getDataManipulatorBuilder());
    DataManipulatorRegistryModule.get().registerAdditionalCatalog(registration);
    Copyable.register(registration.getManipulatorClass(), DataManipulator::copy);
}
 

import org.spongepowered.api.data.manipulator.ImmutableDataManipulator; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public  <D extends DataManipulator<D, C>, C extends ImmutableDataManipulator<C, D>> LanternDataRegistrationBuilder<D, C> dataClass(Class<D> manipulatorClass) {
    this.manipulatorClass = (Class<M>) checkNotNull(manipulatorClass,
            "DataManipulator class cannot be null!");
    return (LanternDataRegistrationBuilder<D, C>) this;
}
 

import org.spongepowered.api.data.manipulator.ImmutableDataManipulator; //导入依赖的package包/类
@Override
public Map<Class<? extends ImmutableDataManipulator<?, ?>>, ? extends ImmutableDataManipulator<?, ?>> getMap() {
    this.collection.getAll().forEach(manipulator -> {
        final Class<? extends ImmutableDataManipulator<?, ?>> immutableClass = getImmutableClass(manipulator.getClass());
        this.cache.computeIfAbsent(immutableClass, c -> Optional.of(manipulator.asImmutable()));
    });
    return (Map) this.unmodifiableCache;
}
 

import org.spongepowered.api.data.manipulator.ImmutableDataManipulator; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public <M extends DataManipulator<M, I>, I extends ImmutableDataManipulator<I, M>> DataManipulatorRegistration<M, I> newRegistrationFor(
        PluginContainer pluginContainer, String id, String name,
        Class<M> manipulatorType, Class<I> immutableManipulatorType,
        @Nullable Class<? extends M> mutableExpansion, @Nullable Class<? extends I> immutableExpansion,
        @Nullable Consumer<ValueCollection> registrationConsumer) {
    Class<?>[] classes = mutableExpansion == null ?
            new Class[] { AbstractData.class, manipulatorType } :
            new Class[] { AbstractData.class, manipulatorType, mutableExpansion };
    final List<Method> mutableMethods = findValueMethods(classes);
    classes = mutableExpansion == null ?
            new Class[] { AbstractImmutableData.class, immutableManipulatorType } :
            new Class[] { AbstractImmutableData.class, immutableManipulatorType, immutableExpansion };
    final List<Method> immutableMethods = findValueMethods(classes);

    final Base<M, I> base = generateBase(this.abstractDataTypeGenerator, pluginContainer, id, name,
            manipulatorType, immutableManipulatorType, mutableExpansion, immutableExpansion, mutableMethods, immutableMethods);
    try {
        base.mutableManipulatorTypeImpl.getField(AbstractDataTypeGenerator.REGISTRATION_CONSUMER).set(null, registrationConsumer);
        base.immutableManipulatorTypeImpl.getField(AbstractDataTypeGenerator.REGISTRATION_CONSUMER).set(null, registrationConsumer);

        final DataManipulatorRegistration<M, I> registration = base.supplier.get();
        final Set<Key<?>> requiredKeys = registration.getRequiredKeys();

        base.mutableManipulatorTypeImpl.getField(TypeGenerator.KEYS).set(null, findKeyMatches(mutableMethods, requiredKeys));
        base.immutableManipulatorTypeImpl.getField(TypeGenerator.KEYS).set(null, findKeyMatches(immutableMethods, requiredKeys));

        return registration;
    } catch (IllegalAccessException | NoSuchFieldException e) {
        throw new RuntimeException(e);
    }
}
 

import org.spongepowered.api.data.manipulator.ImmutableDataManipulator; //导入依赖的package包/类
abstract <M extends DataManipulator<M, I>, I extends ImmutableDataManipulator<I, M>> void generateClasses(
ClassWriter cwM, ClassWriter cwI,
String mutableClassName, String immutableClassName,
Class<M> manipulatorType, Class<I> immutableManipulatorType,
@Nullable Class<? extends M> mutableExpansion,
@Nullable Class<? extends I> immutableExpansion,
@Nullable List<Method> mutableMethods,
@Nullable List<Method> immutableMethods);
 

import org.spongepowered.api.data.manipulator.ImmutableDataManipulator; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public <M extends DataManipulator<M, I>, I extends ImmutableDataManipulator<I, M>> DataManipulatorRegistration<M, I> register(
        Class<M> manipulatorType, Supplier<M> manipulatorSupplier, Function<M, M> manipulatorCopyFunction, Function<I, M> immutableToMutableFunction,
        Class<I> immutableManipulatorType, Supplier<I> immutableManipulatorSupplier, Function<M, I> mutableToImmutableFunction) {
    final RegistrationInfo registrationInfo = RegistrationInfo.build(manipulatorType);
    return register(registrationInfo.pluginContainer, registrationInfo.id, registrationInfo.name, manipulatorType, manipulatorSupplier,
            manipulatorCopyFunction, immutableToMutableFunction, immutableManipulatorType, immutableManipulatorSupplier,
            mutableToImmutableFunction);
}
 

import org.spongepowered.api.data.manipulator.ImmutableDataManipulator; //导入依赖的package包/类
@Override
public Optional<BlockState> with(ImmutableDataManipulator<?, ?> valueContainer) {
    Optional<BlockState> state = null;
    for (ImmutableValue<?> value : valueContainer.getValues()) {
        state = this.with(value);
        if (!state.isPresent()) {
            return state;
        }
    }
    return state == null ? Optional.of(this) : state;
}
 

import org.spongepowered.api.data.manipulator.ImmutableDataManipulator; //导入依赖的package包/类
@Override
public LanternBlockStateBuilder add(ImmutableDataManipulator<?, ?> manipulator) {
    final Optional<BlockState> optional = this.blockState.with(manipulator);
    if (optional.isPresent()) {
        this.blockState = optional.get();
    }
    return this;
}
 

import org.spongepowered.api.data.manipulator.ImmutableDataManipulator; //导入依赖的package包/类
@Override
public AdditionalContainerCollection<ImmutableDataManipulator<?,?>> getAdditionalContainers() {
    if (this.additionalContainers == null) {
        this.additionalContainers = new MutableToImmutableManipulatorCollection(this.itemStack.getAdditionalContainers());
    }
    return this.additionalContainers;
}
 

import org.spongepowered.api.data.manipulator.ImmutableDataManipulator; //导入依赖的package包/类
@Override
public Optional<ItemStackSnapshot> with(ImmutableDataManipulator<?, ?> valueContainer) {
    final LanternItemStack copy = this.itemStack.copy();
    if (copy.offerFast(valueContainer.asMutable())) {
        return Optional.of(new LanternItemStackSnapshot(copy));
    }
    return Optional.empty();
}