multification/multification-core/src/com/eternalcode/multification/Multification.java at 596f580fa0615f9d5c0ec46aec45b575499327ba · EternalCodeTeam/multification · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
package com.eternalcode.multification;

import com.eternalcode.multification.adventure.PlainComponentSerializer;
import com.eternalcode.multification.locate.LocaleProvider;
import com.eternalcode.multification.notice.resolver.NoticeResolverDefaults;
import com.eternalcode.multification.notice.resolver.NoticeResolverRegistry;
import com.eternalcode.multification.platform.PlatformBroadcaster;
import com.eternalcode.multification.translation.TranslationProvider;
import com.eternalcode.multification.viewer.ViewerProvider;
import com.eternalcode.multification.adventure.AudienceConverter;
import com.eternalcode.multification.executor.AsyncExecutor;
import com.eternalcode.multification.notice.Notice;
import com.eternalcode.multification.notice.NoticeBroadcast;
import com.eternalcode.multification.notice.NoticeBroadcastImpl;
import com.eternalcode.multification.notice.provider.NoticeProvider;
import com.eternalcode.multification.shared.Formatter;
import com.eternalcode.multification.shared.Replacer;
import java.util.Locale;
import java.util.UUID;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.serializer.ComponentSerializer;
import org.jetbrains.annotations.ApiStatus;
import org.jetbrains.annotations.CheckReturnValue;
import org.jetbrains.annotations.NotNull;

public abstract class Multification<VIEWER, TRANSLATION> {

    public static final ComponentSerializer<Component, Component, String> DEFAULT_COMPONENT_SERIALIZER = new PlainComponentSerializer();
    public static final AsyncExecutor DEFAULT_EXECUTOR = runnable -> runnable.run();
    public static final Replacer<?> DEFAULT_REPLACER = (v, text) -> text;
    public static final LocaleProvider<?> LOCALE_PROVIDER = v -> Locale.ROOT;

    protected final NoticeResolverRegistry noticeRegistry = NoticeResolverDefaults.createRegistry();

    @CheckReturnValue
    public NoticeBroadcast<VIEWER, TRANSLATION, ?> create() {
        return new NoticeBroadcastImpl<>(
            this.asyncExecutor(),
            this.translationProvider(),
            this.viewerProvider(),
            this.platformBroadcaster(),
            this.localeProvider(),
            this.audienceConverter(),
            this.globalReplacer(),
            noticeRegistry
        );
    }

    @NotNull
    protected abstract ViewerProvider<VIEWER> viewerProvider();

    @NotNull
    protected abstract TranslationProvider<TRANSLATION> translationProvider();

    @NotNull
    protected abstract AudienceConverter<VIEWER> audienceConverter();

    /**
     * @deprecated Use {@link #serializer()} instead to configure serializer or use {@link #getNoticeRegistry()} to configure notice resolvers.
     */
    @ApiStatus.Internal
    @ApiStatus.NonExtendable
    protected PlatformBroadcaster platformBroadcaster() {
        return PlatformBroadcaster.create(serializer(), noticeRegistry);
    }

    @NotNull
    protected ComponentSerializer<Component, Component, String> serializer() {
        return DEFAULT_COMPONENT_SERIALIZER;
    }

    @SuppressWarnings("unchecked")
    @NotNull
    protected Replacer<VIEWER> globalReplacer() {
        return (Replacer<VIEWER>) DEFAULT_REPLACER;
    }

    @NotNull
    protected AsyncExecutor asyncExecutor() {
        return DEFAULT_EXECUTOR;
    }

    @SuppressWarnings("unchecked")
    @NotNull
    protected LocaleProvider<VIEWER> localeProvider() {
        return (LocaleProvider<VIEWER>) LOCALE_PROVIDER;
    }

    public void player(UUID player, NoticeProvider<TRANSLATION> extractor, Formatter... formatters) {
        this.create()
            .player(player)
            .notice(extractor)
            .formatter(formatters)
            .send();
    }

    public void players(Iterable<UUID> players, NoticeProvider<TRANSLATION> extractor, Formatter... formatters) {
        this.create()
            .players(players)
            .notice(extractor)
            .formatter(formatters)
            .send();
    }

    public void viewer(VIEWER viewer, NoticeProvider<TRANSLATION> extractor, Formatter... formatters) {
        this.create()
            .viewer(viewer)
            .notice(extractor)
            .formatter(formatters)
            .send();
    }


    public void console(NoticeProvider<TRANSLATION> extractor, Formatter... formatters) {
        this.create()
            .console()
            .notice(extractor)
            .formatter(formatters)
            .send();
    }

    public void all(NoticeProvider<TRANSLATION> extractor, Formatter... formatters) {
        this.create()
            .all()
            .notice(extractor)
            .formatter(formatters)
            .send();
    }

    public String serialize(Notice notice) {
        return notice.serialize(this.noticeRegistry);
    }

    public Notice deserialize(String raw) {
        return Notice.deserialize(raw, this.noticeRegistry);
    }

    @ApiStatus.Internal
    public NoticeResolverRegistry getNoticeRegistry() {
        return noticeRegistry;
    }

}