Java DataContainer.set方法代码示例

import org.spongepowered.api.data.DataContainer; //导入方法依赖的package包/类
@SuppressWarnings("deprecation")
public static List<DataView> serializeInventory(Inventory inventory) {
	DataContainer container;
	List<DataView> slots = new LinkedList<>();

	int i = 0;
	Optional<ItemStack> stack;

	for (Inventory inv : inventory.slots()) {
		stack = inv.peek();

		if (stack.isPresent()) {
			container = new org.spongepowered.api.data.MemoryDataContainer();

			container.set(SLOT, i);
			container.set(STACK, serializeItemStack(stack.get()));

			slots.add(container);
		}

		i++;
	}

	return slots;
}
 

import org.spongepowered.api.data.DataContainer; //导入方法依赖的package包/类
public static DataContainer serialize(VirtualChestPlugin plugin, VirtualChestItem item) throws InvalidDataException
{
    DataContainer container = new MemoryDataContainer();
    container.set(ITEM, item.serializedStack);
    item.primaryAction.getObjectForSerialization().ifPresent(o -> container.set(PRIMARY_ACTION, o));
    item.secondaryAction.getObjectForSerialization().ifPresent(o -> container.set(SECONDARY_ACTION, o));
    if (!item.requirements.getFirst().isEmpty())
    {
        container.set(REQUIREMENTS, item.requirements.getFirst());
    }
    if (!item.ignoredPermissions.isEmpty())
    {
        container.set(IGNORED_PERMISSIONS, item.ignoredPermissions);
    }
    return container;
}
 

import org.spongepowered.api.data.DataContainer; //导入方法依赖的package包/类
@Override
public DataContainer toContainer() {
    List<String> ownerContainers = new ArrayList<String>();
    for (GameProfile profile : owners) {
        ownerContainers.add(profile.getUniqueId().toString());
    }

    DataContainer data = new MemoryDataContainer();
    data.set(DataQueries.Uuid, uuid.toString());
    data.set(DataQueries.ZoneName, name);
    data.set(DataQueries.Owners, ownerContainers);
    data.set(DataQueries.ZonePermissions, permissions);

    // Zone permissions
    Map<String, DataContainer> profileMap = new HashMap<String, DataContainer>();
    for (Entry<GameProfile, ZonePermissions> entry : userPermissions.entrySet()) {
        profileMap.put(entry.getKey().getUniqueId().toString(), entry.getValue().toContainer());
    }

    data.set(DataQueries.UserPermissions, profileMap);

    // Volume
    data.set(DataQueries.Volume, volume.toContainer());

    return data;
}
 

import org.spongepowered.api.data.DataContainer; //导入方法依赖的package包/类
@Override
public DataContainer toContainer() {
    // Volume
    DataContainer data = new MemoryDataContainer();

    // Min Coord
    DataContainer minData = new MemoryDataContainer();
    minData.set(DataQueries.X, min.getX());
    minData.set(DataQueries.Y, min.getY());
    minData.set(DataQueries.Z, min.getZ());
    data.set(DataQueries.Min, minData);

    // Max Coord
    DataContainer maxData = new MemoryDataContainer();
    maxData.set(DataQueries.X, max.getX());
    maxData.set(DataQueries.Y, max.getY());
    maxData.set(DataQueries.Z, max.getZ());
    data.set(DataQueries.Max, maxData);

    // World
    data.set(DataQueries.World, extent.getUniqueId().toString());

    return data;
}
 

import org.spongepowered.api.data.DataContainer; //导入方法依赖的package包/类
@Override
public DataContainer translate(ConfigurationNode node) throws InvalidDataException {
    checkNotNull(node, "node");
    final DataContainer container = DataContainer.createNew(DataView.SafetyMode.NO_DATA_CLONED);
    final Object value = node.getValue();
    final Object key = node.getKey();
    if (value != null) {
        if (key == null || value instanceof Map || value instanceof List) {
            if (value instanceof Map) {
                //noinspection unchecked
                for (Map.Entry<Object, Object> entry : ((Map<Object, Object>) value).entrySet()) {
                    container.set(DataQuery.of('.', entry.getKey().toString()), entry.getValue());
                }
            } else if (key != null) {
                container.set(DataQuery.of(key.toString()), value);
            }
        } else {
            container.set(DataQuery.of('.', key.toString()), value);
        }
    }
    return container;
}
 

import org.spongepowered.api.data.DataContainer; //导入方法依赖的package包/类
public static DataContainer toContainer(IValueContainer valueContainer) {
    final DataContainer dataContainer = DataContainer.createNew();
    final ValueCollection valueCollection = valueContainer.getValueCollection();
    final LanternDataManager dataManager = Lantern.getGame().getDataManager();
    for (KeyRegistration<?,?> registration : valueCollection.getAll()) {
        if (!(registration instanceof Element)) {
            continue;
        }
        final Key<?> key = registration.getKey();
        final DataQuery dataQuery = key.getQuery();
        final TypeToken<?> typeToken = key.getElementToken();
        final DataTypeSerializer typeSerializer = dataManager.getTypeSerializer(typeToken)
                .orElseThrow(() -> new IllegalStateException("Wasn't able to find a type serializer for the element type: " + typeToken.toString()));
        final DataTypeSerializerContext context = dataManager.getTypeSerializerContext();
        // The value's shouldn't be null inside a data manipulator,
        // since it doesn't support removal of values
        dataContainer.set(dataQuery, typeSerializer.serialize(typeToken, context,
                checkNotNull(((Element) registration).get(), "element")));
    }
    return dataContainer;
}
 

import org.spongepowered.api.data.DataContainer; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public List<DataView> serialize(TypeToken<?> type, DataTypeSerializerContext ctx, Multimap<?, ?> obj) throws InvalidDataException {
    final TypeToken<?> keyType = type.resolveType(this.keyTypeVariable);
    final TypeToken<?> valueType = type.resolveType(this.valueTypeVariable);
    final DataTypeSerializer keySerial = ctx.getSerializers().getTypeSerializer(keyType)
            .orElseThrow(() -> new IllegalStateException("Wasn't able to find a type serializer for: " + keyType.toString()));
    final DataTypeSerializer valueSerial = ctx.getSerializers().getTypeSerializer(valueType)
            .orElseThrow(() -> new IllegalStateException("Wasn't able to find a type serializer for: " + valueType.toString()));
    final List<DataView> dataViews = new ArrayList<>();
    for (Object key : obj.keySet()) {
        final DataContainer dataContainer = DataContainer.createNew();
        dataContainer.set(KEY, keySerial.serialize(keyType, ctx, key));
        final Collection<Object> values = ((Multimap) obj).get(key);
        if (values.size() == 1) {
            dataContainer.set(VALUE, valueSerial.serialize(valueType, ctx, values.iterator().next()));
        } else {
            dataContainer.set(ENTRIES, values.stream().map(v -> valueSerial.serialize(valueType, ctx, v)).collect(Collectors.toList()));
        }
        dataViews.add(dataContainer);
    }
    return dataViews;
}
 

import org.spongepowered.api.data.DataContainer; //导入方法依赖的package包/类
public static void load(Path dataFolder, AbstractUser player) throws IOException {
    final String fileName = player.getUniqueId().toString() + ".dat";

    // Search for the player data and load it
    Path dataFile = dataFolder.resolve(PLAYER_DATA_FOLDER).resolve(fileName);
    if (Files.exists(dataFile)) {
        final DataContainer dataContainer = NbtStreamUtils.read(Files.newInputStream(dataFile), true);

        // Load sponge data if present and attach it to the main data
        dataFile = dataFolder.resolve(SPONGE_PLAYER_DATA_FOLDER).resolve(fileName);
        if (Files.exists(dataFile)) {
            final DataContainer spongeDataContainer = NbtStreamUtils.read(Files.newInputStream(dataFile), true);
            dataContainer.set(DataQueries.EXTENDED_SPONGE_DATA, spongeDataContainer);
        }

        final ObjectStore<AbstractUser> objectStore = ObjectStoreRegistry.get().get(AbstractUser.class).get();
        objectStore.deserialize(player, dataContainer);
    }

    final Path statisticsFile = dataFolder.resolve(STATISTICS_FOLDER).resolve(player.getUniqueId().toString() + ".json");
    if (Files.exists(statisticsFile)) {
        player.getStatisticMap().load(statisticsFile);
    }
}
 

import org.spongepowered.api.data.DataContainer; //导入方法依赖的package包/类
@Override
public DataContainer toContainer() {
    final DataContainer container = DataContainer.createNew()
            .set(UNIQUE_ID, this.uniqueId.toString());
    if (this.name != null) {
        container.set(NAME, this.name);
    }
    if (!this.properties.isEmpty()) {
        final DataContainer propertiesMap = DataContainer.createNew();
        for (String key : this.properties.keySet()) {
            final List<DataContainer> entries = new ArrayList<>();
            for (ProfileProperty property : this.properties.get(key)) {
                final DataContainer entry = DataContainer.createNew()
                        .set(VALUE, property.getValue());
                property.getSignature().ifPresent(signature -> entry.set(SIGNATURE, signature));
                entries.add(entry);
            }
            propertiesMap.set(DataQuery.of(key), entries);
        }
        container.set(PROPERTIES, propertiesMap);
    }
    return container;
}
 

import org.spongepowered.api.data.DataContainer; //导入方法依赖的package包/类
@Override
public DataContainer toContainer() {
	DataContainer container = new MemoryDataContainer();
	if (restrictions != null) {
		container = container.set(NKeys.CUSTOM_ITEM_DATA_RESTRICTIONS.getQuery(), this.restrictions);
	}
	if (enchantements != null) {
		container = container.set(NKeys.CUSTOM_ITEM_DATA_ENCHANTEMENTS.getQuery(), this.enchantements);
	}
	if (itemLevel != null) {
		container = container.set(NKeys.CUSTOM_ITEM_DATA_ITEM_LEVEL.getQuery(), this.itemLevel);
	}

	if (rarity != null) {
		container = container.set(NKeys.ITEM_RARITY.getQuery(), this.rarity);
	}

	if (socketCount != null) {
		container = container.set(NKeys.CUSTOM_ITEM_DATA_SOCKET_COUNT.getQuery(), this.socketCount);
	}
	return container;
}
 

import org.spongepowered.api.data.DataContainer; //导入方法依赖的package包/类
@Override
public DataContainer toContainer() {
	DataContainer c = super.toContainer();
	
	c.set(UPDATE_TIME, this.lastUpdate);
	c.set(AGE, this.age);
	
	return c;
}
 

import org.spongepowered.api.data.DataContainer; //导入方法依赖的package包/类
@Override
public DataContainer toContainer() {
	DataContainer c = super.toContainer();
	
	c.set(RottenData.UPDATE_TIME, this.lastUpdate);
	c.set(RottenData.AGE, this.age);
	
	return c;
}
 

import org.spongepowered.api.data.DataContainer; //导入方法依赖的package包/类
@Override
public DataContainer toContainer() {
    DataContainer permsissions = new MemoryDataContainer();

    for (Entry<String, Boolean> entry : permissions.entrySet()) {
        permsissions.set(DataQuery.of(entry.getKey()), entry.getValue());
    }

    return permsissions;
}
 

import org.spongepowered.api.data.DataContainer; //导入方法依赖的package包/类
@Override
public DataView serialize(LanternItemStack object) {
    final DataContainer dataContainer = DataContainer.createNew(DataView.SafetyMode.NO_DATA_CLONED);
    dataContainer.set(IDENTIFIER, object.getType().getId());
    serialize(object, dataContainer);
    return dataContainer;
}
 

import org.spongepowered.api.data.DataContainer; //导入方法依赖的package包/类
@Override
public DataContainer toContainer() {
    final DataContainer dataContainer = DataContainer.createNew();
    dataContainer.set(DataQuery.of("BlockType"), this.baseState.getBlockType().getId());
    for (Map.Entry<BlockTrait<?>, Comparable<?>> entry : this.traitValues.entrySet()) {
        final Object value = entry.getValue();
        dataContainer.set(((LanternBlockTrait) entry.getKey()).getKey().getQuery(), value);
    }
    return dataContainer;
}