Fzzy Config/me.fzzyhmstrs.fzzy_config.validation.number/ValidatedInt

ValidatedInt

open class ValidatedInt @JvmOverloads constructor(defaultValue: Int, maxValue: Int, minValue: Int, widgetType: ValidatedNumber.WidgetType = if(maxValue == Int.MAX_VALUE || minValue == Int.MIN_VALUE) WidgetType.TEXTBOX else WidgetType.SLIDER) : ValidatedNumber<Int>

A validated integer number. This field is a wrapper of integers that is both a java.util.function.Supplier and java.util.function.Consumer of type Int

Author

fzzyhmstrs

Since

0.1.0

Parameters

defaultValue

Int. the default value of this wrapper

maxValue

Int. the maximum allowed value, inclusive

minValue

Int. the minimum allowed value, inclusive

Samples

import me.fzzyhmstrs.fzzy_config.validation.number.*

fun main() { 
   //sampleStart 
   //ValidatedInt. Defaults to 20, allowable range 40 to 5. Uses a Slider widget
val validatedInt = ValidatedInt(20, 40, 5)

//You can define the widget type of ValidatedInt, either a Slider or a "textbox".
val textBoxInt = ValidatedInt(20, 40, 5, ValidatedNumber.WidgetType.TEXTBOX)

//ValidatedInt built with an IntRange. can use either a Slider or a "textbox" widget.
val rangedDefaultedInt = ValidatedInt(20, 0..40)

//ValidatedInt built with an IntRange. Uses the minimum range value as the default. can use either a Slider or a "textbox" widget.
val rangedInt = ValidatedInt(0..400)

//ValidatedInt built with just a min and max. Uses the minimum value as the default. can use either a Slider or a "textbox" widget.
val minMaxInt = ValidatedInt(0, 400)

//unbounded ValidatedInt. Can be any valid integer value. Widget forced to "textbox" style
val unboundedInt = ValidatedInt(20)

//validation-only Int (unless your default happens to be 0)
val emptyInt = ValidatedInt()

//fields and sections have lang keys based on their "location" in the Config class graph.
//Lange key composition is as follows
//1. the namespace of the config id: (my_mod)
//2. the path of the config id: (my_mod.my_config)
//3. any parent ConfigSection field names as declared in-code: (my_mod.my_config.subSection)
//4. the setting field name as declared in-code: (my_mod.my_config.subSection.fieldName)
val fieldLang = """
{
    "_comment1": "the lang for an example 'fieldName' setting in a config inside section 'subSection'",
    "my_mod.my_config.subSection.fieldName": "Very Important Setting",
    "my_mod.my_config.subSection.fieldName.desc": "This very important setting is used in this very important way."
}
""" 
   //sampleEnd
}

Constructors

ValidatedInt

@JvmOverloads

constructor(defaultValue: Int, range: IntRange, widgetType: ValidatedNumber.WidgetType = WidgetType.SLIDER)

A validated int number generated with an IntRange.

@JvmOverloads

constructor(range: IntRange, widgetType: ValidatedNumber.WidgetType = WidgetType.SLIDER)

A validated int number with a default selected from the min of the allowable range.

@JvmOverloads

constructor(minValue: Int, maxValue: Int, widgetType: ValidatedNumber.WidgetType = WidgetType.SLIDER)

A validated int number with a default selected from the min of the allowable range.

constructor(defaultValue: Int)

An unbounded validated int number.

constructor()

An unbounded validated int number with default of 0.

@JvmOverloads

constructor(defaultValue: Int, maxValue: Int, minValue: Int, widgetType: ValidatedNumber.WidgetType = if(maxValue == Int.MAX_VALUE || minValue == Int.MIN_VALUE) WidgetType.TEXTBOX else WidgetType.SLIDER)

Types

Restrict

annotation class Restrict(val min: Int = Int.MIN_VALUE, val max: Int = Int.MAX_VALUE)

Annotation-driven validation for Ints

Functions

open override fun accept(input: Int)

updates the wrapped value. NOTE: this method will push updates to an UpdateManager, if any. For in-game updating consider validateAndSet

addListener

open fun addListener(listener: Consumer<ValidatedField<Int>>)

Attaches a listener to this field. This listener will be called any time the field is written to ("set"). accept, validateAndSet, setAndUpdate and so on will all call the listener.

andThen

open fun andThen(p0: Consumer<in Int>): Consumer<Int>

codec

fun codec(): Codec<Int>

Provides a Codec representing the value type of this validation, backed by the validators within as applicable

copyStoredValue

open fun copyStoredValue(): Int

Copies the stored value and returns it.

description

open override fun description(fallback: String?): MutableText

The translated Text description from the descriptionKey. Falls back to an empty string so no tooltip is rendered.

descriptionKey

open override fun descriptionKey(): String

translation key of this Translatable's description. the "description" in-game, the descriptions Enchantment Descriptions adds to enchantment tooltips are a good example.

flags

open fun flags(): Byte

get

open override fun get(): Int

supplies the wrapped value

getDefault

fun getDefault(): Int

Provides this validations default value

hasDescription

open override fun hasDescription(): Boolean

Whether this Translatable has a valid description

hasFlag

open override fun hasFlag(flag: EntryFlag.Flag): Boolean

hasTranslation

open fun hasTranslation(): Boolean

Whether this Translatable has a valid translation

instanceEntry

open override fun instanceEntry(): ValidatedInt

map

fun <N> map(to: Function<Int, out N>, from: Function<in N, Int>): ValidatedField<N>

Maps this validation to a new convertible type. The default value will be applied from this delegates current storedValue

fun <N> map(defaultValue: N, to: Function<Int, out N>, from: Function<in N, Int>): ValidatedField<N>

fun <N> map(to: Function<Int, out N>, from: Function<in N, Int>, defaultValue: Int): ValidatedField<N>

Maps this validation to a new convertible type.

toCondition

open fun toCondition(condition: ValidatedField<Boolean>, fallback: Supplier<Int>): ValidatedCondition<Int>

Convert this field to a ValidatedCondition using the provided validation as a supplier. The provided condition (and any others you append) must pass for the stored value to be provided, otherwise the fallback will be supplied.

open fun toCondition(condition: ValidatedCondition.Condition, fallback: Supplier<Int>): ValidatedCondition<Int>

open fun toCondition(condition: Supplier<Boolean>, failMessage: Text, fallback: Supplier<Int>): ValidatedCondition<Int>

Convert this field to a ValidatedCondition. The provided condition (and any others you append) must pass for the stored value to be provided, otherwise the fallback will be supplied.

open fun toCondition(scope: String, failMessage: Text, fallback: Supplier<Int>): ValidatedCondition<Int>

Convert this field to a ValidatedCondition using the provided scope with a default boolean provider. The provided condition (and any others you append) must pass for the stored value to be provided, otherwise the fallback will be supplied. The provided scope must point to a valid boolean config scope otherwise the initial condition will never pass.

toList

fun toList(vararg elements: Int): ValidatedList<Int>

wraps the provided values into a ValidatedList with this field as validation

fun toList(collection: Collection<Int>): ValidatedList<Int>

wraps the provided collection into a ValidatedList with this field as validation

toSet

fun toSet(vararg elements: Int): ValidatedSet<Int>

wraps the provided values into a ValidatedSet with this field as validation

fun toSet(collection: Collection<Int>): ValidatedSet<Int>

wraps the provided collection into a ValidatedSet with this field as validation

toString

open override fun toString(): String

translation

open override fun translation(fallback: String?): MutableText

The translated Text name from the translationKey. Falls back to the implementing classes Simple Name (non-translated)

translationKey

open override fun translationKey(): String

translation key of this Translatable. the "name" in-game

trySerialize

fun trySerialize(input: Any?, errorBuilder: MutableList<String>, flags: Byte): TomlElement?

trySet

open override fun trySet(input: Any?)

update

open fun update(updateMessage: Text)

validateAndSet

open fun validateAndSet(input: Int): ValidationResult<Int>

A setter method for the storedValue that first validates the value being set and then stores the post-validation result.

validateAndSetFlagged

open fun validateAndSetFlagged(input: Int, vararg flag: EntryFlag.Flag): ValidationResult<Int>

A setter method for the storedValue that first validates the value being set and then stores the post-validation result.

widgetAndTooltipEntry

open fun widgetAndTooltipEntry(choicePredicate: ChoiceValidator<Int> = ChoiceValidator.any()): ClickableWidget