Index (trivial-chunk 2.15.0 API)

A B C D E F G H I L M N O P R S T U V W X
All Classes and Interfaces|All Packages|Constant Field Values|Serialized Form

A

AbstractBooleanSupplierKeyedMapLogic<TYPE_LOGIC,TYPE_OUTPUT> - Class in xyz.ronella.trivial.handy: The base class of the BooleanSupplierKeyedMapLogic implementations.
AbstractBooleanSupplierKeyedMapLogic(Map<BooleanSupplier, TYPE_LOGIC>, TYPE_LOGIC, Map.Entry<BooleanSupplier, TYPE_LOGIC>...) - Constructor for class xyz.ronella.trivial.handy.AbstractBooleanSupplierKeyedMapLogic: A standard way of creating an instance of AbstractBooleanSupplierKeyedMapLogic.
AbstractKeyedMapLogic<TYPE_KEY,TYPE_LOGIC,TYPE_OUTPUT> - Class in xyz.ronella.trivial.handy: The base class of the KeyedMapLogic implementations.
AbstractKeyedMapLogic(Map<TYPE_KEY, TYPE_LOGIC>, TYPE_LOGIC, List<Map.Entry<TYPE_KEY, TYPE_LOGIC>>) - Constructor for class xyz.ronella.trivial.handy.AbstractKeyedMapLogic: A standard way of creating an instance of AbstractKeyedMapLogic
AbstractLogical - Class in xyz.ronella.trivial.command.logic: A partial implementation of the logic command.
AbstractLogical(BooleanSupplier...) - Constructor for class xyz.ronella.trivial.command.logic.AbstractLogical: Creates an instance of AbstractLogical.
AbstractLogical(List<BooleanSupplier>) - Constructor for class xyz.ronella.trivial.command.logic.AbstractLogical: Creates an instance of AbstractLogical.
AbstractLogical(List<BooleanSupplier>, Sink) - Constructor for class xyz.ronella.trivial.command.logic.AbstractLogical: Creates an instance of AbstractLogical.
AbstractLogical(List<BooleanSupplier>, Sink, Sink) - Constructor for class xyz.ronella.trivial.command.logic.AbstractLogical: Creates an instance of AbstractLogical.
AbstractLogical(Sink, BooleanSupplier...) - Constructor for class xyz.ronella.trivial.command.logic.AbstractLogical: Creates an instance of AbstractLogical.
AbstractLogical(Sink, Sink, BooleanSupplier...) - Constructor for class xyz.ronella.trivial.command.logic.AbstractLogical: Creates an instance of AbstractLogical.
AbstractStringKeyedMapLogic<TYPE_LOGIC,TYPE_OUTPUT> - Class in xyz.ronella.trivial.handy: The base class of the StringKeyedMapLogic implementations.
AbstractStringKeyedMapLogic(Map<String, TYPE_LOGIC>, TYPE_LOGIC, Map.Entry<String, TYPE_LOGIC>...) - Constructor for class xyz.ronella.trivial.handy.AbstractStringKeyedMapLogic: Creates an instance of AbstractStringKeyedMapLogic
accept(Sink) - Method in class xyz.ronella.trivial.command.logic.AbstractLogical: The default implementation is just passing to the BiConsumer implementation.
accept(Sink, Sink) - Method in class xyz.ronella.trivial.command.logic.AbstractLogical: Calculates if the truthLogic or falseLogic must be executed.
add(int, Supplier<TYPE_ELEMENT>) - Method in class xyz.ronella.trivial.decorator.ListAdder: Add element to a specific index of the wrapped list.
add(int, TYPE_ELEMENT) - Method in class xyz.ronella.trivial.decorator.ListAdder: Add element to a specific index of the wrapped list.
add(BooleanSupplier, int, Supplier<TYPE_ELEMENT>) - Method in class xyz.ronella.trivial.decorator.ListAdder: Add element to a specific index of the wrapped list.
add(BooleanSupplier, int, TYPE_ELEMENT) - Method in class xyz.ronella.trivial.decorator.ListAdder: Add element to a specific index of the wrapped list.
add(BooleanSupplier, Supplier<TYPE_ELEMENT>) - Method in class xyz.ronella.trivial.decorator.ListAdder: Add element to a wrapped list.
add(BooleanSupplier, TYPE_ELEMENT) - Method in class xyz.ronella.trivial.decorator.ListAdder: Add element to a wrapped list.
add(Supplier<TYPE_ELEMENT>) - Method in class xyz.ronella.trivial.decorator.ListAdder: Add element to a wrapped list.
add(TYPE_ELEMENT) - Method in class xyz.ronella.trivial.decorator.ListAdder: Add element to a wrapped list.
addAll(int, Collection<? extends TYPE_ELEMENT>) - Method in class xyz.ronella.trivial.decorator.ListAdder: Add elements to a specified index of the wrapped list.
addAll(int, Supplier<Collection<? extends TYPE_ELEMENT>>) - Method in class xyz.ronella.trivial.decorator.ListAdder: Add elements to a specified index of the wrapped list.
addAll(Collection<? extends TYPE_ELEMENT>) - Method in class xyz.ronella.trivial.decorator.ListAdder: Add elements to a wrapped list.
addAll(BooleanSupplier, int, Collection<? extends TYPE_ELEMENT>) - Method in class xyz.ronella.trivial.decorator.ListAdder: Add elements to a specified index of the wrapped list.
addAll(BooleanSupplier, int, Supplier<Collection<? extends TYPE_ELEMENT>>) - Method in class xyz.ronella.trivial.decorator.ListAdder: Add elements to a specified index of the wrapped list.
addAll(BooleanSupplier, Collection<? extends TYPE_ELEMENT>) - Method in class xyz.ronella.trivial.decorator.ListAdder: Add elements to a wrapped list.
addAll(BooleanSupplier, Supplier<Collection<? extends TYPE_ELEMENT>>) - Method in class xyz.ronella.trivial.decorator.ListAdder: Add elements to a wrapped list.
addAll(Supplier<Collection<? extends TYPE_ELEMENT>>) - Method in class xyz.ronella.trivial.decorator.ListAdder: Add elements to a wrapped list.
addArg(String) - Method in class xyz.ronella.trivial.handy.impl.CommandArray.CommandArrayBuilder: Accepts the arguments of the command.
addArg(BooleanSupplier, String) - Method in class xyz.ronella.trivial.handy.impl.CommandArray.CommandArrayBuilder: Accepts the arguments of the command.
addArgs(Collection<String>) - Method in class xyz.ronella.trivial.handy.impl.CommandArray.CommandArrayBuilder: Accepts the arguments of the command.
addArgs(BooleanSupplier, Collection<String>) - Method in class xyz.ronella.trivial.handy.impl.CommandArray.CommandArrayBuilder: Accepts the arguments of the command.
addExpr(Function) - Method in class xyz.ronella.trivial.handy.NPESilencer.NPESilencerBuilder: Add an expression to be evaluated.
addExpr(Supplier) - Method in class xyz.ronella.trivial.handy.NPESilencer.NPESilencerBuilder: Add an expression to be evaluated.
addFinalLogic(Supplier<TYPE_OUTPUT>) - Method in class xyz.ronella.trivial.handy.LogicMapper.LogicMapperBuilder: The very last logic to execute after the last addLogic execution.
addInitialLogic(Sink) - Method in class xyz.ronella.trivial.handy.LogicMapper.LogicMapperBuilder: The very first logic to execute before the first addLogic execution.
addInlineLogic(Sink) - Method in class xyz.ronella.trivial.handy.LogicMapper.LogicMapperBuilder: Add a logic that will definitely added.
addLogic(BooleanSupplier, Sink) - Method in class xyz.ronella.trivial.handy.LogicMapper.LogicMapperBuilder: Add a logic to the collection.
addPArg(String) - Method in class xyz.ronella.trivial.handy.impl.CommandArray.CommandArrayBuilder: Accepts an argument of the program itself.
addPArg(BooleanSupplier, String) - Method in class xyz.ronella.trivial.handy.impl.CommandArray.CommandArrayBuilder: Accepts an argument of the program itself.
addPArgs(Collection<String>) - Method in class xyz.ronella.trivial.handy.impl.CommandArray.CommandArrayBuilder: Accepts the arguments of the program itself.
addPArgs(BooleanSupplier, Collection<String>) - Method in class xyz.ronella.trivial.handy.impl.CommandArray.CommandArrayBuilder: Accepts the arguments of the program itself.
addPaths(String...) - Method in class xyz.ronella.trivial.handy.PathFinder.PathFinderBuilder: Adds an array of directories where to find first existence of the filename.
addPaths(List<String>) - Method in class xyz.ronella.trivial.handy.PathFinder.PathFinderBuilder: Adds a list of directories where to find first existence of the filename.
addRoot(TYPE_ROOT_OBJECT) - Method in class xyz.ronella.trivial.handy.NPESilencer.NPESilencerBuilder: Add the root object of all the expressions.
addZArg(String) - Method in class xyz.ronella.trivial.handy.impl.CommandArray.CommandArrayBuilder: Accepts an argument that must be at the end of the command arguments.
addZArg(BooleanSupplier, String) - Method in class xyz.ronella.trivial.handy.impl.CommandArray.CommandArrayBuilder: Accepts an argument that must be at the end of the command arguments.
addZArgs(Collection<String>) - Method in class xyz.ronella.trivial.handy.impl.CommandArray.CommandArrayBuilder: Accepts the arguments that must be at the end of the command arguments.
addZArgs(BooleanSupplier, Collection<String>) - Method in class xyz.ronella.trivial.handy.impl.CommandArray.CommandArrayBuilder: Accepts the arguments that must be at the end of the command arguments.
all(Object, Object...) - Static method in class xyz.ronella.trivial.handy.Require: Deprecated.
Use the objects method instead.
and(List<BooleanSupplier>, Sink) - Static method in class xyz.ronella.trivial.handy.Conditions: Accepts multiple conditions if all conditions are true it will pass control to the truthLogic.
and(List<BooleanSupplier>, Sink, Sink) - Static method in class xyz.ronella.trivial.handy.Conditions: Accepts multiple conditions if all condition are true it will pass control to the truthLogic otherwise the falseLogic will take it.
append(String) - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: Perform a normal append without any pre-append or post-append logic.
append(String...) - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: Perform a normal append without any pre-append or post-append logic.
append(String, Consumer<StringBuilder>) - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: Perform an append operation with pre-append logic.
append(String, Consumer<StringBuilder>, Consumer<StringBuilder>) - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: Perform an append operation with pre-append and post-append logic.
append(BooleanSupplier, String) - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: Perform a normal append without any pre-append or post-append logic.
append(BooleanSupplier, String...) - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: Perform a normal append without any pre-append or post-append logic.
append(BooleanSupplier, String, Consumer<StringBuilder>) - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: Perform an append operation with pre-append logic.
append(BooleanSupplier, String, Consumer<StringBuilder>, Consumer<StringBuilder>) - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: Perform an append operation with pre-append and post-append logic.
append(BooleanSupplier, Consumer<StringBuilder>) - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: Ability to append using your own custom logic that this decorator cannot handle.
append(BooleanSupplier, Consumer<StringBuilder>, String...) - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: Perform an append operation with pre-append logic.
append(BooleanSupplier, Consumer<StringBuilder>, Consumer<StringBuilder>) - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: Ability to append using your own custom logic that this decorator cannot handle.
append(BooleanSupplier, Consumer<StringBuilder>, Consumer<StringBuilder>, String...) - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: Perform an append operation with pre-append and post-append logic.
append(BooleanSupplier, Consumer<StringBuilder>, Consumer<StringBuilder>, Consumer<StringBuilder>) - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: Ability to append using your own custom logic that this decorator cannot handle.
append(Consumer<StringBuilder>) - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: Ability to append using your own custom logic that this decorator cannot handle.
append(Consumer<StringBuilder>, String...) - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: Perform an append operation with pre-append logic.
append(Consumer<StringBuilder>, Consumer<StringBuilder>) - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: Ability to append using your own custom logic that this decorator cannot handle.
append(Consumer<StringBuilder>, Consumer<StringBuilder>, String...) - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: Perform an append operation with pre-append and post-append logic.
append(Consumer<StringBuilder>, Consumer<StringBuilder>, Consumer<StringBuilder>) - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: Ability to append using your own custom logic that this decorator cannot handle.

B

biConsumer() - Static method in class xyz.ronella.trivial.functional.NoOperation: An implementation of BiConsumer that does nothing.
biFunction() - Static method in class xyz.ronella.trivial.functional.NoOperation: An implementation of BiFunction that does nothing.
biFunction(R) - Static method in class xyz.ronella.trivial.functional.NoOperation: An implementation of BiFunction that does nothing but produce default output.
biFunctionArg1PassThru() - Static method in class xyz.ronella.trivial.functional.NoOperation: An implementation of BiFunction that does nothing and just return argument 1.
biFunctionArg2PassThru() - Static method in class xyz.ronella.trivial.functional.NoOperation: An implementation of BiFunction that does nothing and just return argument 2.
biPredicate(Boolean) - Static method in class xyz.ronella.trivial.functional.NoOperation: An implementation of Predicate that does nothing but must have a specific boolean output.
BooleanSupplierKeyedMapExecutor - Class in xyz.ronella.trivial.handy.impl: A convenience class for creating a map as an executor.
BooleanSupplierKeyedMapExecutor(Map.Entry<BooleanSupplier, Sink>...) - Constructor for class xyz.ronella.trivial.handy.impl.BooleanSupplierKeyedMapExecutor: Creates an instance of BooleanSupplierKeyedMapExecutor
BooleanSupplierKeyedMapExecutor(Map<BooleanSupplier, Sink>) - Constructor for class xyz.ronella.trivial.handy.impl.BooleanSupplierKeyedMapExecutor: Creates an instance of BooleanSupplierKeyedMapExecutor
BooleanSupplierKeyedMapExecutor(Map<BooleanSupplier, Sink>, Sink, Map.Entry<BooleanSupplier, Sink>...) - Constructor for class xyz.ronella.trivial.handy.impl.BooleanSupplierKeyedMapExecutor: Creates an instance of BooleanSupplierKeyedMapExecutor
BooleanSupplierKeyedMapExecutor(Sink, Map.Entry<BooleanSupplier, Sink>...) - Constructor for class xyz.ronella.trivial.handy.impl.BooleanSupplierKeyedMapExecutor: Creates an instance of BooleanSupplierKeyedMapExecutor
BooleanSupplierKeyedMapGenerator<TYPE_OUTPUT> - Class in xyz.ronella.trivial.handy.impl: A convenience class for creating a map as factory.
BooleanSupplierKeyedMapGenerator(Supplier<TYPE_OUTPUT>, Map.Entry<BooleanSupplier, Supplier<TYPE_OUTPUT>>...) - Constructor for class xyz.ronella.trivial.handy.impl.BooleanSupplierKeyedMapGenerator: Creates an instance of BooleanSupplierKeyedMapFactory
BooleanSupplierKeyedMapGenerator(Map.Entry<BooleanSupplier, Supplier<TYPE_OUTPUT>>...) - Constructor for class xyz.ronella.trivial.handy.impl.BooleanSupplierKeyedMapGenerator: Creates an instance of BooleanSupplierKeyedMapFactory
BooleanSupplierKeyedMapGenerator(Map<BooleanSupplier, Supplier<TYPE_OUTPUT>>) - Constructor for class xyz.ronella.trivial.handy.impl.BooleanSupplierKeyedMapGenerator: Creates an instance of BooleanSupplierKeyedMapFactory
BooleanSupplierKeyedMapGenerator(Map<BooleanSupplier, Supplier<TYPE_OUTPUT>>, Supplier<TYPE_OUTPUT>, Map.Entry<BooleanSupplier, Supplier<TYPE_OUTPUT>>...) - Constructor for class xyz.ronella.trivial.handy.impl.BooleanSupplierKeyedMapGenerator: Creates an instance of BooleanSupplierKeyedMapFactory
build() - Method in class xyz.ronella.trivial.handy.impl.CommandArray.CommandArrayBuilder: The method that can create an instance of CommandArray.
build() - Method in class xyz.ronella.trivial.handy.impl.MatcherConfig.MatcherConfigBuilder: Build an instance of MatcherConfig.
build() - Method in class xyz.ronella.trivial.handy.LogicMapper.LogicMapperBuilder: Builds an instance of LogicMapper.
build() - Method in class xyz.ronella.trivial.handy.NPESilencer.NPESilencerBuilder: Actually creates an instance of NPESilencer.
build() - Method in class xyz.ronella.trivial.handy.PathFinder.PathFinderBuilder: Build an instance of a PathFinder.
build(int) - Method in class xyz.ronella.trivial.handy.impl.MatcherConfig.MatcherConfigBuilder: Build an instance of MatcherConfig with pattern flags.

C

clear() - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: Clears the content of the target string builder
close() - Method in class xyz.ronella.trivial.decorator.CloseableLock: Calls the unlock method.
CloseableLock - Class in xyz.ronella.trivial.decorator: A class that decorates an implementation of Lock to become AutoCloseable.
CloseableLock(Lock) - Constructor for class xyz.ronella.trivial.decorator.CloseableLock: Creates an instance of CloseableLock.
CloseableLock(Lock, boolean) - Constructor for class xyz.ronella.trivial.decorator.CloseableLock: Creates an instance of CloseableLock.
CloseableLock(Lock, boolean, BooleanSupplier) - Constructor for class xyz.ronella.trivial.decorator.CloseableLock: Creates an instance of CloseableLock.
CloseableLock(Lock, BooleanSupplier) - Constructor for class xyz.ronella.trivial.decorator.CloseableLock: Creates an instance of CloseableLock.
CommandArray - Class in xyz.ronella.trivial.handy.impl: The default implementation of ICommandArray.
CommandArray.CommandArrayBuilder - Class in xyz.ronella.trivial.handy.impl: The only instance that can create CommandArray.
CommandRunner - Class in xyz.ronella.trivial.handy: Run external command.
CommandRunnerException - Exception in xyz.ronella.trivial.handy: Thrown when the CommandRunner encountered an exception.
CommandRunnerException(String) - Constructor for exception xyz.ronella.trivial.handy.CommandRunnerException: Creates an instance of CommandRunnerException.
conditions - Variable in class xyz.ronella.trivial.command.logic.AbstractLogical: A list of BooleanSupplier.
Conditions - Class in xyz.ronella.trivial.handy: A collection of logic implementations.
consumer() - Static method in class xyz.ronella.trivial.functional.NoOperation: An implementation of Consumer that does nothing.

D

DEFAULT_LOGIC - Static variable in class xyz.ronella.trivial.handy.AbstractStringKeyedMapLogic: The key for the default logic.
DEFAULT_OUTPUT_LOGIC - Static variable in class xyz.ronella.trivial.handy.CommandRunner: The default output logic implementation that just simply print the output stream to System.out and error stream to System.err.
defaultFalseLogic - Variable in class xyz.ronella.trivial.command.logic.AbstractLogical: The default false logic.
defaultLogic - Variable in class xyz.ronella.trivial.handy.AbstractKeyedMapLogic: Holds the default logic if the key doesn't exist in internalMap.
defaultTruthLogic - Variable in class xyz.ronella.trivial.command.logic.AbstractLogical: The default truth logic
drainsTo(Sink) - Method in interface xyz.ronella.trivial.functional.Sink: Return a composed Sink that executes the logic after the main Sink logic.

E

ERROR_EXIT_CODE - Static variable in class xyz.ronella.trivial.handy.CommandRunner: The ERROR_EXIT_CODE when exception occurred running the command.
evaluate() - Method in class xyz.ronella.trivial.handy.NPESilencer: Evaluate all the expressions and detecting NPE.
execute() - Method in class xyz.ronella.trivial.handy.impl.BooleanSupplierKeyedMapExecutor: Executes the logic of the first key that return true otherwise the default will be executed.
execute() - Method in class xyz.ronella.trivial.handy.LogicMapper: Executes the collection of logic
execute(String) - Method in class xyz.ronella.trivial.handy.impl.StringKeyedMapExecutor: Executes the logic that corresponds to a particular key.
execute(BiConsumer<TYPE_ARG1, TYPE_ARG2>) - Static method in class xyz.ronella.trivial.command.Invoker: Executes an implementation BiConsumer but passed in nulls for the arguments.
execute(BiConsumer<TYPE_ARG1, TYPE_ARG2>, TYPE_ARG1, TYPE_ARG2) - Static method in class xyz.ronella.trivial.command.Invoker: Executes an implementation BiConsumer.
execute(Consumer<TYPE>) - Static method in class xyz.ronella.trivial.command.Invoker: Executes an implementation Consumer but passed in null to the argument.
execute(Consumer<TYPE>, TYPE) - Static method in class xyz.ronella.trivial.command.Invoker: Executes an implementation Consumer.

F

find(String, String) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: Find the RegEx from a text.
find(String, String, int) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: Find the RegEx from a text with pattern flags.
find(String, String, int, Consumer<Matcher>) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: A convenience method for the find matching with pattern flags.
find(String, String, int, Consumer<Matcher>, Consumer<Matcher>) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: A convenience method for the find matching with pattern flags.
find(String, String, Consumer<Matcher>) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: A convenience method for the find matching.
find(String, String, Consumer<Matcher>, Consumer<Matcher>) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: A convenience method for the find matching.
findWithMatchLogic(String, String, Consumer<Matcher>) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: Deprecated.
Use match(String, String, IRegExMatcherConfig) instead.
findWithMatchLogic(String, String, Consumer<Matcher>, Consumer<RuntimeException>) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: Deprecated.
Use match(String, String, IRegExMatcherConfig) instead.
findWithNoMatchLogic(String, String, Consumer<Matcher>, Consumer<Matcher>) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: Deprecated.
Use match(String, String, IRegExMatcherConfig) instead.
findWithNoMatchLogic(String, String, Consumer<Matcher>, Consumer<Matcher>, Consumer<RuntimeException>) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: Deprecated.
Use match(String, String, IRegExMatcherConfig) instead.
function() - Static method in class xyz.ronella.trivial.functional.NoOperation: An implementation of Function that does nothing.
function(R) - Static method in class xyz.ronella.trivial.functional.NoOperation: An implementation of Function that does nothing but produce default output.
functionPassThru() - Static method in class xyz.ronella.trivial.functional.NoOperation: An implementation of Function that does nothing and just return what passed.

G

generate(Supplier<TYPE_RETURN>) - Static method in class xyz.ronella.trivial.command.Invoker: Executes an implementation of Supplier.
get() - Method in class xyz.ronella.trivial.decorator.Mutable: Access the immutable object.
get() - Method in class xyz.ronella.trivial.handy.AbstractBooleanSupplierKeyedMapLogic: Returns the calculated output.
get() - Method in class xyz.ronella.trivial.handy.impl.BooleanSupplierKeyedMapExecutor: This will always return empty values.
get() - Method in class xyz.ronella.trivial.handy.impl.BooleanSupplierKeyedMapGenerator: Executes the logic of the first truth key.
get(String) - Method in class xyz.ronella.trivial.handy.AbstractStringKeyedMapLogic: Must have the implementation on how to get the logic based on a key and must be able to handle if that key doesn't exists.
get(String) - Method in class xyz.ronella.trivial.handy.impl.StringKeyedMapExecutor: This will always return empty values.
get(String) - Method in class xyz.ronella.trivial.handy.impl.StringKeyedMapFactory: Deprecated.

Executes the logic of particular key.
get(String) - Method in class xyz.ronella.trivial.handy.impl.StringKeyedMapGenerator: Executes the logic of particular key.
getBuilder() - Static method in class xyz.ronella.trivial.handy.impl.CommandArray: Return the builder of the CommandArray.
getBuilder() - Static method in class xyz.ronella.trivial.handy.impl.MatcherConfig: Returns an instance of MatcherConfigBuilder
getBuilder() - Static method in class xyz.ronella.trivial.handy.LogicMapper: Build an instance of LogicMapper.
getBuilder() - Static method in class xyz.ronella.trivial.handy.NPESilencer: Creates the builder of the NPESilencer.
getBuilder(String) - Static method in class xyz.ronella.trivial.handy.PathFinder: The only method that can create an instance of PathFinder.
getCommand() - Method in interface xyz.ronella.trivial.handy.ICommandArray: Must hold the implementation of returning the command as array.
getCommand() - Method in class xyz.ronella.trivial.handy.impl.CommandArray: Generates the command as array.
getDefaultLogic() - Method in class xyz.ronella.trivial.handy.AbstractKeyedMapLogic: The default logic that will be executed if none of the keys matched.
getExceptionLogic() - Method in interface xyz.ronella.trivial.handy.IMatcherConfig: The logic for capturing exception RuntimeException.
getExceptionLogic() - Method in class xyz.ronella.trivial.handy.impl.MatcherConfig
getFile() - Method in class xyz.ronella.trivial.handy.PathFinder: Find the first existence of the file.
getInputStream() - Method in class xyz.ronella.trivial.handy.PathFinder: Find the first existence of the file as InputStream.
getMatchFoundLogic() - Method in interface xyz.ronella.trivial.handy.IMatcherConfig: The logic executed when the pattern was found.
getMatchFoundLogic() - Method in class xyz.ronella.trivial.handy.impl.MatcherConfig
getMatchLogic() - Method in interface xyz.ronella.trivial.handy.IMatcherConfig: The logic to be used for matching the regex.
getMatchLogic() - Method in class xyz.ronella.trivial.handy.impl.MatcherConfig
getNoMatchFoundLogic() - Method in interface xyz.ronella.trivial.handy.IMatcherConfig: The logic executed when the pattern was not found.
getNoMatchFoundLogic() - Method in class xyz.ronella.trivial.handy.impl.MatcherConfig
getPatternFlags() - Method in interface xyz.ronella.trivial.handy.IMatcherConfig: Must return the Pattern flags to use.
getPatternFlags() - Method in class xyz.ronella.trivial.handy.impl.MatcherConfig
getStringBuilder() - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: Access the internal StringBuilder that the decorator is holding.
getTruthCondition(List<BooleanSupplier>) - Method in class xyz.ronella.trivial.command.logic.AbstractLogical: Determines the truth condition.
getTruthCondition(List<BooleanSupplier>) - Method in class xyz.ronella.trivial.command.logic.LogicAND
getTruthCondition(List<BooleanSupplier>) - Method in class xyz.ronella.trivial.command.logic.LogicOR

H

handleDefaultLogicConstructorArgument(Supplier<TYPE_OUTPUT>) - Method in class xyz.ronella.trivial.handy.impl.BooleanSupplierKeyedMapGenerator
handleDefaultLogicConstructorArgument(Supplier<TYPE_OUTPUT>) - Method in class xyz.ronella.trivial.handy.impl.StringKeyedMapFactory: Deprecated.
handleDefaultLogicConstructorArgument(Supplier<TYPE_OUTPUT>) - Method in class xyz.ronella.trivial.handy.impl.StringKeyedMapGenerator
handleDefaultLogicConstructorArgument(TYPE_LOGIC) - Method in class xyz.ronella.trivial.handy.AbstractKeyedMapLogic: Must have the implementation to handle the null defaultLogic.
handleDefaultLogicConstructorArgument(Sink) - Method in class xyz.ronella.trivial.handy.impl.BooleanSupplierKeyedMapExecutor
handleDefaultLogicConstructorArgument(Sink) - Method in class xyz.ronella.trivial.handy.impl.StringKeyedMapExecutor

I

ICommandArray - Interface in xyz.ronella.trivial.handy: The implementation of this interface must hold the logic of generating the command as array.
identify() - Static method in enum class xyz.ronella.trivial.handy.OSType: Identifies the current OS where the code is running.
ifPresentNotBlank(Consumer<String>) - Method in class xyz.ronella.trivial.decorator.OptionalString: If the string value is present and not blank, performs the given action with the value, otherwise does nothing.
ifPresentNotBlankOrElse(Consumer<String>, Runnable) - Method in class xyz.ronella.trivial.decorator.OptionalString: If the string value is present and not blank, performs the given action with the value, otherwise performs the given empty-based action.
ifPresentNotEmpty(Consumer<String>) - Method in class xyz.ronella.trivial.decorator.OptionalString: If the string value is present and not empty, performs the given action with the value, otherwise does nothing.
ifPresentNotEmptyOrElse(Consumer<String>, Runnable) - Method in class xyz.ronella.trivial.decorator.OptionalString: If the string value is present and not empty, performs the given action with the value, otherwise performs the given empty-based action.
ILogical - Interface in xyz.ronella.trivial.command.logic: The framework of implementing a logical command.
IMatcherConfig - Interface in xyz.ronella.trivial.handy: The implementation of this interface can be used to change the behaviour of RegExMatcher.
internalMap - Variable in class xyz.ronella.trivial.handy.AbstractKeyedMapLogic: The instance of Map received.
Invoker - Class in xyz.ronella.trivial.command: Invokes an implementation of basic functional interfaces.
isBlank() - Method in class xyz.ronella.trivial.decorator.OptionalString: Identifies if the optional string is blank.
isEmpty() - Method in class xyz.ronella.trivial.decorator.OptionalString: Identifies if optional string is empty.

L

Linux - Enum constant in enum class xyz.ronella.trivial.handy.OSType: Indicates that the OS type is Linux.
ListAdder<TYPE_ELEMENT> - Class in xyz.ronella.trivial.decorator: A class the wraps a List to have add methods with condition.
ListAdder(List<TYPE_ELEMENT>) - Constructor for class xyz.ronella.trivial.decorator.ListAdder: Creates an instance of ListAdder
lock() - Method in class xyz.ronella.trivial.decorator.CloseableLock: Calls the lock method if the lockOnlyWhen returns true.
LogicAND - Class in xyz.ronella.trivial.command.logic: A class that accepts multiple conditions if all conditions are true it will pass control to the truthLogic otherwise the falseLogic will take it.
LogicAND(BooleanSupplier...) - Constructor for class xyz.ronella.trivial.command.logic.LogicAND: Creates an instance of LogicAND.
LogicAND(List<BooleanSupplier>) - Constructor for class xyz.ronella.trivial.command.logic.LogicAND: Creates an instance of LogicAND.
LogicAND(List<BooleanSupplier>, Sink) - Constructor for class xyz.ronella.trivial.command.logic.LogicAND: Creates an instance of LogicAND.
LogicAND(List<BooleanSupplier>, Sink, Sink) - Constructor for class xyz.ronella.trivial.command.logic.LogicAND: Creates an instance of LogicAND.
LogicAND(Sink, BooleanSupplier...) - Constructor for class xyz.ronella.trivial.command.logic.LogicAND: Creates an instance of LogicAND.
LogicAND(Sink, Sink, BooleanSupplier...) - Constructor for class xyz.ronella.trivial.command.logic.LogicAND: Creates an instance of LogicAND.
LogicMapper<TYPE_OUTPUT> - Class in xyz.ronella.trivial.handy: Creates a map of conditions and logic where all the conditions that evaluated to true will perform its corresponding logic.
LogicMapper.LogicMapperBuilder<TYPE_OUTPUT> - Class in xyz.ronella.trivial.handy: A class that can build an instance of LogicMapper.
LogicMapperBuilder() - Constructor for class xyz.ronella.trivial.handy.LogicMapper.LogicMapperBuilder: Creates an instance that can build a LogicMapper instance.
LogicOR - Class in xyz.ronella.trivial.command.logic: A class that accepts multiple conditions and if at least one condition is true it will pass control to the truthLogic otherwise the falseLogic will take it.
LogicOR(BooleanSupplier...) - Constructor for class xyz.ronella.trivial.command.logic.LogicOR: Creates an instance of LogicOR.
LogicOR(List<BooleanSupplier>) - Constructor for class xyz.ronella.trivial.command.logic.LogicOR: Creates an instance of LogicOR.
LogicOR(List<BooleanSupplier>, Sink) - Constructor for class xyz.ronella.trivial.command.logic.LogicOR: Creates an instance of LogicOR.
LogicOR(List<BooleanSupplier>, Sink, Sink) - Constructor for class xyz.ronella.trivial.command.logic.LogicOR: Creates an instance of LogicOR.
LogicOR(Sink, BooleanSupplier...) - Constructor for class xyz.ronella.trivial.command.logic.LogicOR: Creates an instance of LogicOR.
LogicOR(Sink, Sink, BooleanSupplier...) - Constructor for class xyz.ronella.trivial.command.logic.LogicOR: Creates an instance of LogicOR.

M

Mac - Enum constant in enum class xyz.ronella.trivial.handy.OSType: Indicates that the OS type is Mac.
match(String, String, Function<Matcher, Boolean>) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: Deprecated.
Use match(String, String, IRegExMatcherConfig) instead.
match(String, String, Function<Matcher, Boolean>, Consumer<RuntimeException>) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: Deprecated.
Use match(String, String, Function, IRegExMatcherConfig) instead.
match(String, String, IMatcherConfig) - Static method in class xyz.ronella.trivial.handy.RegExMatcher
matchByRegEx(String, String) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: Deprecated.
Use find instead.
matchByRegEx(String, String, Consumer<Matcher>) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: Deprecated.
Use findWithMatchLogic instead.
matchByRegEx(String, String, Consumer<Matcher>, Consumer<RuntimeException>) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: Deprecated.
Use findWithMatchLogic instead.
matchByRegEx(String, String, Consumer<Matcher>, Sink) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: Deprecated.
Use findWithNoMatchLogic instead.
matchByRegEx(String, String, Consumer<Matcher>, Sink, Consumer<RuntimeException>) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: Deprecated.
Use findWithNoMatchLogic instead.
matchByRegEx(String, String, Function<Matcher, Boolean>) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: Deprecated.
Use match instead.
matchByRegEx(String, String, Function<Matcher, Boolean>, Consumer<Matcher>) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: Deprecated.
Use matchWithMatchLogic instead.
matchByRegEx(String, String, Function<Matcher, Boolean>, Consumer<Matcher>, Consumer<RuntimeException>) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: Deprecated.
Use matchWithMatchLogic instead.
matchByRegEx(String, String, Function<Matcher, Boolean>, Consumer<Matcher>, Sink) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: Deprecated.
Use matchWithNoMatchLogic instead.
matchByRegEx(String, String, Function<Matcher, Boolean>, Consumer<Matcher>, Sink, Consumer<RuntimeException>) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: Deprecated.
Use matchWithNoMatchLogic instead.
MatcherConfig - Class in xyz.ronella.trivial.handy.impl: The default implementation of IMatcherConfig.
MatcherConfig.MatcherConfigBuilder - Class in xyz.ronella.trivial.handy.impl: The only class the can create an instance of MatcherConfig.
matchWithMatchLogic(String, String, Function<Matcher, Boolean>, Consumer<Matcher>) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: Deprecated.
Use match(String, String, Function, IRegExMatcherConfig) instead.
matchWithMatchLogic(String, String, Function<Matcher, Boolean>, Consumer<Matcher>, Consumer<RuntimeException>) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: Deprecated.
Use match(String, String, Function, IRegExMatcherConfig) instead.
matchWithNoMatchLogic(String, String, Function<Matcher, Boolean>, Consumer<Matcher>, Consumer<Matcher>) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: Deprecated.
Use match(String, String, Function, IRegExMatcherConfig) instead.
matchWithNoMatchLogic(String, String, Function<Matcher, Boolean>, Consumer<Matcher>, Consumer<Matcher>, Consumer<RuntimeException>) - Static method in class xyz.ronella.trivial.handy.RegExMatcher: Deprecated.
Use match(String, String, Function, IRegExMatcherConfig) instead.
MissingCommandException - Exception in xyz.ronella.trivial.handy: This is thrown when no command to execute.
MissingCommandException() - Constructor for exception xyz.ronella.trivial.handy.MissingCommandException: Creates an instance of MissingCommandException.
Mutable<TYPE_OBJECT> - Class in xyz.ronella.trivial.decorator: A convenience class that accepts an immutable object and making it possible to be replaced within itself.
Mutable(TYPE_OBJECT) - Constructor for class xyz.ronella.trivial.decorator.Mutable: Creates an instance of Mutable.

N

NoCommandException - Exception in xyz.ronella.trivial.handy: Deprecated.
Use MissingCommandException instead.
NoCommandException() - Constructor for exception xyz.ronella.trivial.handy.NoCommandException: Deprecated.

Creates an instance of NoCommandException.
NoOperation - Class in xyz.ronella.trivial.functional: A do nothing implementation of some functional interfaces.
NPESilencer<TYPE_ROOT_OBJECT,TYPE_OUTPUT> - Class in xyz.ronella.trivial.handy: A handy class for silencing the NPE.
NPESilencer.NPESilencerBuilder<TYPE_ROOT_OBJECT,TYPE_OUTPUT> - Class in xyz.ronella.trivial.handy: The only class that can create NPESilencer.
NPESilencerBuilder() - Constructor for class xyz.ronella.trivial.handy.NPESilencer.NPESilencerBuilder
nullable(Supplier) - Static method in class xyz.ronella.trivial.handy.NPESilencer: A convenience method for evaluating a single expression (i.e.

O

objects(Object, Object...) - Static method in class xyz.ronella.trivial.handy.Require: The method that checks if all the objects were not null.
OptionalString - Class in xyz.ronella.trivial.decorator: A class that wraps an Optional instance of type String.
OptionalString(Optional<String>) - Constructor for class xyz.ronella.trivial.decorator.OptionalString: Creates an instance of OptionalString.
or(List<BooleanSupplier>, Sink) - Static method in class xyz.ronella.trivial.handy.Conditions: Accepts multiple conditions if at least one condition is true it will pass control to the truthLogic.
or(List<BooleanSupplier>, Sink, Sink) - Static method in class xyz.ronella.trivial.handy.Conditions: Accepts multiple conditions if at least one condition is true it will pass control to the truthLogic otherwise the falseLogic will take it.
OSType - Enum Class in xyz.ronella.trivial.handy: The enumerator that identifies the OSType.
output() - Method in class xyz.ronella.trivial.handy.LogicMapper: Executes the collection of logic with return the finalLogic output.

P

PathFinder - Class in xyz.ronella.trivial.handy: A class that will find the first existence of a file based on the directories provided.
PathFinder.PathFinderBuilder - Class in xyz.ronella.trivial.handy: The only class that can create an instance of PathFinder.
plummet() - Method in interface xyz.ronella.trivial.functional.Sink: Must a logic that doesn't expects an argument and a return value.
plunge(Sink) - Static method in class xyz.ronella.trivial.command.Invoker: Executes an implementation of Sink
predicate(Boolean) - Static method in class xyz.ronella.trivial.functional.NoOperation: An implementation of Predicate that does nothing but must have a specific boolean output.
process(BiFunction<TYPE_ARG1, TYPE_ARG2, TYPE_RETURN>, TYPE_ARG1, TYPE_ARG2) - Static method in class xyz.ronella.trivial.command.Invoker: Executes an implementation of BiFunction.
process(Function<TYPE_ARG, TYPE_RETURN>, TYPE_ARG) - Static method in class xyz.ronella.trivial.command.Invoker: Executes an implementation of Function.
processInputStream(Consumer<InputStream>) - Method in class xyz.ronella.trivial.handy.PathFinder: The InputStream of the resolved file.

R

RegExMatcher - Class in xyz.ronella.trivial.handy: A handy class to find a RegEx pattern from a text.
replace(CharSequence, CharSequence) - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: Replace part of StringBuilder
Require - Class in xyz.ronella.trivial.handy: A handy class for requiring objects.
RequireAllException - Exception in xyz.ronella.trivial.handy: Thrown with one of argument in Require.objects is null.
RequireAllException() - Constructor for exception xyz.ronella.trivial.handy.RequireAllException: Creates an instance of RequireAllException.
runCommand(String...) - Static method in class xyz.ronella.trivial.handy.CommandRunner: Run the commands received.
runCommand(BiConsumer<InputStream, InputStream>, String...) - Static method in class xyz.ronella.trivial.handy.CommandRunner: Run the commands received.
runCommand(BiConsumer<InputStream, InputStream>, ICommandArray) - Static method in class xyz.ronella.trivial.handy.CommandRunner: Start a process based on the command received.
runCommand(Consumer<ProcessBuilder>, String...) - Static method in class xyz.ronella.trivial.handy.CommandRunner: Run the commands received.
runCommand(Consumer<ProcessBuilder>, BiConsumer<InputStream, InputStream>, String...) - Static method in class xyz.ronella.trivial.handy.CommandRunner: Run the commands received.
runCommand(Consumer<ProcessBuilder>, BiConsumer<InputStream, InputStream>, ICommandArray) - Static method in class xyz.ronella.trivial.handy.CommandRunner: Run the commands received.
runCommand(Consumer<ProcessBuilder>, ICommandArray) - Static method in class xyz.ronella.trivial.handy.CommandRunner: Run the commands received.
runCommand(Supplier<ProcessBuilder>, String...) - Static method in class xyz.ronella.trivial.handy.CommandRunner: Run the commands received.
runCommand(Supplier<ProcessBuilder>, BiConsumer<InputStream, InputStream>, String...) - Static method in class xyz.ronella.trivial.handy.CommandRunner: Run the commands received.
runCommand(Supplier<ProcessBuilder>, BiConsumer<InputStream, InputStream>, ICommandArray) - Static method in class xyz.ronella.trivial.handy.CommandRunner: Run the commands received.
runCommand(Supplier<ProcessBuilder>, ICommandArray) - Static method in class xyz.ronella.trivial.handy.CommandRunner: Run the commands received.
runCommand(ICommandArray) - Static method in class xyz.ronella.trivial.handy.CommandRunner: Run the commands received.

S

set(TYPE_OBJECT) - Method in class xyz.ronella.trivial.decorator.Mutable: Replace the current immutable object.
setCommand(String) - Method in class xyz.ronella.trivial.handy.impl.CommandArray.CommandArrayBuilder: Accepts the command to be run with the program.
setExceptionLogic(Consumer<RuntimeException>) - Method in class xyz.ronella.trivial.handy.impl.MatcherConfig.MatcherConfigBuilder: Must return how the exception logic will be performed.
setFallbackToClassloader(boolean) - Method in class xyz.ronella.trivial.handy.PathFinder.PathFinderBuilder: Set this to load the file using classloader if it doesn't exist in any of the paths provided.
setMatchFoundLogic(Consumer<Matcher>) - Method in class xyz.ronella.trivial.handy.impl.MatcherConfig.MatcherConfigBuilder: Must return how the match found logic will be performed.
setMatchLogic(Function<Matcher, Boolean>) - Method in class xyz.ronella.trivial.handy.impl.MatcherConfig.MatcherConfigBuilder: Must return how the matching logic will be performed.
setNoMatchFoundLogic(Consumer<Matcher>) - Method in class xyz.ronella.trivial.handy.impl.MatcherConfig.MatcherConfigBuilder: Must return how the no match found logic will be performed.
setProgram(String) - Method in class xyz.ronella.trivial.handy.impl.CommandArray.CommandArrayBuilder: Accepts the program name to be executed.
sink() - Static method in class xyz.ronella.trivial.functional.NoOperation: An implementation of Sink that does nothing.
Sink - Interface in xyz.ronella.trivial.functional: Must hold a logic that doesn't expects an argument and a return value.
startProcess(Consumer<Process>, ICommandArray) - Static method in class xyz.ronella.trivial.handy.CommandRunner: Start a process based on the command received.
startProcess(Consumer<ProcessBuilder>, Consumer<Process>, ICommandArray) - Static method in class xyz.ronella.trivial.handy.CommandRunner: Start a process based on the command received.
startProcess(Supplier<ProcessBuilder>, Consumer<Process>, BiConsumer<InputStream, InputStream>, ICommandArray) - Static method in class xyz.ronella.trivial.handy.CommandRunner: Start a process based on the command received.
startProcess(Supplier<ProcessBuilder>, Consumer<Process>, ICommandArray) - Static method in class xyz.ronella.trivial.handy.CommandRunner: Start a process based on the command received.
startProcess(ICommandArray) - Static method in class xyz.ronella.trivial.handy.CommandRunner: Start a process based on the command received.
StringBuilderAppender - Class in xyz.ronella.trivial.decorator: A decorator for StringBuilder that gives you a chance to add pre-append and post-append logic.
StringBuilderAppender() - Constructor for class xyz.ronella.trivial.decorator.StringBuilderAppender: Creates an instance of StringBuilderAppender with default StringBuilder.
StringBuilderAppender(String) - Constructor for class xyz.ronella.trivial.decorator.StringBuilderAppender: Accepts a StringBuilder to decorate.
StringBuilderAppender(StringBuilder) - Constructor for class xyz.ronella.trivial.decorator.StringBuilderAppender: Accepts a StringBuilder to decorate.
StringBuilderAppender(StringBuilder, Consumer<StringBuilder>) - Constructor for class xyz.ronella.trivial.decorator.StringBuilderAppender: Decorate the StringBuilder to have a default pre-append logic.
StringBuilderAppender(StringBuilder, Consumer<StringBuilder>, Consumer<StringBuilder>) - Constructor for class xyz.ronella.trivial.decorator.StringBuilderAppender: Decorate the StringBuilder to have a default pre-append and post-append logic.
StringBuilderAppender(String, Consumer<StringBuilder>) - Constructor for class xyz.ronella.trivial.decorator.StringBuilderAppender: Decorate the StringBuilder to have a default pre-append logic.
StringBuilderAppender(String, Consumer<StringBuilder>, Consumer<StringBuilder>) - Constructor for class xyz.ronella.trivial.decorator.StringBuilderAppender: Decorate the StringBuilder to have a default pre-append and post-append logic.
StringBuilderAppender(Consumer<StringBuilder>) - Constructor for class xyz.ronella.trivial.decorator.StringBuilderAppender: Creates an instance of StringBuilderAppender with default StringBuilder.
StringBuilderAppender(Consumer<StringBuilder>, Consumer<StringBuilder>) - Constructor for class xyz.ronella.trivial.decorator.StringBuilderAppender: Creates an instance of StringBuilderAppender with default StringBuilder.
StringKeyedMapExecutor - Class in xyz.ronella.trivial.handy.impl: A convenience class for creating a map as executor.
StringKeyedMapExecutor(Map.Entry<String, Sink>...) - Constructor for class xyz.ronella.trivial.handy.impl.StringKeyedMapExecutor: Creates an instance of StringKeyedMapExecutor
StringKeyedMapExecutor(Map<String, Sink>) - Constructor for class xyz.ronella.trivial.handy.impl.StringKeyedMapExecutor: Creates an instance of StringKeyedMapExecutor
StringKeyedMapExecutor(Map<String, Sink>, Sink, Map.Entry<String, Sink>...) - Constructor for class xyz.ronella.trivial.handy.impl.StringKeyedMapExecutor: Creates an instance of StringKeyedMapExecutor
StringKeyedMapExecutor(Sink, Map.Entry<String, Sink>...) - Constructor for class xyz.ronella.trivial.handy.impl.StringKeyedMapExecutor: Creates an instance of StringKeyedMapExecutor
StringKeyedMapFactory<TYPE_OUTPUT> - Class in xyz.ronella.trivial.handy.impl: Deprecated.
Use StringKeyedMapGenerator instead
StringKeyedMapFactory(Supplier<TYPE_OUTPUT>, Map.Entry<String, Supplier<TYPE_OUTPUT>>...) - Constructor for class xyz.ronella.trivial.handy.impl.StringKeyedMapFactory: Deprecated.

Creates an instance of StringKeyedMapFactory
StringKeyedMapFactory(Map.Entry<String, Supplier<TYPE_OUTPUT>>...) - Constructor for class xyz.ronella.trivial.handy.impl.StringKeyedMapFactory: Deprecated.

Creates an instance of StringKeyedMapFactory
StringKeyedMapFactory(Map<String, Supplier<TYPE_OUTPUT>>, Supplier<TYPE_OUTPUT>, Map.Entry<String, Supplier<TYPE_OUTPUT>>...) - Constructor for class xyz.ronella.trivial.handy.impl.StringKeyedMapFactory: Deprecated.

Creates an instance of StringKeyedMapFactory
StringKeyedMapGenerator<TYPE_OUTPUT> - Class in xyz.ronella.trivial.handy.impl: A convenience class for creating a map as factory.
StringKeyedMapGenerator(Supplier<TYPE_OUTPUT>, Map.Entry<String, Supplier<TYPE_OUTPUT>>...) - Constructor for class xyz.ronella.trivial.handy.impl.StringKeyedMapGenerator: Creates an instance of StringKeyedMapFactory
StringKeyedMapGenerator(Map.Entry<String, Supplier<TYPE_OUTPUT>>...) - Constructor for class xyz.ronella.trivial.handy.impl.StringKeyedMapGenerator: Creates an instance of StringKeyedMapFactory
StringKeyedMapGenerator(Map<String, Supplier<TYPE_OUTPUT>>) - Constructor for class xyz.ronella.trivial.handy.impl.StringKeyedMapGenerator: Creates an instance of StringKeyedMapFactory
StringKeyedMapGenerator(Map<String, Supplier<TYPE_OUTPUT>>, Supplier<TYPE_OUTPUT>, Map.Entry<String, Supplier<TYPE_OUTPUT>>...) - Constructor for class xyz.ronella.trivial.handy.impl.StringKeyedMapGenerator: Creates an instance of StringKeyedMapFactory
supplier() - Static method in class xyz.ronella.trivial.functional.NoOperation: An implementation of Supplier that does nothing.

T

threadSafe() - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: Make the appending task thread safe.
toString() - Method in class xyz.ronella.trivial.decorator.StringBuilderAppender: String representation of the internal StringBuilder that the decorator is holding.

U

Unknown - Enum constant in enum class xyz.ronella.trivial.handy.OSType: Indicates that the OS type cannot be determined.
unlock() - Method in class xyz.ronella.trivial.decorator.CloseableLock: Calls the unlock method if the lockOnlyWhen returns true.

V

valueOf(String) - Static method in enum class xyz.ronella.trivial.handy.OSType: Returns the enum constant of this class with the specified name.
values() - Static method in enum class xyz.ronella.trivial.handy.OSType: Returns an array containing the constants of this enum class, in the order they are declared.

W

Windows - Enum constant in enum class xyz.ronella.trivial.handy.OSType: Indicates that the OS type is Windows.

X

xyz.ronella.casual.trivial - module xyz.ronella.casual.trivial: The module of trivial codes.
xyz.ronella.trivial.command - package xyz.ronella.trivial.command
xyz.ronella.trivial.command.logic - package xyz.ronella.trivial.command.logic
xyz.ronella.trivial.decorator - package xyz.ronella.trivial.decorator
xyz.ronella.trivial.functional - package xyz.ronella.trivial.functional
xyz.ronella.trivial.handy - package xyz.ronella.trivial.handy
xyz.ronella.trivial.handy.impl - package xyz.ronella.trivial.handy.impl

A B C D E F G H I L M N O P R S T U V W X
All Classes and Interfaces|All Packages|Constant Field Values|Serialized Form