add DefaultedTag

Author: MrHell228

src/main/java/org/spongepowered/api/event/cause/entity/damage/DamageType.java

@@ -29,7 +29,6 @@
 import org.spongepowered.api.entity.Entity;
 import org.spongepowered.api.event.cause.entity.damage.source.DamageSource;
 import org.spongepowered.api.registry.DefaultedRegistryValue;
-import org.spongepowered.api.tag.Tag;
 import org.spongepowered.api.tag.Taggable;
 import org.spongepowered.api.util.CopyableBuilder;
 import org.spongepowered.api.util.Nameable;
@@ -65,15 +64,6 @@ static Builder builder() {
      */
     double exhaustion();
 
-    /**
-     * Checks whether this damage types matches a damage type tag.
-     *
-     * @param tag The tag to check.
-     * @return true if this damage type matches the damage type tag.
-     */
-    @Override
-    boolean is(Tag<DamageType> tag);
-
     /**
      * Returns the damage scaling.
      *

src/main/java/org/spongepowered/api/registry/Registry.java

@@ -30,7 +30,6 @@
 
 import java.util.Objects;
 import java.util.Optional;
-import java.util.Set;
 import java.util.stream.Stream;
 
 /**
@@ -128,7 +127,7 @@ default <V extends T> Optional<V> findValue(final RegistryKey<T> key) {
      *
      * @return The registered types associated with given tag
      */
-    <V extends T> Set<V> taggedValues(Tag<T> tag);
+    <V extends T> Stream<V> taggedValues(Tag<T> tag);
 
     /**
      * Gets the tags associated with this registry.

src/main/java/org/spongepowered/api/tag/DefaultedTag.java

@@ -0,0 +1,80 @@
+/*
+ * This file is part of SpongeAPI, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) SpongePowered <https://www.spongepowered.org>
+ * Copyright (c) contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package org.spongepowered.api.tag;
+
+import org.spongepowered.api.ResourceKey;
+import org.spongepowered.api.registry.DefaultedRegistryType;
+import org.spongepowered.api.registry.RegistryHolder;
+import org.spongepowered.api.registry.ValueNotFoundException;
+
+import java.util.Objects;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+/**
+ * A {@link Tag} paired with the {@link RegistryHolder}.
+ */
+public interface DefaultedTag<T> extends Tag<T> {
+
+    static <T> DefaultedTag<T> of(final DefaultedRegistryType<T> registryType, final ResourceKey location) {
+        return Tag.of(registryType, location).asDefaultedTag(registryType.defaultHolder());
+    }
+
+    Supplier<RegistryHolder> defaultHolder();
+
+    /**
+     * Returns the {@link Stream} of values tagged by this tag in the {@link #defaultHolder()}.
+     *
+     * <p>Great care needs to be made in calling this method with any uncertainty as to
+     * if the {@link #registry()} will exist in the {@link #defaultHolder()}. Should the
+     * key lack a value, a {@link ValueNotFoundException} will be thrown. Therefore, it
+     * is advised to call {@link #findValues()} instead.</p>
+     *
+     * @return The {@link Stream} of values
+     */
+    default Stream<T> values() {
+        return this.defaultHolder().get().registry(this.registry()).taggedValues(this);
+    }
+
+    /**
+     * Returns the {@link Stream} of values tagged by this tag in the {@link #defaultHolder()}
+     * if it contains this tag's {@link #registry()}, or {@link Stream#empty()} otherwise.
+     *
+     * @return The {@link Stream} of values
+     */
+    default Stream<T> findValues() {
+        return this.defaultHolder().get().findRegistry(this.registry()).map(r -> r.taggedValues(this)).orElseGet(Stream::empty);
+    }
+
+    /**
+     * Returns whether this tag is associated with the given value in the {@link #defaultHolder()}.
+     *
+     * @param value The value
+     * @return true if this tag is associated with the given value in the {@link #defaultHolder()}
+     */
+    default boolean contains(final T value) {
+        return this.findValues().anyMatch(Objects.requireNonNull(value, "value")::equals);
+    }
+}

src/main/java/org/spongepowered/api/tag/Tag.java

@@ -29,9 +29,11 @@
 import org.spongepowered.api.ResourceKeyed;
 import org.spongepowered.api.Sponge;
 import org.spongepowered.api.block.BlockType;
-import org.spongepowered.api.registry.DefaultedRegistryType;
+import org.spongepowered.api.registry.RegistryHolder;
 import org.spongepowered.api.registry.RegistryType;
 
+import java.util.function.Supplier;
+
 /**
  * A {@link ResourceKey resource keyed} collection of {@link Taggable} values
  * (of type {@code T}).
@@ -50,26 +52,22 @@
  */
 public interface Tag<T> extends ResourceKeyed {
 
+    static <T> Tag<T> of(final RegistryType<T> registryType, final ResourceKey key) {
+        return Sponge.game().factoryProvider().provide(Tag.Factory.class).of(registryType, key);
+    }
+
     /**
      * Gets the {@link RegistryType location} defining the parent registry.
      *
      * @return The location
      */
     RegistryType<T> registry();
 
-    interface Factory {
-        default <T> Tag<T> of(DefaultedRegistryType<T> registryType, ResourceKey key) {
-            return this.of((RegistryType<T>) registryType, key);
-        }
+    DefaultedTag<T> asDefaultedTag(Supplier<RegistryHolder> holder);
 
-        <T> Tag<T> of(RegistryType<T> registryType, ResourceKey key);
-    }
+    DefaultedTag<T> asScopedTag();
 
-    static <T> Tag<T> of(DefaultedRegistryType<T> registryType, ResourceKey key) {
-        return Sponge.game().factoryProvider().provide(Tag.Factory.class).of(registryType, key);
-    }
-
-    static <T> Tag<T> of(RegistryType<T> registryType, ResourceKey key) {
-        return Sponge.game().factoryProvider().provide(Tag.Factory.class).of(registryType, key);
+    interface Factory {
+        <T> Tag<T> of(RegistryType<T> registryType, ResourceKey key);
     }
 }

src/main/java/org/spongepowered/api/tag/Taggable.java

@@ -26,35 +26,55 @@
 
 import org.spongepowered.api.registry.DefaultedRegistryType;
 import org.spongepowered.api.registry.DefaultedRegistryValue;
-import org.spongepowered.api.registry.RegistryType;
+import org.spongepowered.api.registry.Registry;
+import org.spongepowered.api.registry.RegistryHolder;
 
-import java.util.Collection;
+import java.util.Objects;
+import java.util.stream.Stream;
 
 /**
  * A type that may be included in one or more {@link Tag} collections.
  */
+@SuppressWarnings("unchecked")
 public interface Taggable<T extends Taggable<T>> extends DefaultedRegistryValue {
 
     /**
-     * Gets the {@link RegistryType} that holds the types of {@link Tag tags}
-     * that can be associated with this object.
+     * Gets all {@link Tag}s that have been associated with this object in the given registry.
      *
-     * @return The {@link RegistryType}
+     * @return The {@link Stream} of {@link Tag}s.
      */
-    DefaultedRegistryType<T> registryType();
+    default Stream<Tag<T>> tags(final DefaultedRegistryType<T> registryType) {
+        final Registry<T> registry = Objects.requireNonNull(registryType, "registryType").get();
+        return registry.tags().filter(tag -> this.is(registry, tag));
+    }
 
     /**
-     * Gets all {@link Tag tags} that have been associated with this object.
+     * Returns whether the given tag is associated with this object in the given registry holder.
      *
-     * @return The {@link Collection} of {@link Tag}s.
+     * @param tag The tag
+     * @return true if the given tag is associated with this object in the given registry holder
      */
-    Collection<Tag<T>> tags();
+    default boolean is(final RegistryHolder registryHolder, final Tag<T> tag) {
+        return registryHolder.findRegistry(tag.registry()).map(r -> this.is(r, tag)).orElse(false);
+    }
 
     /**
-     * Returns true when given tag is associated with this object
+     * Returns whether the given tag is associated with this object in the given registry.
+     *
      * @param tag The tag
-     * @return true when given tag is associated with this object
+     * @return true if the given tag is associated with this object in the given registry
      */
-    boolean is(Tag<T> tag);
+    default boolean is(final Registry<T> registry, final Tag<T> tag) {
+        return registry.taggedValues(tag).anyMatch(this::equals);
+    }
 
+    /**
+     * Returns whether the given tag is associated with this object.
+     *
+     * @param tag The tag
+     * @return true if the given tag is associated with this object
+     */
+    default boolean is(final DefaultedTag<T> tag) {
+        return tag.contains((T) this);
+    }
 }