public class Referenceable<T> {
private T obj;
private Referenceable(T t) { obj = t; }
public static <U> Referenceable<U> ref(U u){
return new Referenceable<U>(u);
}
public T dereference() {
return obj;
}
public T dereference(T newT) { // Should be used for reassigning underlying object
return obj = newT;
}
}
This simple class allows functions like swap or exchange to be implemented for non-primitive types generically. An example implementation of swap with Referenceable:
<T> void swap(Referenceable<T> first, Referenceable<T> second){
var tmp = first.dereference();
first.dereference(second);
second.dereference(tmp);
}
Here is example usage:
Referenceable<Integer> ri1 = Referenceable.ref(new Integer(21)),
ri2 = Referenceable.ref(new Integer(42)),
rn = Referenceable.ref(null); // can reference null objects
System.out.prinln(ri1.dereference().toString(), ri2.dereference().toString());
SomeUtilClass.swap(ri1, ri2);
System.out.prinln(ri1.dereference().toString(), ri2.dereference().toString());
rn.dereference(new Integer(69)); // more efficient than rn = Referenceable.ref(new Integer(69)
Integer i = rn.dereference();
Questions:
Referenceableis a bit of mouthful: should I change the name?Should I directly use the constructor instead of a factory function?
Could
OptionalreplaceReferenceable, making my class useless?Though I doubt it, is there any way for me to make the syntax look something more like this:
Referenceable<Integer> ri1 = new Integer(21), // Automatically wraps into Referenceable.ref(new Integer(21)) ri2 = new Integer(42), // ditto rn = Referenceable.ref(null); // ref required because of ambiguity System.out.prinln(ri1.dereference().toString(), ri2.dereference().toString()); //dereference required so Referenceable.toString() is not called SomeUtilClass.swap(ri1, ri2); System.out.prinln(ri1.dereference().toString(), ri2.dereference().toString()); // ditto Integer i = rn;
