import org.spongepowered.api.data.value.mutable.Value; //导入依赖的package包/类
/**
 * Attempts to get a {@link ImmutableValue} for the given
 * {@link Key}. {@link Optional#empty()} will be returned
 * when it fails.
 *
 * @param key The key
 * @return The immutable value, if success
 */
default <E, R extends ImmutableValue<E>> Optional<R> getImmutableValueFor(Key<? extends BaseValue<E>> key) {
    checkNotNull(key, "key");
    final ImmutableContainerCache cache = getContainerCache();
    if (cache != null) {
        Object value = cache.values.get(key);
        if (value != null) {
            return value == ImmutableContainerCache.NONE ? Optional.empty() : Optional.of((R) value);
        }
    }
    Optional optValue = getRawValueFor((Key) key);
    if (optValue.isPresent() && !(optValue.get() instanceof ImmutableValue)) {
        optValue = Optional.of(((Value) optValue.get()).asImmutable());
    }
    if (cache != null) {
        cache.values.put(key, optValue.orElse(ImmutableContainerCache.NONE));
    }
    return Optional.empty();
}
 

import org.spongepowered.api.data.value.mutable.Value; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public <M extends VariantData<E, M, I>, I extends ImmutableVariantData<E, I, M>, E> DataManipulatorRegistration<M, I> newVariantRegistrationFor(
        PluginContainer pluginContainer, String id, String name, Class<M> manipulatorType, Class<I> immutableManipulatorType,
        Key<Value<E>> key, E defaultValue) {
    final Base<M, I> base = generateBase(this.abstractVariantDataTypeGenerator, pluginContainer, id, name,
            manipulatorType, immutableManipulatorType, null, null, null, null);
    try {
        base.mutableManipulatorTypeImpl.getField(AbstractVariantDataTypeGenerator.KEY).set(null, key);
        base.mutableManipulatorTypeImpl.getField(AbstractVariantDataTypeGenerator.VALUE).set(null, defaultValue);
        base.immutableManipulatorTypeImpl.getField(AbstractVariantDataTypeGenerator.KEY).set(null, key);
        base.immutableManipulatorTypeImpl.getField(AbstractVariantDataTypeGenerator.VALUE).set(null, defaultValue);
    } catch (IllegalAccessException | NoSuchFieldException e) {
        throw new RuntimeException(e);
    }
    return base.supplier.get();
}
 

import org.spongepowered.api.data.value.mutable.Value; //导入依赖的package包/类
LanternBlockState(LanternBlockStateMap baseState, ImmutableMap<BlockTrait<?>, Comparable<?>> traitValues) {
    this.traitValues = traitValues;
    this.baseState = baseState;

    ImmutableBiMap.Builder<Key<Value<?>>, BlockTrait<?>> builder = ImmutableBiMap.builder();
    for (BlockTrait trait : traitValues.keySet()) {
        builder.put(((LanternBlockTrait) trait).getKey(), trait);
    }
    this.keyToBlockTrait = builder.build();

    final StringBuilder idBuilder = new StringBuilder();
    idBuilder.append(baseState.getBlockType().getId().substring(baseState.getBlockType().getPluginId().length() + 1));
    if (!traitValues.isEmpty()) {
        idBuilder.append('[');
        final Joiner joiner = Joiner.on(',');
        final List<String> propertyValues = new ArrayList<>();
        for (Map.Entry<BlockTrait<?>, Comparable<?>> entry : traitValues.entrySet()) {
            propertyValues.add(entry.getKey().getName() + "=" + entry.getValue().toString().toLowerCase(Locale.ENGLISH));
        }
        idBuilder.append(joiner.join(propertyValues));
        idBuilder.append(']');
    }
    this.name = idBuilder.toString();
    this.id = baseState.getBlockType().getPluginId() + ':' + this.name;
}
 

import org.spongepowered.api.data.value.mutable.Value; //导入依赖的package包/类
@Override
public CommandElement[] getArguments() {
    HashMap<String, Key<Value<Boolean>>> choices = new HashMap<>();
    choices.put("attribute", Keys.HIDE_ATTRIBUTES);
    choices.put("attributes", Keys.HIDE_ATTRIBUTES);
    choices.put("candestroy", Keys.HIDE_CAN_DESTROY);
    choices.put("canbreak", Keys.HIDE_CAN_DESTROY);
    choices.put("canplace", Keys.HIDE_CAN_PLACE);
    choices.put("canplaceon", Keys.HIDE_CAN_PLACE);
    choices.put("ench", Keys.HIDE_ENCHANTMENTS);
    choices.put("enchantment", Keys.HIDE_ENCHANTMENTS);
    choices.put("enchantments", Keys.HIDE_ENCHANTMENTS);
    choices.put("misc", Keys.HIDE_MISCELLANEOUS);
    choices.put("miscellaneous", Keys.HIDE_MISCELLANEOUS);
    choices.put("unbreakable", Keys.HIDE_UNBREAKABLE);

    return new CommandElement[]{
            Arguments.builder(new ChoicesArgument(Text.of("tag"), choices)).onlyOne().usage("attributes/candestroy/canplaceon/enchantments/miscellaneous/unbreakable").build(),
            Arguments.builder(new BooleanArgument(Text.of("enabled"))).usageKey("Enable/Disable").onlyOne().build()
    };
}
 

import org.spongepowered.api.data.value.mutable.Value; //导入依赖的package包/类
@Override
public CommandResult execute(CommandSource sender, CommandContext args) throws CommandException {
    checkIfPlayer(sender);
    checkPermission(sender, ItemPermissions.UC_ITEM_ITEMHIDETAGS_BASE);
    Player p = (Player) sender;

    if (!p.getItemInHand(HandTypes.MAIN_HAND).isPresent() || p.getItemInHand(HandTypes.MAIN_HAND).get().getItem().equals(ItemTypes.NONE)) {
        throw new ErrorMessageException(Messages.getFormatted(p, "item.noiteminhand"));
    }
    ItemStack stack = p.getItemInHand(HandTypes.MAIN_HAND).get();

    Key<Value<Boolean>> key = args.<Key<Value<Boolean>>>getOne("tag").get();
    boolean value = args.<Boolean>getOne("enabled").get();

    stack.offer(key, value);
    p.setItemInHand(HandTypes.MAIN_HAND, stack);
    Messages.send(sender, "item.command.itemhidetags.success", "%tag%", key.getName(), "%status%", Messages.getFormatted(value ? "item.command.itemhidetags.hidden" : "item.command.itemhidetags.shown"));
    return CommandResult.success();
}
 

import org.spongepowered.api.data.value.mutable.Value; //导入依赖的package包/类
private boolean toggle(Player player, Key<Value<Boolean>> key, String settingName)
{
    Optional<PlayerMountDataMutable> optional = player.get(PlayerMountDataMutable.class);
    if (optional.isPresent())
    {
        PlayerMountDataMutable data = optional.get();
        Boolean value = !data.get(key).get();
        player.offer(data.set(key, value));
        messenger().info("Toggled ").stress(settingName).info(" " + (value ? "on" : "off")).tell(player);
        return true;
    }
    messenger().error("You must first create a mount before your can change its properties!").tell(player);
    return false;
}
 

import org.spongepowered.api.data.value.mutable.Value; //导入依赖的package包/类
private <T> boolean set(Player player, Key<Value<T>> key, T value)
{
    Optional<PlayerMountDataMutable> optional = player.get(PlayerMountDataMutable.class);
    if (optional.isPresent())
    {
        PlayerMountDataMutable data = optional.get();
        data.set(key, value);
        player.offer(data);
        return true;
    }
    messenger().error("You must first create a mount before your can change its properties!").tell(player);
    return false;
}
 

import org.spongepowered.api.data.value.mutable.Value; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public static <E> Key<? extends BaseValue<E>> unwrap(Key<? extends BaseValue<Optional<E>>> key) {
    return (Key<Value<E>>) nonOptionalKey.computeIfAbsent(key, key1 -> {
        final TypeToken newElementType = key1.getElementToken().resolveType(optionalType);
        return makeValueKey(newElementType, DataQuery.of('.', key1.getQuery().asString('.') + "Required"),
                key1.getId() + "_required", key1.getName() + "Required");
    });
}
 

import org.spongepowered.api.data.value.mutable.Value; //导入依赖的package包/类
@Override
public Value<T> transform(Function<T, T> function) {
    final T entity = checkNotNull(checkNotNull(function).apply(this.weakReference.get()));
    this.weakReference = new WeakReference<>(entity);
    this.entityId = checkNotNull(entity).getUniqueId();
    return this;
}
 

import org.spongepowered.api.data.value.mutable.Value; //导入依赖的package包/类
public <M extends VariantData<E, M, I>, I extends ImmutableVariantData<E, I, M>, E> DataManipulatorRegistration<M, I> registerVariant(
        PluginContainer pluginContainer, String id, String name, Class<M> manipulatorType, Class<I> immutableManipulatorType,
        Key<Value<E>> key, E defaultValue) {
    final DataManipulatorRegistration<M, I> registration = this.dataManipulatorGenerator.newVariantRegistrationFor(
            pluginContainer, id, name, manipulatorType, immutableManipulatorType, key, defaultValue);
    return register(registration);
}
 

import org.spongepowered.api.data.value.mutable.Value; //导入依赖的package包/类
/**
 * Creates a new integer trait with the specified name and the possible values.
 * 
 * <p>The possible values array may not be empty.</p>
 * 
 * @param name the name
 * @param key the key that should be attached to the trait
 * @param possibleValues the possible values
 * @return the integer trait
 */
public static IntegerTrait of(String name, Key<? extends Value<Integer>> key, int... possibleValues) {
    checkNotNullOrEmpty(name, "name");
    checkNotNull(possibleValues, "possibleValues");
    checkNotNull(key, "key");
    checkState(possibleValues.length != 0, "possibleValues may not be empty");
    ImmutableSet.Builder<Integer> builder = ImmutableSet.builder();
    for (int possibleValue : possibleValues) {
        builder.add(possibleValue);
    }
    return new LanternIntegerTrait(name, key, builder.build());
}
 

import org.spongepowered.api.data.value.mutable.Value; //导入依赖的package包/类
public static void main(String... args) {
    test(new TypeToken<Key<?>>() {},
            new TypeToken<Key<BaseValue<?>>>() {});
    test(new TypeToken<Key<BaseValue<?>>>() {},
            new TypeToken<Key<BaseValue<?>>>() {});
    test(new TypeToken<Key<BaseValue<?>>>() {},
            new TypeToken<Key<BaseValue<CatalogType>>>() {});
    test(new TypeToken<Key<BaseValue<?>>>() {},
            new TypeToken<Key<BaseValue<? extends CatalogType>>>() {});
    test(new TypeToken<Key<BaseValue<?>>>() {},
            new TypeToken<Key<BaseValue<? extends Advancement>>>() {});
    test(new TypeToken<Key<BaseValue<Advancement>>>() {},
            new TypeToken<Key<BaseValue<Integer>>>() {});
    test(new TypeToken<Key<BaseValue<Slime>>>() {},
            new TypeToken<Key<BaseValue<? extends EnderDragon>>>() {});
    test(new TypeToken<Key<BaseValue<EnderDragon>>>() {},
            new TypeToken<Key<BaseValue<? extends Living>>>() {});
    test(new TypeToken<Key<BaseValue<EnderDragon>>>() {},
            new TypeToken<Key<BaseValue<? extends Living>>>() {});
    test(TypeToken.of(Key.class),
            new TypeToken<Key<BaseValue<? extends Living>>>() {});

    test(new TypeToken<DataRegistration>() {},
            new TypeToken<DataRegistration<?,?>>() {});
    test(new TypeToken<DataRegistration>() {},
            new TypeToken<DataRegistration<LoreData,?>>() {});
    test(new TypeToken<DataRegistration<?,?>>() {},
            new TypeToken<DataRegistration<LoreData,?>>() {});

    // Enclosing classes testing
    test(new TypeToken<A<Object>.B<Value<Double>>>() {},
            new TypeToken<A<Object>.B<Value<? extends Number>>>() {});
    test(new TypeToken<A<Key<BaseValue<EnderDragon>>>.B<Value<Double>>>() {},
            new TypeToken<A<Key<BaseValue<Slime>>>.B<Value<? extends Number>>>() {});
    test(new TypeToken<A<Key<BaseValue<EnderDragon>>>.B<Value<Double>>>() {},
            new TypeToken<A<Key<BaseValue<? extends Living>>>.B<Value<? extends Number>>>() {});
}
 

import org.spongepowered.api.data.value.mutable.Value; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public static boolean isSameVariant(ItemStack itemStack1, ItemStack itemStack2) {
    if (itemStack1.getType() != itemStack2.getType()) {
        return false;
    }

    List<Key<? extends Value<? extends CatalogType>>> keys = Arrays.asList(Keys.BRICK_TYPE, Keys.COAL_TYPE, Keys.COOKED_FISH, Keys.DIRT_TYPE, Keys.DISGUISED_BLOCK_TYPE, Keys.DOUBLE_PLANT_TYPE, Keys.DYE_COLOR, Keys.FISH_TYPE, Keys.GOLDEN_APPLE_TYPE, Keys.PRISMARINE_TYPE, Keys.QUARTZ_TYPE, Keys.SAND_TYPE, Keys.SANDSTONE_TYPE, Keys.SHRUB_TYPE, Keys.STONE_TYPE, Keys.TREE_TYPE, Keys.WALL_TYPE);
    return !keys.stream().map(key -> (Key<Value<CatalogType>>) key).filter(key -> itemStack1.supports(key) && itemStack2.supports(key)).filter(key -> {
        Optional<? extends CatalogType> type1 = itemStack1.get(key);
        Optional<? extends CatalogType> type2 = itemStack2.get(key);
        return type1.isPresent() && type2.isPresent() && type1.get().getId().equals(type2.get().getId());

    }).collect(Collectors.toSet()).isEmpty();
}
 

import org.spongepowered.api.data.value.mutable.Value; //导入依赖的package包/类
public Value<String> world() {
    return Sponge.getRegistry().getValueFactory().createValue(VigilateKeys.OLD_LOCATION_WORLD, this.world);
}
 

import org.spongepowered.api.data.value.mutable.Value; //导入依赖的package包/类
public Value<Double> locX() {
    return Sponge.getRegistry().getValueFactory().createValue(VigilateKeys.OLD_LOCATION_X, this.locX);
}
 

import org.spongepowered.api.data.value.mutable.Value; //导入依赖的package包/类
public Value<Double> locY() {
    return Sponge.getRegistry().getValueFactory().createValue(VigilateKeys.OLD_LOCATION_Y, this.locY);
}
 

import org.spongepowered.api.data.value.mutable.Value; //导入依赖的package包/类
public Value<Double> locZ() {
    return Sponge.getRegistry().getValueFactory().createValue(VigilateKeys.OLD_LOCATION_Z, this.locZ);
}
 

import org.spongepowered.api.data.value.mutable.Value; //导入依赖的package包/类
public Value<String> camera() {
    return Sponge.getRegistry().getValueFactory().createValue(VigilateKeys.CAMERA, this.camera);
}
 

import org.spongepowered.api.data.value.mutable.Value; //导入依赖的package包/类
public Value<GameMode> gameMode() {
    return Sponge.getRegistry().getValueFactory().createValue(VigilateKeys.OLD_GAME_MODE, this.gameMode);
}
 

import org.spongepowered.api.data.value.mutable.Value; //导入依赖的package包/类
public Value<Boolean> isFlying() {
    return Sponge.getRegistry().getValueFactory().createValue(VigilateKeys.OLD_IS_FLYING, this.isFlying);
}