java - Restrict which values will be settleable in an javafx property? -

what's best way keep value of javafx property within specific bounds?

(or - bad practice, existing reason never filter values wrapped javafx properties?)

example1: avoid negative values in integerproperty
example2: keep value of integerproperty within bounds of list

first idea: - override integerpropertybase.set(int). it's safe? setvalue(int) calls set(int), - if implementation 1 day changes - control on values set goes lost.

second idea: - override integerpropertybase.invalidate(). @ point value set.

will fit better javafx properties throw illegalargumentexception (or arrayindexoutofboundsexception, if wrapped value index of array), or better refuse value out of bounds, setting last value in bounds?

maybe this:

    class boundedintegerproperty extends integerpropertybase {         (...)         int oldvalue = defaultvalueinbounds;         boolean settingoldvalue = false;         public void invalidated() {             if(!settingoldvalue){                 if(outofbounds(get())){                     settingoldvalue = true;                     set(oldvalue);                 } else {                     oldvalue = get();                 }             } else                 settingoldvalue = false;         }     } 

only throw exception in invalidated() values out of bounds may keep value of property out of bounds.

have overlooked in javafx properties provided filter values?

(if necessary, please me improving possibly bad english of text...)

in both examples, there seemed logical default value (eg. if it's required positive, negative numbers turn 0). assuming document (what defaults if value invalid), think first approach seems it's on right path.

i'd recommend starting concrete class simpleintegerproperty class you're extending (unless there's reason chose integerpropertybase instead.

i overwrite both set(int) method , setvalue(number) method, wrapping parent in logic:

    /**      * explanation values under 0 set 0      */     @override     public void set(int value){         super.set(value > 0 ? value : 0);     }      /**      * explanation values under 0 set 0      */     @override     public void setvalue(number value){         super.setvalue(value.intvalue() > 0 ? value : 0);     } 

there may case there isn't logical default values (or want reject invalid values). case makes bit harder - you'd want use method signature of caller knows if value changed:

public boolean set(int value) 

in order that, you'll have go quite few classes - way readonlyintegerproperty , implement setting / invalidating structure yourself.

i hesitate use exceptions handle invalid input. legitimate use of exceptions, fear exception relied on validation. exceptions resource intensive, , should hit if there's needs fixed. it's intentions , how trust people using class right thing (and validate before sending you).