import org.spongepowered.api.data.DataTransactionResult; //导入依赖的package包/类
@Override
public final void setModel(String model) {
    if(!getDefinition().getModels().contains(model))
        throw new IllegalArgumentException("This custom tool has no model called '" + model
                + "'. Available, defined models: "
                + getDefinition().getModels().stream().collect(Collectors.joining(", ")));

    applyModel(model);

    DataTransactionResult result = getDataHolder().offer(CustomItemLibraryKeys.CUSTOM_FEATURE_MODEL, model);

    if(!result.isSuccessful())
        throw new IllegalStateException("Could not update the item model; rejected: " + result.getRejectedData()
                + "; replaced: " + result.getReplacedData());
}
 

import org.spongepowered.api.data.DataTransactionResult; //导入依赖的package包/类
@Override
public boolean awardPlayer(Player player) {
    final Optional<Integer> expAmountOpt = Util.safeGetInt(this.data, "amount");
    if (!expAmountOpt.isPresent()) {
        this.plugin.getLogger().error("No experience amount specified. Aborting.");
        return false;
    }

    int existingExperience = player.get(Keys.TOTAL_EXPERIENCE).get();

    DataTransactionResult result = player.offer(Keys.TOTAL_EXPERIENCE, existingExperience + expAmountOpt.get());
    return result.isSuccessful();
}
 

import org.spongepowered.api.data.DataTransactionResult; //导入依赖的package包/类
@Override
public boolean awardPlayer(Player player) {
    final Optional<String> potionEffectTypeIDOpt = Util.safeGetString(this.data, "potionEffectType");
    if (!potionEffectTypeIDOpt.isPresent()) {
        this.plugin.getLogger().error("No potion effect type specified. Aborting.");
        return false;
    }

    String potionEffectTypeID = potionEffectTypeIDOpt.get();

    final Optional<PotionEffectType> optType = Sponge.getRegistry().getType(PotionEffectType.class,
            potionEffectTypeID);
    if (!optType.isPresent()) {
        this.plugin.getLogger().error("Potion effect type " + potionEffectTypeID + " not found. Aborting.");
        return false;
    }

    PotionEffect.Builder builder = Sponge.getRegistry().createBuilder(PotionEffect.Builder.class)
            .potionType(optType.get());

    Optional<Integer> durationOpt = Util.safeGetInt(this.data, "duration");
    if (!durationOpt.isPresent()) {
        this.plugin.getLogger().error("Potion effect duration not specified. Aborting.");
        return false;
    }
    builder.duration(durationOpt.get());

    builder.amplifier(Util.safeGetInt(this.data, "amplifier").orElse(1));

    List<PotionEffect> currentEffects = player.get(Keys.POTION_EFFECTS).orElse(new ArrayList<>());
    currentEffects.add(builder.build());

    DataTransactionResult result = player.offer(Keys.POTION_EFFECTS, currentEffects);
    return result.isSuccessful();
}
 

import org.spongepowered.api.data.DataTransactionResult; //导入依赖的package包/类
@Override
public void registerKeys() {
    super.registerKeys();
    final ValueCollection c = getValueCollection();
    c.register(Keys.DISPLAY_NAME, null);
    c.registerProcessor(LanternKeys.INVENTORY_SNAPSHOT).add(builder -> builder
            .offerHandler(((key, valueContainer, inventorySnapshot) -> {
                this.inventory.clear();
                inventorySnapshot.offerTo(this.inventory);
                return DataTransactionResult.successNoData();
            }))
            .failAlwaysRemoveHandler()
            .retrieveHandler((key, valueContainer) -> Optional.of(InventorySnapshot.ofInventory(this.inventory))));
}
 

import org.spongepowered.api.data.DataTransactionResult; //导入依赖的package包/类
public CommandResult execute(CommandSource src, CommandContext ctx) throws CommandException
{
	int number = ctx.<Integer> getOne("number").get();

	if (src instanceof Player)
	{
		Player player = (Player) src;

		if (player.getItemInHand(HandTypes.MAIN_HAND).isPresent())
		{
			ItemStack stack = player.getItemInHand(HandTypes.MAIN_HAND).get();
			LoreData loreData = stack.getOrCreate(LoreData.class).get();
			List<Text> newLore = loreData.lore().get();
			newLore.remove(number - 1);
			DataTransactionResult dataTransactionResult = stack.offer(Keys.ITEM_LORE, newLore);

			if (dataTransactionResult.isSuccessful())
			{
				player.setItemInHand(HandTypes.MAIN_HAND, stack);
				src.sendMessage(Text.of(TextColors.GREEN, "Success! ", TextColors.YELLOW, "Removed lore from item."));
			}
			else
			{
				src.sendMessage(Text.of(TextColors.DARK_RED, "Error! ", TextColors.RED, "Could not remove lore from item."));
			}
		}
		else
		{
			src.sendMessage(Text.of(TextColors.DARK_RED, "Error! ", TextColors.RED, "You must be holding an item!"));
		}
	}
	else
	{
		src.sendMessage(Text.of(TextColors.DARK_RED, "Error! ", TextColors.RED, "You must be a player to name items."));
	}
	return CommandResult.success();
}
 

import org.spongepowered.api.data.DataTransactionResult; //导入依赖的package包/类
default DataTransactionResult copyFromNoEvents(DataHolder that, MergeFunction function) {
    final Collection<DataManipulator<?, ?>> containers = that.getContainers();
    final DataTransactionResult.Builder builder = DataTransactionResult.builder();
    boolean success = false;
    for (DataManipulator<?, ?> thatContainer : containers) {
        final DataManipulator<?, ?> thisContainer = get(thatContainer.getClass()).orElse(null);
        final DataManipulator<?, ?> merged = function.merge(thisContainer, thatContainer);
        final DataTransactionResult result = offerNoEvents(merged, MergeFunction.IGNORE_ALL);
        builder.absorbResult(result);
        if (!result.getSuccessfulData().isEmpty()) {
            success = true;
        }
    }
    return builder.result(success ? DataTransactionResult.Type.SUCCESS : DataTransactionResult.Type.FAILURE).build();
}
 

import org.spongepowered.api.data.DataTransactionResult; //导入依赖的package包/类
public CommandResult execute(CommandSource src, CommandContext ctx) throws CommandException
{
	String name = ctx.<String> getOne("name").get();

	if (src instanceof Player)
	{
		Player player = (Player) src;

		if (player.getItemInHand(HandTypes.MAIN_HAND).isPresent())
		{
			ItemStack stack = player.getItemInHand(HandTypes.MAIN_HAND).get();
			Text textName = TextSerializers.FORMATTING_CODE.deserialize(name);
			DataTransactionResult dataTransactionResult = stack.offer(Keys.DISPLAY_NAME, textName);
			
			if(dataTransactionResult.isSuccessful())
			{
				player.setItemInHand(HandTypes.MAIN_HAND, stack);
				src.sendMessage(Text.of(TextColors.GREEN, "Success! ", TextColors.YELLOW, "Set name on item."));
			}
			else
			{
				src.sendMessage(Text.of(TextColors.DARK_RED, "Error! ", TextColors.RED, "Could not set name on item."));
			}
		}
		else
		{
			src.sendMessage(Text.of(TextColors.DARK_RED, "Error! ", TextColors.RED, "You must be holding an item!"));
		}
	}
	else
	{
		src.sendMessage(Text.of(TextColors.DARK_RED, "Error! ", TextColors.RED, "You must be a player to name items."));
	}

	return CommandResult.success();
}
 

import org.spongepowered.api.data.DataTransactionResult; //导入依赖的package包/类
@Listener
public void signChange(ChangeSignEvent event) throws Exception {
    ListValue<Text> lines = event.getText().lines();

    // Check that the first line is [warp]
    if (lines.get(0).toPlain().equalsIgnoreCase(Constants.WARP_SIGN_PREFIX)) {
        // Second line has to be the name of the warp
        String warpName = lines.get(1).toPlain();
        Optional<Warp> optWarp = this.plugin.getWarpManager().getOne(warpName);
        if (!optWarp.isPresent()) {
            return;
        }
        event.getText().set(Util.generateWarpSignData(optWarp.get()).getValues());

        WarpDataManipulatorBuilder builder = (WarpDataManipulatorBuilder) Sponge.getDataManager().getManipulatorBuilder(WarpData.class).get();
        WarpData data = builder.createFrom(optWarp.get());
        DataTransactionResult result = event.getTargetTile().offer(data);

        if (!result.isSuccessful()) {
            // Couldn't offer WarpData to the sign - log in the console and
            // warn the possible player that placed the sign
            String error =
                    "Failed to offer WarpData " + data.toContainer().toString() + " to the Sign at "
                            + event.getTargetTile().getLocation().toString();
            plugin.getLogger().warn(error);
            Optional<Player> optPlayer = event.getCause().first(Player.class);
            if (optPlayer.isPresent()) {
                optPlayer.get().sendMessage(Text.of(TextColors.RED, Constants.PREFIX, " ", error));
            }

        }
    }

}
 

import org.spongepowered.api.data.DataTransactionResult; //导入依赖的package包/类
protected static Set<Key<?>> getKeys(DataTransactionResult result) {
    final Set<Key<?>> keys = new HashSet<>();
    result.getReplacedData().forEach(value -> keys.add(value.getKey()));
    result.getSuccessfulData().forEach(value -> keys.add(value.getKey()));
    // We don't need the rejected keys, they didn't modify any values
    return keys;
}
 

import org.spongepowered.api.data.DataTransactionResult; //导入依赖的package包/类
protected static <H extends ValueContainer<?>> boolean undoFast(ICompositeValueStore<?, H> store, DataTransactionResult result) {
    final boolean hasListeners = hasListeners(store, getKeys(result));
    if (hasListeners) {
        return undo(store, result, () -> true).isSuccessful();
    }
    return store.undoFastNoEvents(result);
}
 

import org.spongepowered.api.data.DataTransactionResult; //导入依赖的package包/类
default DataTransactionResult offerNoEvents(Iterable<H> valueContainers, MergeFunction function) {
    final DataTransactionResult.Builder builder = DataTransactionResult.builder();
    for (H valueContainer : valueContainers) {
        builder.absorbResult(offerNoEvents(valueContainer, function));
    }
    return builder.build();
}
 

import org.spongepowered.api.data.DataTransactionResult; //导入依赖的package包/类
protected static <H extends ValueContainer<?>> DataTransactionResult offer(ICompositeValueStore<?, H> store,
        Iterable<H> valueContainers, MergeFunction function) {
    return offer(store, valueContainers, function, () -> {
        final Set<Key<?>> keys = new HashSet<>();
        for (H valueContainer : valueContainers) {
            keys.addAll(valueContainer.getKeys());
        }
        return hasListeners(store, keys);
    });
}
 

import org.spongepowered.api.data.DataTransactionResult; //导入依赖的package包/类
@Override
public DataTransactionResult removeFrom(IValueContainer<?> valueContainer) {
    DataTransactionResult result = null;
    for (Processor<V, E> processor : this.processors) {
        result = processor.removeFrom(valueContainer);
        if (result.isSuccessful()) {
            return result;
        }
    }
    return result == null ? DataTransactionResult.failNoData() : result;
}
 

import org.spongepowered.api.data.DataTransactionResult; //导入依赖的package包/类
@Override
public DataTransactionResult offerTo(IValueContainer<?> valueContainer, E element) {
    DataTransactionResult result = null;
    for (Processor<V, E> processor : this.processors) {
        result = processor.offerTo(valueContainer, element);
        if (result.isSuccessful()) {
            return result;
        }
    }
    return result == null ? DataTransactionResult.failNoData() : result;
}
 

import org.spongepowered.api.data.DataTransactionResult; //导入依赖的package包/类
@Override
public DataTransactionResult offerTo(IValueContainer<?> valueContainer, E element) {
    if (!isApplicableTo(valueContainer)) {
        return DataTransactionResult.failNoData();
    }
    return isApplicableTo(valueContainer) ? this.offerHandler.offer(valueContainer, getKey(), element) : DataTransactionResult.failNoData();
}
 

import org.spongepowered.api.data.DataTransactionResult; //导入依赖的package包/类
default DataTransactionResult removeNoEvents(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).removeFrom(this);
    }

    // Check for a global registration
    final Optional<ValueProcessorKeyRegistration> globalRegistration = LanternValueFactory.get().getKeyRegistration((Key) key);
    if (globalRegistration.isPresent()) {
        return ((Processor<BaseValue<?>, ?>) globalRegistration.get()).removeFrom(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).removeNoEvents(key);
                } else if (valueContainer instanceof CompositeValueStore) {
                    return ((CompositeValueStore) valueContainer).remove(key);
                }
                return DataTransactionResult.failNoData();
            }
        }
    }

    return DataTransactionResult.failNoData();
}
 

import org.spongepowered.api.data.DataTransactionResult; //导入依赖的package包/类
default boolean undoFastNoEvents(DataTransactionResult result) {
    if (result.getReplacedData().isEmpty() &&
            result.getSuccessfulData().isEmpty()) {
        return true;
    }
    result.getSuccessfulData().forEach(value -> removeFastNoEvents(value.getKey()));
    result.getReplacedData().forEach(value -> offerFastNoEvents((Key) value.getKey(), value.get()));
    return true;
}
 

import org.spongepowered.api.data.DataTransactionResult; //导入依赖的package包/类
default DataTransactionResult undoNoEvents(DataTransactionResult result) {
    if (result.getReplacedData().isEmpty() &&
            result.getSuccessfulData().isEmpty()) {
        return DataTransactionResult.successNoData();
    }
    final DataTransactionResult.Builder builder = DataTransactionResult.builder();
    for (ImmutableValue<?> replaced : result.getReplacedData()) {
        builder.absorbResult(offerNoEvents(replaced));
    }
    for (ImmutableValue<?> successful : result.getSuccessfulData()) {
        builder.absorbResult(removeNoEvents(successful.getKey()));
    }
    return builder.result(DataTransactionResult.Type.SUCCESS).build();
}
 

import org.spongepowered.api.data.DataTransactionResult; //导入依赖的package包/类
@Override
public DataTransactionResult removeFrom(ValueContainer<?> container) {
    return DataTransactionResult.failNoData();
}
 

import org.spongepowered.api.data.DataTransactionResult; //导入依赖的package包/类
@Override
public DataTransactionResult remove(DataHolder dataHolder) {
    return DataTransactionResult.failNoData();
}