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
144
145
146
147
148
149
150
151
152
|
package io.dico.dicore.command;
import io.dico.dicore.command.chat.IChatController;
import io.dico.dicore.command.parameter.ArgumentBuffer;
import io.dico.dicore.command.predef.PredefinedCommand;
import org.bukkit.command.CommandSender;
import java.util.List;
import java.util.Map;
/**
* Interface for an address of a command.
* <p>
* The address holds what the name and aliases of a command are.
* The address also (optionally) holds a reference to a {@link Command}
* <p>
* One instance of {@link Command} can be held by multiple addresses,
* because the address decides what the command's name and aliases are.
* <p>
* The address holds children by key in a map. This map's keys include aliases for its children.
* This creates a tree of addresses. If a command is dispatches, the tree is traversed untill a command is found
* and no children deeper down match the command (there are exceptions to the later as defined by
* {@link Command#takePrecedenceOverSubcommand(String, ArgumentBuffer)}
* and {@link Command#isVisibleTo(CommandSender)}
*/
public interface ICommandAddress {
/**
* @return true if this address has a parent.
*/
boolean hasParent();
/**
* Get the parent of this address
*
* @return the parent of this address, or null if none exists.
*/
ICommandAddress getParent();
/**
* @return true if this address has a command.
*/
boolean hasCommand();
/**
* @return true if this address has a command that is not an instance of {@link PredefinedCommand}
*/
boolean hasUserDeclaredCommand();
/**
* @return Get the command of this address, or null if none exists.
*/
Command getCommand();
/**
* @return true if this address is an instance of {@link RootCommandAddress}
*/
boolean isRoot();
/**
* @return the root address of the tree which this address resides in.
*/
ICommandAddress getRoot();
/**
* A list of the names of this address, at the current level.
* The first entry is the main key, the subsequent ones are aliases.
* <p>
* Untill an address is assigned a parent, this list is mutable.
* <p>
* If {@link #isRoot()}, this returns an immutable, empty list.
*
* @return the list of names.
*/
List<String> getNames();
/**
* A list of the aliases of this address. That is, {@link #getNames()}
* without the first entry.
*
* @return a list of aliases
*/
List<String> getAliases();
/**
* @return The first element of {@link #getNames()}
*/
String getMainKey();
/**
* Get the address of this command.
* That is, the main keys of all commands leading up to this address, and this address itself, separated by a space.
* In other words, the command without the / that is required to target the command at this address.
*
* @return the address of this command.
*/
String getAddress();
/**
* Get the amount of addresses that separate this address from the root of the tree, + 1.
* The root of the tree has a depth of 0. Each subsequent child has its depth incremented by 1.
*
* @return The depth of this address
*/
int getDepth();
/**
* @return true if the depth of this address is larger than the argument.
*/
boolean isDepthLargerThan(int depth);
/**
* Get an unmodifiable view of the children of this address.
* Values might be duplicated for aliases.
*
* @return the children of this address.
*/
Map<String, ? extends ICommandAddress> getChildren();
/**
* Query for a child at the given key.
*
* @param key the key. The name or alias of a command.
* @return the child, or null if it's not found
*/
ICommandAddress getChild(String key);
/**
* Get the command dispatcher for this tree
*
* @return the command dispatcher
*/
ICommandDispatcher getDispatcherForTree();
/**
* @return The desired chatcontroller for use by commands at this address and any sub-addresses, if they define no explicit chat controller.
*/
IChatController getChatController();
static ICommandAddress newChild() {
return new ChildCommandAddress();
}
static ICommandAddress newChild(Command command) {
return new ChildCommandAddress(command);
}
static ICommandAddress newRoot() {
return new RootCommandAddress();
}
}
|
