public ObjectDef getObjectDef() {
try {
Node ref =
Nodes.lookup(
Client.getRSData().getObjectDefLoaders().getDefCache().getTable(), (long) getID());
if (ref == null) return null;
if (ref.currentObject
.getClass()
.getName()
.equals(Data.indentifiedClasses.get("SoftReference").getClassName())) {
SoftReference sr = new SoftReference(ref.currentObject);
Object def = sr.getSoftReference().get();
return new ObjectDef(def);
} else if (ref.currentObject
.getClass()
.getName()
.equals(Data.indentifiedClasses.get("HardReference").getClassName())) {
HardReference hr = new HardReference(ref.currentObject);
Object def = hr.getHardReference();
return new ObjectDef(def);
}
} catch (Exception e) {
}
return null;
}
// returns null if we don't have anything free
private static synchronized Class getFreeVMImplClass() {
while (!freeVMClasses.isEmpty()) {
SoftReference ref = (SoftReference) freeVMClasses.remove(0);
Object o = ref.get();
if (o != null) {
if (DEBUG) {
System.out.println("re-using loaded VirtualMachineImpl");
}
return (Class) o;
}
}
return null;
}
private ObjectMapper mapper() {
if (mapperRef == null) {
mapperRef = new SoftReference<ObjectMapper>(new ObjectMapper());
}
ObjectMapper mapper = mapperRef.get();
if (mapper == null) {
mapper = new ObjectMapper();
mapperRef = new SoftReference<ObjectMapper>(mapper);
}
return mapper;
}
/**
* Checks that one can veto a property change.
*
* @param persistent Whether to make strong references to triggers, to prevent them from being
* garbage collected
* @param save Whether to keep a pointer to each trigger on the stack, to prevent them from being
* garbage collected
*/
private void checkVetoChangeValue(final boolean persistent, boolean save) throws Exception {
final MyProperties props = new MyProperties();
String path = "test.mondrian.properties.veto.change.value";
IntegerProperty intProp = new IntegerProperty(props, path, -1);
assertTrue("Check property value NOT false", (intProp.get() == -1));
// now explicitly set the property
props.setProperty(path, "-1");
String v = props.getProperty(path);
assertTrue("Check property value is null", (v != null));
assertTrue("Check property value is -1", (Integer.decode(v).intValue() == -1));
final State3 state = new State3();
state.callCounter = 0;
// Add a trigger. Keep it on the stack to prevent it from being
// garbage-collected.
final Trigger trigger1 =
new Trigger() {
public boolean isPersistent() {
return persistent;
}
public int phase() {
return Trigger.PRIMARY_PHASE;
}
public void execute(Property property, String value) {
state.triggerCalled = true;
state.triggerValue = value;
}
};
intProp.addTrigger(trigger1);
SoftReference<Trigger> ref1 = new SoftReference<Trigger>(trigger1);
final Trigger trigger2 =
new Trigger() {
public boolean isPersistent() {
return persistent;
}
public int phase() {
return Trigger.SECONDARY_PHASE;
}
public void execute(Property property, String value) throws VetoRT {
// even numbers are rejected
state.callCounter++;
int ival = Integer.decode(value).intValue();
if ((ival % 2) == 0) {
// throw on even
throw new VetoRT("have a nice day");
} else {
// ok
}
}
};
intProp.addTrigger(trigger2);
SoftReference<Trigger> ref2 = new SoftReference<Trigger>(trigger2);
// Holder object prevents triggers from being garbage-collected even
// if persistent=false.
Object saver;
if (save) {
saver = new Trigger[] {trigger1, trigger2};
} else {
saver = "dummy";
}
for (int i = 0; i < 10; i++) {
// reset values
state.triggerCalled = false;
state.triggerValue = null;
boolean isEven = ((i % 2) == 0);
try {
props.setProperty(path, Integer.toString(i));
// If triggers have been gc'ed - only possible if persistent =
// save = false - then we can't guarantee that state has been
// changed.
if (!persistent && !save && ((ref1.get() == null) || (ref2.get() == null))) {
continue;
}
// should only be here if odd
if (isEven) {
fail("Did not pass odd number: " + i);
}
int val = Integer.decode(state.triggerValue).intValue();
assertTrue("Odd counter not value", (i == val));
} catch (Trigger.VetoRT ex) {
// If triggers have been gc'ed - only possible if persistent =
// save = false - then we can't guarantee that state has been
// changed.
if (!persistent && !save && ((ref1.get() == null) || (ref2.get() == null))) {
continue;
}
// Trigger rejects even numbers so if even its ok
if (!isEven) {
fail("Did not reject even number: " + i);
}
int val = Integer.decode(state.triggerValue).intValue();
// the property value was reset to the previous value of "i"
// so we add "1" to it to get the current value.
if (i != (val + 1)) {
fail("Even counter not value plus one: " + i + ", " + val);
}
}
}
// Refer to the saver object at the end of the routine so that it
// cannot be garbage-collected. (Some VMs try to be smart.)
assertTrue(saver != null);
}
