Examples with CompositeValueStore org.spongepowered.api.data.value.mutable.CompositeValueStore used on opensource projects

Example 1 with CompositeValueStore

use of org.spongepowered.api.data.value.mutable.CompositeValueStore in project LanternServer by LanternPowered.

the class CompositeValueStoreHelper method offerFast.

protected static <H extends ValueContainer<?>> boolean offerFast(ICompositeValueStore<?, H> store, Iterable<H> valueContainers, MergeFunction function) {
    // Leave this, the compiler complains
    final CompositeValueStore store1 = store;
    if (store1 instanceof DataHolder) {
        final Set<Key<?>> keys = new HashSet<>();
        for (H valueContainer : valueContainers) {
            keys.addAll(valueContainer.getKeys());
        }
        final boolean hasListeners = hasListeners(store, keys);
        if (hasListeners) {
            return offer(store, valueContainers, function, () -> true).isSuccessful();
        }
    }
    return store.offerFastNoEvents(valueContainers, function);
}

Example 2 with CompositeValueStore

use of org.spongepowered.api.data.value.mutable.CompositeValueStore in project LanternServer by LanternPowered.

the class DataRegistrar method setupRegistrations.

public static void setupRegistrations(LanternGame game) {
    Copyable.register(ImmutableMap.class, map -> map);
    Copyable.register(ImmutableList.class, list -> list);
    Copyable.register(ImmutableSet.class, set -> set);
    Copyable.register(List.class, ArrayList::new);
    Copyable.register(Set.class, HashSet::new);
    Copyable.register(Map.class, HashMap::new);
    final PropertyRegistry propertyRegistry = game.getPropertyRegistry();
    // Block property stores
    propertyRegistry.register(SkyLuminanceProperty.class, new SkyLuminancePropertyStore());
    propertyRegistry.register(GroundLuminanceProperty.class, new GroundLuminancePropertyStore());
    // Entity property stores
    propertyRegistry.register(DominantHandProperty.class, new DominantHandPropertyStore());
    // Item property stores
    propertyRegistry.register(SmeltableProperty.class, new SmeltablePropertyStore());
    propertyRegistry.register(BurningFuelProperty.class, new BurningFuelPropertyStore());
    final LanternDataManager dataManager = game.getDataManager();
    // Register the data type serializers
    DataTypeSerializers.registerSerializers(dataManager);
    // Register the data serializers
    DataTranslators.registerSerializers(dataManager);
    // Register the data builders
    dataManager.registerBuilder(PatternLayer.class, new LanternPatternLayer.Builder(game));
    dataManager.registerBuilder(Text.class, new TextConfigSerializer());
    dataManager.registerBuilder(BookView.class, new BookViewDataBuilder());
    dataManager.registerBuilder(PotionEffect.class, new LanternPotionEffectBuilder());
    dataManager.registerBuilder(RespawnLocation.class, new RespawnLocation.Builder());
    dataManager.registerBuilder(Enchantment.class, new LanternEnchantmentBuilder());
    final LanternValueFactory valueFactory = LanternValueFactory.get();
    valueFactory.registerKey(Keys.CONNECTED_DIRECTIONS).add(builder -> builder.applicableTester(valueContainer -> valueContainer.supports(Keys.CONNECTED_WEST) || valueContainer.supports(Keys.CONNECTED_EAST) || valueContainer.supports(Keys.CONNECTED_NORTH) || valueContainer.supports(Keys.CONNECTED_SOUTH)).retrieveHandler((valueContainer, key) -> {
        final Set<Direction> directions = new HashSet<>();
        if (valueContainer.get(Keys.CONNECTED_WEST).orElse(false)) {
            directions.add(Direction.WEST);
        }
        if (valueContainer.get(Keys.CONNECTED_EAST).orElse(false)) {
            directions.add(Direction.EAST);
        }
        if (valueContainer.get(Keys.CONNECTED_SOUTH).orElse(false)) {
            directions.add(Direction.SOUTH);
        }
        if (valueContainer.get(Keys.CONNECTED_NORTH).orElse(false)) {
            directions.add(Direction.NORTH);
        }
        return Optional.of(directions);
    }).offerHandler((valueContainer, key, directions) -> {
        if (valueContainer instanceof ICompositeValueStore) {
            final ICompositeValueStore store = (ICompositeValueStore) valueContainer;
            final DataTransactionResult.Builder resultBuilder = DataTransactionResult.builder();
            resultBuilder.absorbResult(store.offerNoEvents(Keys.CONNECTED_WEST, directions.contains(Direction.WEST)));
            resultBuilder.absorbResult(store.offerNoEvents(Keys.CONNECTED_EAST, directions.contains(Direction.EAST)));
            resultBuilder.absorbResult(store.offerNoEvents(Keys.CONNECTED_SOUTH, directions.contains(Direction.SOUTH)));
            resultBuilder.absorbResult(store.offerNoEvents(Keys.CONNECTED_NORTH, directions.contains(Direction.NORTH)));
            return resultBuilder.result(DataTransactionResult.Type.SUCCESS).build();
        }
        return DataTransactionResult.successNoData();
    }).failAlwaysRemoveHandler());
    valueFactory.registerKey(Keys.WIRE_ATTACHMENTS).add(builder -> builder.applicableTester(valueContainer -> valueContainer.supports(Keys.WIRE_ATTACHMENT_WEST) || valueContainer.supports(Keys.WIRE_ATTACHMENT_EAST) || valueContainer.supports(Keys.WIRE_ATTACHMENT_NORTH) || valueContainer.supports(Keys.WIRE_ATTACHMENT_SOUTH)).retrieveHandler((valueContainer, key) -> {
        final Map<Direction, WireAttachmentType> attachments = new HashMap<>();
        valueContainer.get(Keys.WIRE_ATTACHMENT_WEST).ifPresent(type -> attachments.put(Direction.WEST, type));
        valueContainer.get(Keys.WIRE_ATTACHMENT_EAST).ifPresent(type -> attachments.put(Direction.EAST, type));
        valueContainer.get(Keys.WIRE_ATTACHMENT_SOUTH).ifPresent(type -> attachments.put(Direction.SOUTH, type));
        valueContainer.get(Keys.WIRE_ATTACHMENT_NORTH).ifPresent(type -> attachments.put(Direction.NORTH, type));
        return Optional.of(attachments);
    }).offerHandler((key, valueContainer, attachments) -> {
        if (valueContainer instanceof ICompositeValueStore) {
            final ICompositeValueStore store = (ICompositeValueStore) valueContainer;
            final DataTransactionResult.Builder resultBuilder = DataTransactionResult.builder();
            WireAttachmentType type = attachments.get(Direction.WEST);
            resultBuilder.absorbResult(store.offerNoEvents(Keys.CONNECTED_WEST, type == null ? WireAttachmentTypes.NONE : type));
            type = attachments.get(Direction.EAST);
            resultBuilder.absorbResult(store.offerNoEvents(Keys.CONNECTED_EAST, type == null ? WireAttachmentTypes.NONE : type));
            type = attachments.get(Direction.SOUTH);
            resultBuilder.absorbResult(store.offerNoEvents(Keys.CONNECTED_SOUTH, type == null ? WireAttachmentTypes.NONE : type));
            type = attachments.get(Direction.NORTH);
            resultBuilder.absorbResult(store.offerNoEvents(Keys.CONNECTED_NORTH, type == null ? WireAttachmentTypes.NONE : type));
            return resultBuilder.result(DataTransactionResult.Type.SUCCESS).build();
        }
        return DataTransactionResult.successNoData();
    }).failAlwaysRemoveHandler());
    valueFactory.registerKey(Keys.BODY_ROTATIONS).add(builder -> builder.applicableTester(valueContainer -> valueContainer.supports(Keys.RIGHT_ARM_ROTATION) || valueContainer.supports(Keys.LEFT_ARM_ROTATION) || valueContainer.supports(Keys.RIGHT_LEG_ROTATION) || valueContainer.supports(Keys.LEFT_LEG_ROTATION) || valueContainer.supports(Keys.HEAD_ROTATION) || valueContainer.supports(Keys.CHEST_ROTATION)).retrieveHandler((valueContainer, key) -> {
        final Map<BodyPart, Vector3d> rotations = new HashMap<>();
        valueContainer.get(Keys.RIGHT_ARM_ROTATION).ifPresent(type -> rotations.put(BodyParts.RIGHT_ARM, type));
        valueContainer.get(Keys.RIGHT_LEG_ROTATION).ifPresent(type -> rotations.put(BodyParts.RIGHT_LEG, type));
        valueContainer.get(Keys.LEFT_ARM_ROTATION).ifPresent(type -> rotations.put(BodyParts.LEFT_ARM, type));
        valueContainer.get(Keys.LEFT_LEG_ROTATION).ifPresent(type -> rotations.put(BodyParts.LEFT_LEG, type));
        valueContainer.get(Keys.HEAD_ROTATION).ifPresent(type -> rotations.put(BodyParts.HEAD, type));
        valueContainer.get(Keys.CHEST_ROTATION).ifPresent(type -> rotations.put(BodyParts.CHEST, type));
        return Optional.of(rotations);
    }).offerHandler((key, valueContainer, rotations) -> {
        if (valueContainer instanceof CompositeValueStore) {
            final ICompositeValueStore store = (ICompositeValueStore) valueContainer;
            final DataTransactionResult.Builder resultBuilder = DataTransactionResult.builder();
            Vector3d rot;
            if ((rot = rotations.get(BodyParts.RIGHT_ARM)) != null) {
                resultBuilder.absorbResult(store.offerNoEvents(Keys.RIGHT_ARM_ROTATION, rot));
            }
            if ((rot = rotations.get(BodyParts.RIGHT_LEG)) != null) {
                resultBuilder.absorbResult(store.offerNoEvents(Keys.RIGHT_LEG_ROTATION, rot));
            }
            if ((rot = rotations.get(BodyParts.LEFT_ARM)) != null) {
                resultBuilder.absorbResult(store.offerNoEvents(Keys.LEFT_ARM_ROTATION, rot));
            }
            if ((rot = rotations.get(BodyParts.LEFT_LEG)) != null) {
                resultBuilder.absorbResult(store.offerNoEvents(Keys.LEFT_LEG_ROTATION, rot));
            }
            if ((rot = rotations.get(BodyParts.HEAD)) != null) {
                resultBuilder.absorbResult(store.offerNoEvents(Keys.HEAD_ROTATION, rot));
            }
            if ((rot = rotations.get(BodyParts.CHEST)) != null) {
                resultBuilder.absorbResult(store.offerNoEvents(Keys.CHEST_ROTATION, rot));
            }
            return resultBuilder.result(DataTransactionResult.Type.SUCCESS).build();
        }
        return DataTransactionResult.successNoData();
    }).failAlwaysRemoveHandler());
    DataManipulatorRegistry.get();
}

Example 3 with CompositeValueStore

use of org.spongepowered.api.data.value.mutable.CompositeValueStore in project LanternServer by LanternPowered.

the class DataHelper method deserializeRawRegisteredKeyData.

public static void deserializeRawRegisteredKeyData(DataView dataView, IValueContainer valueContainer) throws InvalidDataException {
    dataView = dataView.getView(DataQueries.DATA_VALUES).orElse(null);
    if (dataView == null) {
        return;
    }
    final ValueCollection valueCollection = valueContainer.getValueCollection();
    final LanternDataManager dataManager = Lantern.getGame().getDataManager();
    final DataTypeSerializerContext context = dataManager.getTypeSerializerContext();
    for (KeyRegistration<?, ?> registration : valueCollection.getAll()) {
        final Key<?> key = registration.getKey();
        if (!(registration instanceof Element) || key == LanternKeys.FAILED_DATA_MANIPULATORS || key == LanternKeys.FAILED_DATA_VALUES) {
            continue;
        }
        final Optional<Object> data = dataView.get(key.getQuery());
        if (!data.isPresent()) {
            continue;
        }
        dataView.remove(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()));
        ((Element) registration).set(typeSerializer.deserialize(typeToken, context, data.get()));
    }
    if (valueContainer instanceof CompositeValueStore) {
        final CompositeValueStore store = (CompositeValueStore) valueContainer;
        for (Map.Entry<DataQuery, Object> entry : dataView.getValues(false).entrySet()) {
            final Key<?> key = KeyRegistryModule.get().getByQuery(entry.getKey()).orElse(null);
            if (key == null) {
                continue;
            }
            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()));
            store.offer(key, typeSerializer.deserialize(typeToken, context, entry.getValue()));
            dataView.remove(entry.getKey());
        }
    }
    if (!dataView.isEmpty()) {
        // Should be safe to cast, at least if nobody touches this key
        Element<DataView> holder = valueCollection.getElement(LanternKeys.FAILED_DATA_VALUES).orElse(null);
        if (holder == null) {
            holder = valueCollection.register(LanternKeys.FAILED_DATA_VALUES, null);
        }
        holder.set(dataView);
    }
}

Example 4 with CompositeValueStore

use of org.spongepowered.api.data.value.mutable.CompositeValueStore in project LanternServer by LanternPowered.

the class ICompositeValueStore method offerNoEvents.

default <E> DataTransactionResult offerNoEvents(Key<? extends BaseValue<E>> key, E element) {
    // Check the local key registration
    final KeyRegistration<?, ?> localKeyRegistration = (KeyRegistration<?, ?>) getValueCollection().get((Key) key).orElse(null);
    if (localKeyRegistration != null) {
        return ((Processor<BaseValue<E>, E>) localKeyRegistration).offerTo(this, element);
    }
    // Check for a global registration
    final Optional<ValueProcessorKeyRegistration> globalRegistration = LanternValueFactory.get().getKeyRegistration((Key) key);
    if (globalRegistration.isPresent()) {
        return ((Processor<BaseValue<E>, E>) globalRegistration.get()).offerTo(this, element);
    }
    // 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).offerNoEvents(key, element);
                } else if (valueContainer instanceof CompositeValueStore) {
                    return ((CompositeValueStore) valueContainer).offer(key, element);
                } else if (valueContainer instanceof DataManipulator) {
                    final ImmutableValue oldImmutableValue = (ImmutableValue) valueContainer.getValue((Key) key).map(value -> ValueHelper.toImmutable((BaseValue) value)).orElse(null);
                    ((DataManipulator) valueContainer).set(key, element);
                    final ImmutableValue immutableValue = (ImmutableValue) valueContainer.getValue((Key) key).map(value -> ValueHelper.toImmutable((BaseValue) value)).orElse(null);
                    if (oldImmutableValue == null && immutableValue == null) {
                        return DataTransactionResult.successNoData();
                    } else if (oldImmutableValue == null) {
                        return DataTransactionResult.successResult(immutableValue);
                    } else if (immutableValue == null) {
                        return DataTransactionResult.successRemove(oldImmutableValue);
                    } else {
                        return DataTransactionResult.successReplaceResult(immutableValue, oldImmutableValue);
                    }
                } else {
                    // TODO: Support immutable manipulators?
                    return DataTransactionResult.failNoData();
                }
            }
        }
    }
    return DataTransactionResult.failNoData();
}