baritone.api.command.argument

Interface IArgConsumer

public interface IArgConsumer

The IArgConsumer is how ICommands read the arguments passed to them. This class has many benefits:

• Mutability. The whole concept of the IArgConsumer} is to let you gradually consume arguments in any way you'd like. You can change your consumption based on earlier arguments, for subcommands for example.
• You don't need to keep track of your consumption. The IArgConsumer} keeps track of the arguments you consume so that it can throw detailed exceptions whenever something is out of the ordinary. Additionally, if you need to retrieve an argument after you've already consumed it - look no further than consumed()!
• Easy retrieval of many different types. If you need to retrieve an instance of an int or float for example, look no further than getAs(Class). If you need a more powerful way of retrieving data, try out the many getDatatype... methods.
• It's very easy to throw detailed exceptions. The IArgConsumer} has many different methods that can enforce the number of arguments, the type of arguments, and more, throwing different types of CommandExceptions if something seems off. You're recommended to do all validation and store all needed data in variables BEFORE logging any data to chat via Helper.logDirect(String), so that the error handlers can do their job and log the error to chat.

Method Summary

Modifier and Type	Method and Description
ICommandArgument	consumed()
java.lang.String	consumedString()
IArgConsumer	copy()
ICommandArgument	get() Gets the next argument and returns it.
java.util.LinkedList<ICommandArgument>	getArgs()
<T> T	getAs(java.lang.Class<T> type) Tries to use a stateless IArgParser to parse the next argument into the specified class
<T> T	getAsOrDefault(java.lang.Class<T> type, T def) Tries to use a stateless IArgParser to parse the next argument into the specified class
<T> T	getAsOrNull(java.lang.Class<T> type) Tries to use a stateless IArgParser to parse the next argument into the specified class
java.util.Deque<ICommandArgument>	getConsumed()
<T,D extends IDatatypeFor<T>> T	getDatatypeFor(D datatype)
<T,D extends IDatatypeFor<T>> T	getDatatypeForOrDefault(D datatype, T def)
<T,D extends IDatatypeFor<T>> T	getDatatypeForOrNull(D datatype)
<T,O,D extends IDatatypePost<T,O>> T	getDatatypePost(D datatype, O original)
<T,O,D extends IDatatypePost<T,O>> T	getDatatypePostOrDefault(D datatype, O original, T _default)
<T,O,D extends IDatatypePost<T,O>> T	getDatatypePostOrNull(D datatype, O original)
<E extends java.lang.Enum<?>> E	getEnum(java.lang.Class<E> enumClass) Gets an enum value from the enum class with the same name as the next argument's value
<E extends java.lang.Enum<?>> E	getEnumOrDefault(java.lang.Class<E> enumClass, E def) Gets an enum value from the enum class with the same name as the next argument's value
<E extends java.lang.Enum<?>> E	getEnumOrNull(java.lang.Class<E> enumClass) Gets an enum value from the enum class with the same name as the next argument's value
java.lang.String	getString() Gets the value of the next argument and returns it.
boolean	has(int num)
boolean	hasAny()
boolean	hasAtMost(int num)
boolean	hasAtMostOne()
boolean	hasConsumed()
boolean	hasExactly(int num)
boolean	hasExactlyOne()
boolean	is(java.lang.Class<?> type)
boolean	is(java.lang.Class<?> type, int index)
ICommandArgument	peek()
ICommandArgument	peek(int index)
<T> T	peekAs(java.lang.Class<T> type) Tries to use a stateless IArgParser to parse the next argument into the specified class
<T> T	peekAs(java.lang.Class<T> type, int index) Tries to use a stateless IArgParser to parse the argument at the specified index into the specified class
<T> T	peekAsOrDefault(java.lang.Class<T> type, T def) Tries to use a stateless IArgParser to parse the next argument into the specified class
<T> T	peekAsOrDefault(java.lang.Class<T> type, T def, int index) Tries to use a stateless IArgParser to parse the argument at the specified index into the specified class
<T> T	peekAsOrNull(java.lang.Class<T> type) Tries to use a stateless IArgParser to parse the next argument into the specified class
<T> T	peekAsOrNull(java.lang.Class<T> type, int index) Tries to use a stateless IArgParser to parse the argument at the specified index into the specified class
<T> T	peekDatatype(IDatatypeFor<T> datatype)
<T,O> T	peekDatatype(IDatatypePost<T,O> datatype)
<T,O> T	peekDatatype(IDatatypePost<T,O> datatype, O original)
<T,D extends IDatatypeFor<T>> T	peekDatatypeFor(java.lang.Class<D> datatype) Attempts to get the specified IDatatypeFor from this ArgConsumer
<T,D extends IDatatypeFor<T>> T	peekDatatypeForOrDefault(java.lang.Class<D> datatype, T def) Attempts to get the specified IDatatypeFor from this ArgConsumer
<T,D extends IDatatypeFor<T>> T	peekDatatypeForOrNull(java.lang.Class<D> datatype) Attempts to get the specified IDatatypeFor from this ArgConsumer
<T> T	peekDatatypeOrNull(IDatatypeFor<T> datatype)
<T,O> T	peekDatatypeOrNull(IDatatypePost<T,O> datatype)
<T,O,D extends IDatatypePost<T,O>> T	peekDatatypePost(D datatype, O original)
<T,O,D extends IDatatypePost<T,O>> T	peekDatatypePostOrDefault(D datatype, O original, T def)
<T,O,D extends IDatatypePost<T,O>> T	peekDatatypePostOrNull(D datatype, O original)
<E extends java.lang.Enum<?>> E	peekEnum(java.lang.Class<E> enumClass)
<E extends java.lang.Enum<?>> E	peekEnum(java.lang.Class<E> enumClass, int index)
<E extends java.lang.Enum<?>> E	peekEnumOrNull(java.lang.Class<E> enumClass)
<E extends java.lang.Enum<?>> E	peekEnumOrNull(java.lang.Class<E> enumClass, int index)
java.lang.String	peekString()
java.lang.String	peekString(int index)
java.lang.String	rawRest() Returns the "raw rest" of the string.
void	requireExactly(int args)
void	requireMax(int max)
void	requireMin(int min)
<T extends IDatatype> java.util.stream.Stream<java.lang.String>	tabCompleteDatatype(T datatype)

Method Detail

getArgs

java.util.LinkedList<ICommandArgument> getArgs()

getConsumed

java.util.Deque<ICommandArgument> getConsumed()

has

boolean has(int num)

Parameters:

num - The number of arguments to check for

Returns:

true if there are at least num arguments left in this IArgConsumer}

See Also:

hasAny(), hasAtMost(int), hasExactly(int)

hasAny

boolean hasAny()

Returns:

true if there is at least 1 argument left in this IArgConsumer}

See Also:

has(int), hasAtMostOne(), hasExactlyOne()

hasAtMost

boolean hasAtMost(int num)

Parameters:

num - The number of arguments to check for

Returns:

true if there are at most num arguments left in this IArgConsumer}

See Also:

has(int), hasAtMost(int), hasExactly(int)

hasAtMostOne

boolean hasAtMostOne()

Returns:

true if there is at most 1 argument left in this IArgConsumer}

See Also:

hasAny(), hasAtMostOne(), hasExactlyOne()

hasExactly

boolean hasExactly(int num)

Parameters:

num - The number of arguments to check for

Returns:

true if there are exactly num arguments left in this IArgConsumer}

See Also:

has(int), hasAtMost(int)

hasExactlyOne

boolean hasExactlyOne()

Returns:

true if there is exactly 1 argument left in this IArgConsumer}

See Also:

hasAny(), hasAtMostOne()

peek

ICommandArgument peek(int index)
               throws CommandNotEnoughArgumentsException

Parameters:

index - The index to peek

Returns:

The argument at index index in this IArgConsumer}, with 0 being the next one. This does not mutate the IArgConsumer}

Throws:

CommandNotEnoughArgumentsException - If there is less than index + 1 arguments left

See Also:

peek(), peekString(int), peekAs(Class, int), get()

peek

ICommandArgument peek()
               throws CommandNotEnoughArgumentsException

Returns:

The next argument in this IArgConsumer}. This does not mutate the IArgConsumer}

Throws:

CommandNotEnoughArgumentsException - If there is less than one argument left

See Also:

peek(int), peekString(), peekAs(Class), get()

is

boolean is(java.lang.Class<?> type,
           int index)
    throws CommandNotEnoughArgumentsException

Parameters:

index - The index to peek

type - The type to check for

Returns:

If an ArgParser.Stateless for the specified type would succeed in parsing the next argument

Throws:

CommandNotEnoughArgumentsException - If there is less than index + 1 arguments left

See Also:

peek(), getAs(Class)

is

boolean is(java.lang.Class<?> type)
    throws CommandNotEnoughArgumentsException

Parameters:

type - The type to check for

Returns:

If an ArgParser.Stateless for the specified type would succeed in parsing the next argument

Throws:

CommandNotEnoughArgumentsException - If there is less than one argument left

See Also:

peek(), getAs(Class)

peekString

java.lang.String peekString(int index)
                     throws CommandNotEnoughArgumentsException

Parameters:

index - The index to peek

Returns:

The value of the argument at index index in this IArgConsumer}, with 0 being the next one This does not mutate the IArgConsumer}

Throws:

CommandNotEnoughArgumentsException - If there is less than index + 1 arguments left

See Also:

peek(), peekString()

peekString

java.lang.String peekString()
                     throws CommandNotEnoughArgumentsException

Returns:

The value of the next argument in this IArgConsumer}. This does not mutate the IArgConsumer}

Throws:

CommandNotEnoughArgumentsException - If there is less than one argument left

See Also:

peekString(int), getString()

peekEnum

<E extends java.lang.Enum<?>> E peekEnum(java.lang.Class<E> enumClass,
                                         int index)
                                  throws CommandInvalidTypeException,
                                         CommandNotEnoughArgumentsException

Parameters:

index - The index to peek

enumClass - The class to search

Returns:

From the specified enum class, an enum constant of that class. The enum constant's name will match the next argument's value

Throws:

java.util.NoSuchElementException - If the constant couldn't be found

CommandInvalidTypeException

CommandNotEnoughArgumentsException

See Also:

peekEnumOrNull(Class), getEnum(Class), ICommandArgument.getEnum(Class)

peekEnum

<E extends java.lang.Enum<?>> E peekEnum(java.lang.Class<E> enumClass)
                                  throws CommandInvalidTypeException,
                                         CommandNotEnoughArgumentsException

Parameters:

enumClass - The class to search

Returns:

From the specified enum class, an enum constant of that class. The enum constant's name will match the next argument's value

Throws:

CommandInvalidTypeException - If the constant couldn't be found

CommandNotEnoughArgumentsException

See Also:

peekEnumOrNull(Class), getEnum(Class), ICommandArgument.getEnum(Class)

peekEnumOrNull

<E extends java.lang.Enum<?>> E peekEnumOrNull(java.lang.Class<E> enumClass,
                                               int index)
                                        throws CommandNotEnoughArgumentsException

Parameters:

index - The index to peek

enumClass - The class to search

Returns:

From the specified enum class, an enum constant of that class. The enum constant's name will match the next argument's value. If no constant could be found, null

Throws:

CommandNotEnoughArgumentsException

See Also:

peekEnum(Class), getEnumOrNull(Class), ICommandArgument.getEnum(Class)

peekEnumOrNull

<E extends java.lang.Enum<?>> E peekEnumOrNull(java.lang.Class<E> enumClass)
                                        throws CommandNotEnoughArgumentsException

Parameters:

enumClass - The class to search

Returns:

From the specified enum class, an enum constant of that class. The enum constant's name will match the next argument's value. If no constant could be found, null

Throws:

CommandNotEnoughArgumentsException

See Also:

peekEnum(Class), getEnumOrNull(Class), ICommandArgument.getEnum(Class)

peekAs

<T> T peekAs(java.lang.Class<T> type,
             int index)
      throws CommandInvalidTypeException,
             CommandNotEnoughArgumentsException

Tries to use a stateless IArgParser to parse the argument at the specified index into the specified class

A critical difference between IDatatypes and IArgParsers is how many arguments they can take. While IArgParsers always operate on a single argument's value, IDatatypes get access to the entire IArgConsumer}.

Parameters:

type - The type to peek as

index - The index to peek

Returns:

An instance of the specified type

Throws:

CommandInvalidTypeException - If the parsing failed

CommandNotEnoughArgumentsException

See Also:

IArgParser, peekAs(Class), peekAsOrDefault(Class, Object, int), peekAsOrNull(Class, int)

peekAs

<T> T peekAs(java.lang.Class<T> type)
      throws CommandInvalidTypeException,
             CommandNotEnoughArgumentsException

Tries to use a stateless IArgParser to parse the next argument into the specified class

A critical difference between IDatatypes and IArgParsers is how many arguments they can take. While IArgParsers always operate on a single argument's value, IDatatypes get access to the entire IArgConsumer}.

Parameters:

type - The type to peek as

Returns:

An instance of the specified type

Throws:

CommandInvalidTypeException - If the parsing failed

CommandNotEnoughArgumentsException

See Also:

IArgParser, peekAs(Class, int), peekAsOrDefault(Class, Object), peekAsOrNull(Class)

peekAsOrDefault

<T> T peekAsOrDefault(java.lang.Class<T> type,
                      T def,
                      int index)
               throws CommandNotEnoughArgumentsException

Tries to use a stateless IArgParser to parse the argument at the specified index into the specified class

A critical difference between IDatatypes and IArgParsers is how many arguments they can take. While IArgParsers always operate on a single argument's value, IDatatypes get access to the entire IArgConsumer}.

Parameters:

type - The type to peek as

def - The value to return if the argument can't be parsed

index - The index to peek

Returns:

An instance of the specified type, or def if it couldn't be parsed

Throws:

CommandNotEnoughArgumentsException

See Also:

IArgParser, peekAsOrDefault(Class, Object), peekAs(Class, int), peekAsOrNull(Class, int)

peekAsOrDefault

<T> T peekAsOrDefault(java.lang.Class<T> type,
                      T def)
               throws CommandNotEnoughArgumentsException

Tries to use a stateless IArgParser to parse the next argument into the specified class

A critical difference between IDatatypes and IArgParsers is how many arguments they can take. While IArgParsers always operate on a single argument's value, IDatatypes get access to the entire IArgConsumer}.

Parameters:

type - The type to peek as

def - The value to return if the argument can't be parsed

Returns:

An instance of the specified type, or def if it couldn't be parsed

Throws:

CommandNotEnoughArgumentsException

See Also:

IArgParser, peekAsOrDefault(Class, Object, int), peekAs(Class), peekAsOrNull(Class)

peekAsOrNull

<T> T peekAsOrNull(java.lang.Class<T> type,
                   int index)
            throws CommandNotEnoughArgumentsException

Tries to use a stateless IArgParser to parse the argument at the specified index into the specified class

A critical difference between IDatatypes and IArgParsers is how many arguments they can take. While IArgParsers always operate on a single argument's value, IDatatypes get access to the entire IArgConsumer}.

Parameters:

type - The type to peek as

index - The index to peek

Returns:

An instance of the specified type, or null if it couldn't be parsed

Throws:

CommandNotEnoughArgumentsException

See Also:

IArgParser, peekAsOrNull(Class), peekAs(Class, int), peekAsOrDefault(Class, Object, int)

peekAsOrNull

<T> T peekAsOrNull(java.lang.Class<T> type)
            throws CommandNotEnoughArgumentsException

Tries to use a stateless IArgParser to parse the next argument into the specified class

A critical difference between IDatatypes and IArgParsers is how many arguments they can take. While IArgParsers always operate on a single argument's value, IDatatypes get access to the entire IArgConsumer}.

Parameters:

type - The type to peek as

Returns:

An instance of the specified type, or null if it couldn't be parsed

Throws:

CommandNotEnoughArgumentsException

See Also:

IArgParser, peekAsOrNull(Class, int), peekAs(Class), peekAsOrDefault(Class, Object)

peekDatatype

<T> T peekDatatype(IDatatypeFor<T> datatype)
            throws CommandInvalidTypeException,
                   CommandNotEnoughArgumentsException

Throws:

CommandInvalidTypeException

CommandNotEnoughArgumentsException

peekDatatype

<T,O> T peekDatatype(IDatatypePost<T,O> datatype)
              throws CommandInvalidTypeException,
                     CommandNotEnoughArgumentsException

Throws:

CommandInvalidTypeException

CommandNotEnoughArgumentsException

peekDatatype

<T,O> T peekDatatype(IDatatypePost<T,O> datatype,
                     O original)
              throws CommandInvalidTypeException,
                     CommandNotEnoughArgumentsException

Throws:

CommandInvalidTypeException

CommandNotEnoughArgumentsException

peekDatatypeOrNull

<T> T peekDatatypeOrNull(IDatatypeFor<T> datatype)

peekDatatypeOrNull

<T,O> T peekDatatypeOrNull(IDatatypePost<T,O> datatype)

peekDatatypePost

<T,O,D extends IDatatypePost<T,O>> T peekDatatypePost(D datatype,
                                                      O original)
                                               throws CommandInvalidTypeException,
                                                      CommandNotEnoughArgumentsException

Throws:

CommandInvalidTypeException

CommandNotEnoughArgumentsException

peekDatatypePostOrDefault

<T,O,D extends IDatatypePost<T,O>> T peekDatatypePostOrDefault(D datatype,
                                                               O original,
                                                               T def)

peekDatatypePostOrNull

<T,O,D extends IDatatypePost<T,O>> T peekDatatypePostOrNull(D datatype,
                                                            O original)

peekDatatypeFor

<T,D extends IDatatypeFor<T>> T peekDatatypeFor(java.lang.Class<D> datatype)

Attempts to get the specified IDatatypeFor from this ArgConsumer

A critical difference between IDatatypes and IArgParsers is how many arguments they can take. While IArgParsers always operate on a single argument's value, IDatatypes get access to the entire IArgConsumer}.

Since this is a peek operation, this ArgConsumer will not be mutated by any call to this method.

Parameters:

datatype - The datatype to get

Returns:

The datatype instance

See Also:

IDatatype, IDatatypeFor

peekDatatypeForOrDefault

<T,D extends IDatatypeFor<T>> T peekDatatypeForOrDefault(java.lang.Class<D> datatype,
                                                         T def)

Attempts to get the specified IDatatypeFor from this ArgConsumer

A critical difference between IDatatypes and IArgParsers is how many arguments they can take. While IArgParsers always operate on a single argument's value, IDatatypes get access to the entire IArgConsumer}.

Since this is a peek operation, this ArgConsumer will not be mutated by any call to this method.

Parameters:

datatype - The datatype to get

def - The default value

Returns:

The datatype instance, or def if it throws an exception

See Also:

IDatatype, IDatatypeFor

peekDatatypeForOrNull

<T,D extends IDatatypeFor<T>> T peekDatatypeForOrNull(java.lang.Class<D> datatype)

Attempts to get the specified IDatatypeFor from this ArgConsumer

A critical difference between IDatatypes and IArgParsers is how many arguments they can take. While IArgParsers always operate on a single argument's value, IDatatypes get access to the entire IArgConsumer}.

Since this is a peek operation, this ArgConsumer will not be mutated by any call to this method.

Parameters:

datatype - The datatype to get

Returns:

The datatype instance, or null if it throws an exception

See Also:

IDatatype, IDatatypeFor

get

ICommandArgument get()
              throws CommandNotEnoughArgumentsException

Gets the next argument and returns it. This consumes the first argument so that subsequent calls will return later arguments

Returns:

The next argument

Throws:

CommandNotEnoughArgumentsException - If there's less than one argument left

getString

java.lang.String getString()
                    throws CommandNotEnoughArgumentsException

Gets the value of the next argument and returns it. This consumes the first argument so that subsequent calls will return later arguments

Returns:

The value of the next argument

Throws:

CommandNotEnoughArgumentsException - If there's less than one argument left

getEnum

<E extends java.lang.Enum<?>> E getEnum(java.lang.Class<E> enumClass)
                                 throws CommandInvalidTypeException,
                                        CommandNotEnoughArgumentsException

Gets an enum value from the enum class with the same name as the next argument's value

For example if you getEnum as an EnumFacing, and the next argument's value is "up", this will return EnumFacing.UP

Parameters:

enumClass - The enum class to search

Returns:

An enum constant of that class with the same name as the next argument's value

Throws:

CommandInvalidTypeException - If the constant couldn't be found

CommandNotEnoughArgumentsException

See Also:

peekEnum(Class), getEnumOrNull(Class), ICommandArgument.getEnum(Class)

getEnumOrDefault

<E extends java.lang.Enum<?>> E getEnumOrDefault(java.lang.Class<E> enumClass,
                                                 E def)
                                          throws CommandNotEnoughArgumentsException

Gets an enum value from the enum class with the same name as the next argument's value

For example if you getEnum as an EnumFacing, and the next argument's value is "up", this will return EnumFacing.UP

Parameters:

enumClass - The enum class to search

def - The default value

Returns:

An enum constant of that class with the same name as the next argument's value, or def if it couldn't be found

Throws:

CommandNotEnoughArgumentsException

See Also:

getEnum(Class), getEnumOrNull(Class), peekEnumOrNull(Class), ICommandArgument.getEnum(Class)

getEnumOrNull

<E extends java.lang.Enum<?>> E getEnumOrNull(java.lang.Class<E> enumClass)
                                       throws CommandNotEnoughArgumentsException

Gets an enum value from the enum class with the same name as the next argument's value

For example if you getEnum as an EnumFacing, and the next argument's value is "up", this will return EnumFacing.UP

Parameters:

enumClass - The enum class to search

Returns:

An enum constant of that class with the same name as the next argument's value, or null if it couldn't be found

Throws:

CommandNotEnoughArgumentsException

See Also:

getEnum(Class), getEnumOrDefault(Class, Enum), peekEnumOrNull(Class), ICommandArgument.getEnum(Class)

getAs

<T> T getAs(java.lang.Class<T> type)
     throws CommandInvalidTypeException,
            CommandNotEnoughArgumentsException

Tries to use a stateless IArgParser to parse the next argument into the specified class

A critical difference between IDatatypes and IArgParsers is how many arguments they can take. While IArgParsers always operate on a single argument's value, IDatatypes get access to the entire IArgConsumer}.

Parameters:

type - The type to peek as

Returns:

An instance of the specified type

Throws:

CommandInvalidTypeException - If the parsing failed

CommandNotEnoughArgumentsException

See Also:

IArgParser, get(), getAsOrDefault(Class, Object), getAsOrNull(Class), peekAs(Class), peekAsOrDefault(Class, Object, int), peekAsOrNull(Class, int)

getAsOrDefault

<T> T getAsOrDefault(java.lang.Class<T> type,
                     T def)
              throws CommandNotEnoughArgumentsException

Tries to use a stateless IArgParser to parse the next argument into the specified class

A critical difference between IDatatypes and IArgParsers is how many arguments they can take. While IArgParsers always operate on a single argument's value, IDatatypes get access to the entire IArgConsumer}.

Parameters:

type - The type to peek as

def - The default value

Returns:

An instance of the specified type, or def if it couldn't be parsed

Throws:

CommandNotEnoughArgumentsException

See Also:

IArgParser, get(), getAs(Class), getAsOrNull(Class), peekAs(Class), peekAsOrDefault(Class, Object, int), peekAsOrNull(Class, int)

getAsOrNull

<T> T getAsOrNull(java.lang.Class<T> type)
           throws CommandNotEnoughArgumentsException

Tries to use a stateless IArgParser to parse the next argument into the specified class

A critical difference between IDatatypes and IArgParsers is how many arguments they can take. While IArgParsers always operate on a single argument's value, IDatatypes get access to the entire IArgConsumer}.

Parameters:

type - The type to peek as

Returns:

An instance of the specified type, or null if it couldn't be parsed

Throws:

CommandNotEnoughArgumentsException

See Also:

IArgParser, get(), getAs(Class), getAsOrDefault(Class, Object), peekAs(Class), peekAsOrDefault(Class, Object, int), peekAsOrNull(Class, int)

getDatatypePost

<T,O,D extends IDatatypePost<T,O>> T getDatatypePost(D datatype,
                                                     O original)
                                              throws CommandInvalidTypeException,
                                                     CommandNotEnoughArgumentsException

Throws:

CommandInvalidTypeException

CommandNotEnoughArgumentsException

getDatatypePostOrDefault

<T,O,D extends IDatatypePost<T,O>> T getDatatypePostOrDefault(D datatype,
                                                              O original,
                                                              T _default)

getDatatypePostOrNull

<T,O,D extends IDatatypePost<T,O>> T getDatatypePostOrNull(D datatype,
                                                           O original)

getDatatypeFor

<T,D extends IDatatypeFor<T>> T getDatatypeFor(D datatype)
                                        throws CommandInvalidTypeException,
                                               CommandNotEnoughArgumentsException

Throws:

CommandInvalidTypeException

CommandNotEnoughArgumentsException

getDatatypeForOrDefault

<T,D extends IDatatypeFor<T>> T getDatatypeForOrDefault(D datatype,
                                                        T def)

getDatatypeForOrNull

<T,D extends IDatatypeFor<T>> T getDatatypeForOrNull(D datatype)

tabCompleteDatatype

<T extends IDatatype> java.util.stream.Stream<java.lang.String> tabCompleteDatatype(T datatype)

rawRest

java.lang.String rawRest()

Returns the "raw rest" of the string. For example, from a string arg1 arg2 arg3, split into three ICommandArguments "arg1", "arg2", and "arg3":

• rawRest() would return arg1 arg2 arg3
• After calling get(), rawRest() would return arg2 arg3 (note the double space - it is preserved!)
• After calling get() again, rawRest() would return "arg3"
• After calling get() one last time, rawRest() would return ""

Returns:

The "raw rest" of the string.

requireMin

void requireMin(int min)
         throws CommandNotEnoughArgumentsException

Parameters:

min - The minimum amount of arguments to require.

Throws:

CommandNotEnoughArgumentsException - If there are less than min arguments left.

See Also:

requireMax(int), requireExactly(int)

requireMax

void requireMax(int max)
         throws CommandTooManyArgumentsException

Parameters:

max - The maximum amount of arguments allowed.

Throws:

CommandTooManyArgumentsException - If there are more than max arguments left.

See Also:

requireMin(int), requireExactly(int)

requireExactly

void requireExactly(int args)
             throws CommandException

Parameters:

args - The exact amount of arguments to require.

Throws:

CommandNotEnoughArgumentsException - If there are less than args arguments left.

CommandTooManyArgumentsException - If there are more than args arguments left.

CommandException

See Also:

requireMin(int), requireMax(int)

hasConsumed

boolean hasConsumed()

Returns:

If this IArgConsumer} has consumed at least one argument.

See Also:

consumed(), consumedString()

consumed

ICommandArgument consumed()

Returns:

The last argument this IArgConsumer} has consumed, or an "unknown" argument, indicated by a comamnd argument index that has a value of -1, if no arguments have been consumed yet.

See Also:

consumedString(), hasConsumed()

consumedString

java.lang.String consumedString()

Returns:

The value of thelast argument this IArgConsumer} has consumed, or an empty string if no arguments have been consumed yet

See Also:

consumed(), hasConsumed()

copy

IArgConsumer copy()

Returns:

A copy of this IArgConsumer}. It has the same arguments (both consumed and not), but does not affect or mutate this instance. Useful for the various peek functions