Merge remote-tracking branch 'origin/dev' into wrapper/d4j

2025-02-17 13:06:27 +01:00
parent b4af922ac2 3b65784770
commit fd87431d51
21 changed files with 630 additions and 90 deletions
--- a/wrapper/javacord/src/main/java/net/tomatentum/marinara/wrapper/javacord/JavacordContextObjectProvider.java
+++ b/wrapper/javacord/src/main/java/net/tomatentum/marinara/wrapper/javacord/JavacordContextObjectProvider.java
@@ -0,0 +1,110 @@
+package net.tomatentum.marinara.wrapper.javacord;
+
+import org.javacord.api.interaction.AutocompleteInteraction;
+import org.javacord.api.interaction.ButtonInteraction;
+import org.javacord.api.interaction.SlashCommandInteraction;
+import org.javacord.api.interaction.SlashCommandInteractionOption;
+import org.javacord.api.interaction.SlashCommandOptionType;
+
+import net.tomatentum.marinara.wrapper.ContextObjectProvider;
+
+public class JavacordContextObjectProvider implements ContextObjectProvider {
+
+    @Override
+    public Object convertCommandOption(Object context, String optionName) {
+        if (!(context instanceof SlashCommandInteraction))
+            return null;
+        SlashCommandInteraction interaction = (SlashCommandInteraction) context;
+        if (!interaction.getArguments().isEmpty())
+            return getOptionValue(interaction.getOptionByName(optionName).get());
+
+        SlashCommandInteractionOption subCommandOption = interaction.getOptions().getFirst();
+
+        if (!subCommandOption.getOptions().isEmpty())
+            subCommandOption = subCommandOption.getOptions().getFirst();
+
+        return getOptionValue(subCommandOption.getOptionByName(optionName).get());
+    }
+
+    private Object getOptionValue(SlashCommandInteractionOption option) {
+        SlashCommandOptionType type = getOptionType(option);
+        switch (type) {
+            case ATTACHMENT:
+                return option.getAttachmentValue().get();
+            case BOOLEAN:
+                return option.getBooleanValue().get();
+            case CHANNEL:
+                return option.getChannelValue().get();
+            case DECIMAL:
+                return option.getDecimalValue().get();
+            case LONG:
+                return option.getLongValue().get();
+            case MENTIONABLE:
+                return option.requestMentionableValue().get();
+            case ROLE:
+                return option.getRoleValue().get();
+            case STRING:
+                return option.getStringValue().get();
+            case USER:
+                return option.requestUserValue().get();
+            default:
+                return null;
+        }
+    }
+
+
+    private SlashCommandOptionType getOptionType(SlashCommandInteractionOption option) {
+        if (option.getAttachmentValue().isPresent())
+            return SlashCommandOptionType.ATTACHMENT;
+        if (option.getBooleanValue().isPresent())
+            return SlashCommandOptionType.BOOLEAN;
+        if (option.getChannelValue().isPresent())
+            return SlashCommandOptionType.CHANNEL;
+        if (option.getDecimalValue().isPresent())
+            return SlashCommandOptionType.DECIMAL;
+        if (option.getLongValue().isPresent())
+            return SlashCommandOptionType.LONG;
+        if (option.requestMentionableValue().isPresent())
+            return SlashCommandOptionType.MENTIONABLE;
+        if (option.getRoleValue().isPresent())
+            return SlashCommandOptionType.ROLE;
+        if (option.getStringValue().isPresent())
+            return SlashCommandOptionType.STRING;
+        if (option.requestUserValue().isPresent())
+            return SlashCommandOptionType.USER;
+
+        return SlashCommandOptionType.UNKNOWN;
+    }
+
+    @Override
+    public Object getComponentContextObject(Object context, Class<?> type) {
+        ButtonInteraction button = (ButtonInteraction) context;
+        switch (type.getName()) {
+            case "org.javacord.api.entity.message.Message":
+                return button.getMessage();
+            default:
+                return getInteractionContextObject(context, type);
+        }
+    }
+
+    @Override
+    public Object getInteractionContextObject(Object context, Class<?> type) {
+        ButtonInteraction button = (ButtonInteraction) context;
+        switch (type.getName()) {
+            case "org.javacord.api.entity.channel.TextChannel":
+                return button.getChannel().orElse(null);
+            case "org.javacord.api.entity.server.Server":
+                return button.getServer().orElse(null);
+            case "org.javacord.api.entity.user.User":
+                return button.getUser();
+        }
+        return null;
+    }
+
+    @Override
+    public Object getAutocompleteFocusedOption(Object context) {
+        AutocompleteInteraction interaction = (AutocompleteInteraction) context;
+        return getOptionValue(interaction.getFocusedOption());
+    }
+
+}
--- a/wrapper/javacord/src/main/java/net/tomatentum/marinara/wrapper/javacord/JavacordWrapper.java
+++ b/wrapper/javacord/src/main/java/net/tomatentum/marinara/wrapper/javacord/JavacordWrapper.java
@@ -11,10 +11,14 @@ import java.util.Set;
 import org.apache.logging.log4j.Logger;
 import org.javacord.api.DiscordApi;
 import org.javacord.api.interaction.ApplicationCommandInteraction;
+import org.javacord.api.interaction.AutocompleteInteraction;
 import org.javacord.api.interaction.ButtonInteraction;
 import org.javacord.api.interaction.SlashCommandBuilder;
 import org.javacord.api.interaction.SlashCommandInteraction;
 import org.javacord.api.interaction.SlashCommandInteractionOption;
+import org.javacord.api.interaction.SlashCommandOptionBuilder;
+import org.javacord.api.interaction.SlashCommandOptionChoiceBuilder;
+import org.javacord.api.interaction.SlashCommandOptionType;

 import io.leangen.geantyref.AnnotationFormatException;
 import io.leangen.geantyref.TypeFactory;
@@ -23,31 +27,35 @@ import net.tomatentum.marinara.interaction.commands.ExecutableSlashCommandDefini
 import net.tomatentum.marinara.interaction.commands.SlashCommandDefinition;
 import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand;
 import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOption;
+import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOptionChoice;
 import net.tomatentum.marinara.interaction.commands.annotation.SubCommand;
 import net.tomatentum.marinara.interaction.commands.annotation.SubCommandGroup;
-import net.tomatentum.marinara.interaction.commands.option.SlashCommandOptionType;
+import net.tomatentum.marinara.wrapper.ContextObjectProvider;
 import net.tomatentum.marinara.util.LoggerUtil;
 import net.tomatentum.marinara.wrapper.LibraryWrapper;

 public class JavacordWrapper extends LibraryWrapper {

    private DiscordApi api;
-
+    private JavacordContextObjectProvider contextObjectProvider;
+    
    private Logger logger = LoggerUtil.getLogger(getClass());

    public JavacordWrapper(DiscordApi api) {
        this.api = api;
+        this.contextObjectProvider = new JavacordContextObjectProvider();
        api.addInteractionCreateListener((e) -> handleInteraction(e.getInteraction()));
        logger.info("Javacord wrapper loaded!");
    }

    @Override
    public InteractionType getInteractionType(Object context) {
+        if (AutocompleteInteraction.class.isAssignableFrom(context.getClass()))
+            return InteractionType.AUTOCOMPLETE;
        if (ApplicationCommandInteraction.class.isAssignableFrom(context.getClass()))
            return InteractionType.COMMAND;
        if (ButtonInteraction.class.isAssignableFrom(context.getClass()))
            return InteractionType.BUTTON;
-
        return null;
    }

@@ -72,22 +80,6 @@ public class JavacordWrapper extends LibraryWrapper {
        api.bulkOverwriteGlobalApplicationCommands(globalCommands);
    }

-    @Override
-    public Object convertCommandOption(Object context, SlashCommandOptionType type, String optionName) {
-        if (!(context instanceof SlashCommandInteraction))
-            return null;
-        SlashCommandInteraction interaction = (SlashCommandInteraction) context;
-        if (!interaction.getArguments().isEmpty())
-            return getOptionValue(interaction.getOptionByName(optionName).get(), type);
-
-        SlashCommandInteractionOption subCommandOption = interaction.getOptions().getFirst();
-
-        if (!subCommandOption.getOptions().isEmpty())
-            subCommandOption = subCommandOption.getOptions().getFirst();
-
-        return getOptionValue(subCommandOption.getOptionByName(optionName).get(), type);
-    }
-
    @Override
    public ExecutableSlashCommandDefinition getCommandDefinition(Object context) {
        if (!(context instanceof SlashCommandInteraction))
@@ -128,43 +120,53 @@ public class JavacordWrapper extends LibraryWrapper {
    private org.javacord.api.interaction.SlashCommandOption convertSubCommandGroupDef(SlashCommandDefinition def, SubCommandGroup subGroup) {
        SubCommand[] subCommands = def.getSubCommands(subGroup.name());
        org.javacord.api.interaction.SlashCommandOption[] convertedSubCommands = (org.javacord.api.interaction.SlashCommandOption[]) Arrays.stream(subCommands).map(this::convertSubCommandDef).toArray();
-        return org.javacord.api.interaction.SlashCommandOption.createWithOptions(org.javacord.api.interaction.SlashCommandOptionType.SUB_COMMAND_GROUP, subGroup.name(), subGroup.description(), Arrays.asList(convertedSubCommands));
+        return org.javacord.api.interaction.SlashCommandOption.createWithOptions(
+            org.javacord.api.interaction.SlashCommandOptionType.SUB_COMMAND_GROUP, 
+            subGroup.name(), 
+            subGroup.description(), 
+            Arrays.asList(convertedSubCommands));
    }

    private org.javacord.api.interaction.SlashCommandOption convertSubCommandDef(SubCommand sub) {
        List<org.javacord.api.interaction.SlashCommandOption> convertedOptions = new ArrayList<>();
        Arrays.stream(sub.options()).map(this::convertOptionDef).forEach(convertedOptions::add);
-        return org.javacord.api.interaction.SlashCommandOption.createWithOptions(org.javacord.api.interaction.SlashCommandOptionType.SUB_COMMAND, sub.name(), sub.description(), convertedOptions);
+        return org.javacord.api.interaction.SlashCommandOption.createWithOptions(
+            org.javacord.api.interaction.SlashCommandOptionType.SUB_COMMAND, 
+            sub.name(), 
+            sub.description(), 
+            convertedOptions);
    }

    private org.javacord.api.interaction.SlashCommandOption convertOptionDef(SlashCommandOption option) {
-        org.javacord.api.interaction.SlashCommandOptionType type = Enum.valueOf(org.javacord.api.interaction.SlashCommandOptionType.class, option.type().toString());
-        return org.javacord.api.interaction.SlashCommandOption.create(type, option.name(), option.description(), option.required());
+        SlashCommandOptionType type = SlashCommandOptionType.fromValue(option.type().getValue());
+        SlashCommandOptionBuilder builder = new SlashCommandOptionBuilder();
+        builder
+            .setType(type)
+            .setName(option.name())
+            .setDescription(option.description())
+            .setRequired(option.required())
+            .setAutocompletable(option.autocomplete())
+            .setChoices(convertChoices(option));
+        
+        return builder.build();
    }

-    private Object getOptionValue(SlashCommandInteractionOption option, SlashCommandOptionType type) {
-        switch (type) {
-            case ATTACHMENT:
-                return option.getAttachmentValue().get();
-            case BOOLEAN:
-                return option.getBooleanValue().get();
-            case CHANNEL:
-                return option.getChannelValue().get();
-            case DECIMAL:
-                return option.getDecimalValue().get();
-            case LONG:
-                return option.getLongValue().get();
-            case MENTIONABLE:
-                return option.getMentionableValue().get();
-            case ROLE:
-                return option.getRoleValue().get();
-            case STRING:
-                return option.getStringValue().get();
-            case USER:
-                return option.getUserValue().get();
-            default:
-                return null;
+    private List<org.javacord.api.interaction.SlashCommandOptionChoice> convertChoices(SlashCommandOption option) {
+        List<org.javacord.api.interaction.SlashCommandOptionChoice> convertedChoices = new ArrayList<>();
+        for (SlashCommandOptionChoice choice : ExecutableSlashCommandDefinition.getActualChoices(option)) {
+            SlashCommandOptionChoiceBuilder builder = new SlashCommandOptionChoiceBuilder();
+            builder.setName(choice.name());
+            if (choice.longValue() != Long.MAX_VALUE)
+                builder.setValue(choice.longValue());
+            /*
+            not yet available
+            if (choice.doubleValue() != Double.MAX_VALUE)
+                builder.setValue(choice.doubleValue());
+            */
+            if (!choice.stringValue().isEmpty())
+                builder.setValue(choice.stringValue());
        }
+        return convertedChoices;
    }

    @Override
@@ -174,20 +176,8 @@ public class JavacordWrapper extends LibraryWrapper {
    }

    @Override
-    public Object getComponentContextObject(Object context, Class<?> type) {
-        ButtonInteraction button = (ButtonInteraction) context;
-        switch (type.getName()) {
-            case "org.javacord.api.entity.channel.TextChannel":
-                return button.getChannel().orElse(null);
-            case "org.javacord.api.entity.message.Message":
-                return button.getMessage();
-            case "org.javacord.api.entity.server.Server":
-                return button.getServer().orElse(null);
-            case "org.javacord.api.entity.user.User":
-                return button.getUser();
-        }
-        return null;
+    public ContextObjectProvider getContextObjectProvider() {
+        return contextObjectProvider;
    }

-    
 }
--- a/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/AutoCompleteTest.java
+++ b/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/AutoCompleteTest.java
@@ -0,0 +1,23 @@
+package net.tomatentum.marinara.test;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+import net.tomatentum.marinara.Marinara;
+import net.tomatentum.marinara.test.mocks.AutocompleteInteractionMock;
+import net.tomatentum.marinara.test.mocks.DiscordApiMock;
+import net.tomatentum.marinara.wrapper.LibraryWrapper;
+import net.tomatentum.marinara.wrapper.javacord.JavacordWrapper;
+
+public class AutoCompleteTest {
+    
+    @Test
+    public void testAutocomplete() {
+        LibraryWrapper wrapper = new JavacordWrapper(new DiscordApiMock()); //null okay as we don't use the discord API in this test.
+        Marinara marinara = Marinara.load(wrapper);
+        marinara.getRegistry().addInteractions(new TestAutocomplete());
+        wrapper.handleInteraction(new AutocompleteInteractionMock());
+        assertTrue(AutocompleteInteractionMock.didAutocompleteRun);
+    }
+}
--- a/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/TestAutocomplete.java
+++ b/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/TestAutocomplete.java
@@ -0,0 +1,23 @@
+package net.tomatentum.marinara.test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.Collections;
+
+import org.javacord.api.interaction.AutocompleteInteraction;
+
+import net.tomatentum.marinara.interaction.InteractionHandler;
+import net.tomatentum.marinara.interaction.annotation.AutoComplete;
+import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand;
+
+public class TestAutocomplete implements InteractionHandler {
+    
+    @SlashCommand(name = "test")
+    @AutoComplete
+    public void autocomplete(AutocompleteInteraction context, String value) {
+        System.out.println("Success!");
+        assertEquals(value, "test");
+        context.respondWithChoices(Collections.emptyList());
+    }
+
+}
--- a/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/TestChoiceEnum.java
+++ b/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/TestChoiceEnum.java
@@ -0,0 +1,20 @@
+package net.tomatentum.marinara.test;
+
+import net.tomatentum.marinara.interaction.commands.ChoiceValueProvider;
+
+public enum TestChoiceEnum implements ChoiceValueProvider<String> {
+    TestValue("testValue"),
+    FooBar("fooBar"),
+    Spongebob("spongebob");
+
+    private String value;
+
+    private TestChoiceEnum(String value) {
+        this.value = value;
+    }
+    @Override
+    public String getChoiceValue() {
+        return value;
+    }
+    
+}
--- a/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/TestCommand.java
+++ b/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/TestCommand.java
@@ -20,7 +20,8 @@ public class TestCommand implements InteractionHandler {
            @SlashCommandOption(
                name = "foo",
                description = "foo bar is very fooby",
-                type = SlashCommandOptionType.STRING
+                type = SlashCommandOptionType.STRING,
+                choiceEnum = TestChoiceEnum.class
            )
        }
        )
--- a/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/mocks/AutocompleteInteractionMock.java
+++ b/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/mocks/AutocompleteInteractionMock.java
@@ -0,0 +1,179 @@
+package net.tomatentum.marinara.test.mocks;
+
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+
+import org.javacord.api.DiscordApi;
+import org.javacord.api.entity.channel.TextChannel;
+import org.javacord.api.entity.message.component.HighLevelComponent;
+import org.javacord.api.entity.permission.PermissionType;
+import org.javacord.api.entity.server.Server;
+import org.javacord.api.entity.user.User;
+import org.javacord.api.interaction.AutocompleteInteraction;
+import org.javacord.api.interaction.DiscordLocale;
+import org.javacord.api.interaction.InteractionType;
+import org.javacord.api.interaction.SlashCommandInteractionOption;
+import org.javacord.api.interaction.SlashCommandOptionChoice;
+import org.javacord.api.interaction.callback.InteractionFollowupMessageBuilder;
+import org.javacord.api.interaction.callback.InteractionImmediateResponseBuilder;
+import org.javacord.api.interaction.callback.InteractionOriginalResponseUpdater;
+
+public class AutocompleteInteractionMock implements AutocompleteInteraction {
+
+    public static boolean didAutocompleteRun = false;
+
+    @Override
+    public String getFullCommandName() {
+        return "test";
+    }
+
+    @Override
+    public long getCommandId() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getCommandId'");
+    }
+
+    @Override
+    public String getCommandIdAsString() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getCommandIdAsString'");
+    }
+
+    @Override
+    public String getCommandName() {
+        return "test";
+    }
+
+    @Override
+    public Optional<Long> getRegisteredCommandServerId() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getRegisteredCommandServerId'");
+    }
+
+    @Override
+    public long getApplicationId() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getApplicationId'");
+    }
+
+    @Override
+    public InteractionType getType() {
+        return InteractionType.APPLICATION_COMMAND_AUTOCOMPLETE;
+    }
+
+    @Override
+    public InteractionImmediateResponseBuilder createImmediateResponder() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'createImmediateResponder'");
+    }
+
+    @Override
+    public CompletableFuture<InteractionOriginalResponseUpdater> respondLater() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'respondLater'");
+    }
+
+    @Override
+    public CompletableFuture<InteractionOriginalResponseUpdater> respondLater(boolean ephemeral) {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'respondLater'");
+    }
+
+    @Override
+    public CompletableFuture<Void> respondWithModal(String customId, String title,
+            List<HighLevelComponent> components) {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'respondWithModal'");
+    }
+
+    @Override
+    public InteractionFollowupMessageBuilder createFollowupMessageBuilder() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'createFollowupMessageBuilder'");
+    }
+
+    @Override
+    public Optional<Server> getServer() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getServer'");
+    }
+
+    @Override
+    public Optional<TextChannel> getChannel() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getChannel'");
+    }
+
+    @Override
+    public User getUser() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getUser'");
+    }
+
+    @Override
+    public String getToken() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getToken'");
+    }
+
+    @Override
+    public int getVersion() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getVersion'");
+    }
+
+    @Override
+    public DiscordLocale getLocale() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getLocale'");
+    }
+
+    @Override
+    public Optional<DiscordLocale> getServerLocale() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getServerLocale'");
+    }
+
+    @Override
+    public Optional<EnumSet<PermissionType>> getBotPermissions() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getBotPermissions'");
+    }
+
+    @Override
+    public DiscordApi getApi() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getApi'");
+    }
+
+    @Override
+    public long getId() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getId'");
+    }
+
+    @Override
+    public List<SlashCommandInteractionOption> getOptions() {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public List<SlashCommandInteractionOption> getArguments() {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public CompletableFuture<Void> respondWithChoices(List<SlashCommandOptionChoice> choices) {
+        didAutocompleteRun = true;
+        return CompletableFuture.completedFuture(null);
+    }
+
+    @Override
+    public SlashCommandInteractionOption getFocusedOption() {
+        return new SlashCommandInteractionOptionMock();
+    }
+    
+}
--- a/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/mocks/SlashCommandInteractionOptionMock.java
+++ b/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/mocks/SlashCommandInteractionOptionMock.java
@@ -41,52 +41,52 @@ public class SlashCommandInteractionOptionMock implements SlashCommandInteractio

    @Override
    public Optional<Long> getLongValue() {
-        throw new UnsupportedOperationException("Unimplemented method 'getLongValue'");
+        return Optional.empty();
    }

    @Override
    public Optional<Boolean> getBooleanValue() {
-        throw new UnsupportedOperationException("Unimplemented method 'getBooleanValue'");
+        return Optional.empty();
    }

    @Override
    public Optional<User> getUserValue() {
-        throw new UnsupportedOperationException("Unimplemented method 'getUserValue'");
+        return Optional.empty();
    }

    @Override
    public Optional<CompletableFuture<User>> requestUserValue() {
-        throw new UnsupportedOperationException("Unimplemented method 'requestUserValue'");
+        return Optional.empty();
    }

    @Override
    public Optional<ServerChannel> getChannelValue() {
-        throw new UnsupportedOperationException("Unimplemented method 'getChannelValue'");
+        return Optional.empty();
    }

    @Override
    public Optional<Attachment> getAttachmentValue() {
-        throw new UnsupportedOperationException("Unimplemented method 'getAttachmentValue'");
+        return Optional.empty();
    }

    @Override
    public Optional<Role> getRoleValue() {
-        throw new UnsupportedOperationException("Unimplemented method 'getRoleValue'");
+        return Optional.empty();
    }

    @Override
    public Optional<Mentionable> getMentionableValue() {
-        throw new UnsupportedOperationException("Unimplemented method 'getMentionableValue'");
+        return Optional.empty();
    }

    @Override
    public Optional<Double> getDecimalValue() {
-        throw new UnsupportedOperationException("Unimplemented method 'getDecimalValue'");
+        return Optional.empty();
    }

    @Override
    public Optional<CompletableFuture<Mentionable>> requestMentionableValue() {
-        throw new UnsupportedOperationException("Unimplemented method 'requestMentionableValue'");
+        return Optional.empty();
    }

    @Override