Print

---

Hi!

I have been trying to implement a simple own Properties Class to be able 
to declare my Properties in a way I like better than declaring lots of 
methods.

Maybe one could think about adding the possibility of Java Annotations 
to declare the domain, description etc.? Or would this break with Masons 
JDK compatbility target?

The disadvantage of reflection would still be that there is not ordering 
of the properties - at least I don't think that reflecting on a class 
would guarantee any ordering of the properties that reflects the 
ordering in the code.

Anyway, I have produce a class derive from sim.util.Properties that 
delivers the information and made my inspected class implement 
Propertied. For the source code see below. It' in Scala but that should 
not be the reason for any of my problems.

When using this combination with SimpleInspector and a Domain-Slider I 
get into an endless loop in SimpleInspector of
- PropertyField.newValue calling
- SimpleInspector.this.state.controller.refresh() calling
- SimpleInspector.updateInspector() calling
- SimpleInspector.generateProperties(start) calling
- PropertyField.newValue calling
...


The responsible lines of code in SimpleInspector.generateProperties are:

if (SimpleInspector.this.state.controller != null)
	SimpleInspector.this.state.controller.refresh();

If I just comment them out everything seems to be just fine. There is 
not problems with the display not refreshing whatsoever.

Strange enough this kind of endless loop does not happen with the 
standard SimpleProperties generated by Reflection. There is some looping 
going on but it stops after some rounds. There has to be some race 
condition or something alike that by chance works out fine. Or is there 
some other reason? I couldn't figure it out.

Any ideas? Maybe this is just a bug. Then it would be fine and 
commenting out the two lines of code above would fix it.

regards
roman

-------------------------
Custom Properties code:
-------------------------

package at.granul.mason

import scala.collection.mutable
import java.lang.reflect.Method
import sim.util.{Properties, Propertied}
import scala.Boolean
import java.lang.Class

import at.granul.mason.Property
import java.text.NumberFormat

/**
  * Created by Roman Seidl on 28.01.14.
  */

trait DeclaredPropertied extends Propertied {
   var ___properties = DeclaredProperties(this)

   override def properties(): Properties = ___properties

   def setProperties(p: PropertyElement*) : DeclaredProperties = 
___properties.setProperties(p :_*)

}

abstract class PropertyElement(nam: String){
   val name = nam
}

case class Property(override val name : String, var title : String = 
null, var domain : AnyRef = null, var isReadOnly : Boolean = false) 
extends PropertyElement(name) {
   if (title == null)
     title = name

   def dom(lower: Long, upper: Long) : Property = {
     domain = new sim.util.Interval(lower, upper)
     this
   }

   def dom(lower: Double, upper: Double) : Property = {
     domain = new sim.util.Interval(lower, upper)
     this
   }

   def dom(dom: Array[String]) : Property = {
     domain = dom
     this
   }


   def caption(tf : String) : Property = title(tf)
   def text(tf : String) : Property = title(tf)
   def title(tf : String) : Property = {
     title = tf
     this
   }

   def readOnly = ro
   def ro : Property = {
     isReadOnly = true
     this
   }

   //override def toString: String = super.toString + " Domain: " + " 
Domain: " + domain + " Field: " + targetField
}


case class DeclaredProperties(obj: Object, p : PropertyElement*) extends 
sim.util.Properties {

   val propertyElements = mutable.Buffer[PropertyElement]()
   val elements = mutable.Buffer[Property]()
   this.setProperties(p :_*)

   var getMethods = mutable.Buffer[Method]()
   var setMethods = mutable.Buffer[Method]()

   def setProperties(p : PropertyElement*) : DeclaredProperties = {
     for (pe <- p.iterator)
       this.+(pe)
     this
   }

   def +(prop : PropertyElement) : DeclaredProperties = {
     propertyElements += prop
     if( prop.isInstanceOf[Property]){
       elements += prop.asInstanceOf[Property]

       val getMethodStub = obj.getClass.getMethods.find(m => {m.getName 
== prop.name || m.getName == ("get" + prop.name.capitalize) || m.getName 
== ("is" + prop.name.capitalize)})
       val getMethod = if(getMethodStub != null) getMethodStub.get else null
       getMethods += getMethod

       val setMethodStub = obj.getClass.getMethods.find(m => {(m.getName 
== prop.name + "_$eq") || m.getName == ("set" + prop.name.capitalize)})
       val setMethod = if(setMethodStub != null) setMethodStub.get else null
       setMethods += setMethod
     }
     this
   }


   def numProperties(): Int = elements.size

   def isVolatile: Boolean = true


   def getValue(index: Int): Object = {
     val method = getMethods(index)
     if(method != null) method.invoke(obj) else null
   }

   def _setValue(index: Int, value: Object): Object = {
/*    if(isReadWrite(index: Int))
     {*/
       var method = setMethods(index)
       if(method != null) {
         method.invoke(obj, value.asInstanceOf[AnyRef])
         getValue(index)
       } else null
/*    }
     getValue(index)*/
   }

   override def getDomain(index: Int): AnyRef = elements(index).domain

   def isReadWrite(index: Int): Boolean = !elements(index).isReadOnly

   def getName(index: Int): String = elements(index).title

   def getType(index: Int): Class[_] = {
     val method = getMethods(index)
     if(method != null) method.getReturnType else null
   }

   override def toString: String = super.toString + " obj: " + obj + " 
elements:"+ propertyElements
}