GabrielTofvesson/libRefTools
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master'

Browse Source 
# Conflicts:
#	src/com/tofvesson/reflection/SafeReflection.java
This commit is contained in:
Gabriel Tofvesson 2016-11-13 15:19:53 +01:00
commit fec11f3a47
6 changed files with 301 additions and 265 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
src/com/tofvesson/async/Async.java
View File

@ -6,9 +6,24 @@ import java.lang.reflect.Method;
@SuppressWarnings({"WeakerAccess", "unused", "unchecked"})
public class Async<T> {
/**
* Thread running background task.
*/
Thread task;
volatile T ret; // Assigned using native method
/**
* Return value/ constructed object.
*/
volatile T ret;
/**
* Status indicators.
*/
volatile boolean complete = false, failed = false; // Used by anonymous class, therefore not private
/**
* Exception to throw in case something goes wrong.
*/
volatile Throwable t;
/**
@ -19,12 +34,20 @@ public class Async<T> {
* @param params Required parameters.
*/
public Async(final Object o, final Method method, final Object... params){
method.setAccessible(true);
task = new Thread(()-> {
try { ret = (T) method.invoke(o, params); complete = true; } catch (Throwable t1) { if(!failed) { failed = true; t=t1; } }
method.setAccessible(true); // Ensure that no crash occurs
task = new Thread(()-> { // Create a new thread
try {
ret = (T) method.invoke(o, params); // Invoke given method
complete = true; // Notify all threads who are checking
} catch (Throwable t1) { // Prepare for failure
if(!failed) { // Checks if task was canceled
failed = true; // Notifies all threads that task failed
t=t1; // Makes error accessible to be thrown
}
}
});
task.setDaemon(true);
task.start();
task.setDaemon(true); // Ensure that process dies with program
task.start(); // Start task
}
/**
@ -53,12 +76,20 @@ public class Async<T> {
* @param params Parameters to use when instantiaing object.
*/
public Async(final Constructor<T> c, final Object... params){
c.setAccessible(true);
task = new Thread(() -> {
try { ret = c.newInstance(params); complete = true; } catch (Throwable t1) { if(!failed) { failed = true; t=t1; } }
c.setAccessible(true); // Ensure that constructor can be called
task = new Thread(() -> { // Creates a new thread for asynchronous execution
try {
ret = c.newInstance(params); // Create a new instance: invoke "<init>" method
complete = true; // Notify all threads that async is finished
} catch (Throwable t1) { // Handle crash
if(!failed) { // Ensure that crash wasn't called by cancel()
failed = true; // Notify all threads that error has been encountered
t=t1; // Make throwable accessible to be thrown in caller thread
}
}
});
task.setDaemon(true);
task.start();
task.setDaemon(true); // Ensure that thread dies with program
task.start(); // Start construction
}
/**
@ -67,7 +98,10 @@ public class Async<T> {
*/
public Async(Constructor<T> c){ this(c, (Object[]) null); }
Async() {task = null;} // Only package-scoped because it should only be used when overriding standard construction
/**
* WARNING: Package-scoped because it should only be used when overriding standard construction. Should not bw used haphazardly!
*/
Async() {task = null;}
/**
* Await completion of async task. Blocks thread if task isn't complete.
@ -85,18 +119,19 @@ public class Async<T> {
* Checks if async task is still running.
* @return True if it's still running.
*/
public boolean isAlive(){ return task.isAlive(); }
public boolean isAlive(){ return task.isAlive(); } // Check if thread is still alive which directly determines if process is alive since Async is a wrapper of Thread
/**
* Cancels async operation if it's still alive.
*/
public void cancel(){
if(task.isAlive()){
// Set values before interrupting to prevent InterruptedException from
// being propagated and thrown in the main thread
// Set values before interrupting to prevent InterruptedException from
// being propagated and thrown in the main thread
t=null;
failed = true; // Creates a unique and identifiable state
task.stop();
failed = true; // Creates a unique and identifiable state
//noinspection deprecation
task.stop(); // Force-stop thread
}
}
}

4
src/com/tofvesson/async/WorkerThread.java
View File

@ -56,7 +56,7 @@ public class WorkerThread extends Thread {
* @param params Parameters for method.
* @return A UID corresponding to the queued instruction.
*/
public long enqueue(Object invokeOn, Method m, Object... params){
public long push(Object invokeOn, Method m, Object... params){
m.setAccessible(true);
long id;
do{ id = ThreadLocalRandom.current().nextLong(); }while(ids.contains(id));
@ -73,6 +73,7 @@ public class WorkerThread extends Thread {
public Object pop(long id){
if(!ids.contains(id)) return null;
if(Thread.currentThread() == this) throw new RuntimeException("Attempting to await result in worker thread! This causes the thread to lock.");
//noinspection StatementWithEmptyBody
while(!output.containsKey(id)) ; // Block caller thread until result is received
Object o = output.get(id);
output.remove(id);
@ -93,6 +94,7 @@ public class WorkerThread extends Thread {
*/
public void stopForced(){
alive = false;
//noinspection deprecation
stop();
}
}

43
src/com/tofvesson/collections/ShiftingList.java
View File

@ -4,8 +4,9 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;
@SuppressWarnings({"unchecked", "ReturnOfInnerClass"})
@SuppressWarnings({"unchecked", "ReturnOfInnerClass", "unused"})
public class ShiftingList<E> implements List<E> {
/**
* Holder for entries. Dur to reasons, the array holds objects.
@ -55,7 +56,7 @@ public class ShiftingList<E> implements List<E> {
@Override
public boolean contains(Object o) {
if(o==empty) return false;
for(Object o1 : entries) if(o.equals(o1)) return true;
for(int i = 0; i<pop; ++i) if((o!=null && o.equals(entries[i])) || (o==null && entries[i]==empty)) return true;
return false;
}
@ -75,6 +76,7 @@ public class ShiftingList<E> implements List<E> {
@Override
public boolean add(E e) {
if(contains(e)) return false;
preparePopulate(1);
entries[0] = e!=null?e:empty;
pop=pop!=maxSize?pop+1:pop;
@ -104,28 +106,25 @@ public class ShiftingList<E> implements List<E> {
@Override
public boolean addAll(Collection<? extends E> c) {
ArrayList<? extends E> l = new ArrayList<>(c);
preparePopulate(c.size());
for(int i = 0; i<Math.min(entries.length, c.size()); ++i) entries[i] = l.get(i);
pop=Math.min(pop+c.size(), maxSize);
ArrayList<? super E> l = c.stream().filter(e -> !contains(e)).collect(Collectors.toCollection(ArrayList::new));
if(l.size()>maxSize) for(int i = maxSize; i<l.size(); ++i) l.remove(i);
preparePopulate(l.size());
for(int i = 0; i<l.size(); ++i) entries[i] = l.get(i);
pop=Math.min(pop+l.size(), maxSize);
return true;
}
@Override
public boolean addAll(int index, Collection<? extends E> c) {
if(index>=maxSize) return false;
if(index>=entries.length || index<0 || c.size()==0) return false;
ArrayList<Object> l = new ArrayList<>(c);
for(int i = 0; i<l.size(); ++i) if(l.get(i)==null) l.set(i, empty);
if(pop+l.size()>maxSize) for(int i = pop+l.size()-maxSize; i<l.size(); ++i) l.remove(l.size());
pop = pop==maxSize?pop:pop+l.size();
if(pop==entries.length) adaptLoad();
if(index==entries.length-1){
entries[index] = l.get(0);
return true;
}
if(l.size()+index<entries.length)
System.arraycopy(entries, index, entries, index+1, entries.length-(index+l.size()));
for(int i = index; i<Math.min(index+l.size(), entries.length); ++i) entries[i] = l.get(i);
ArrayList<? super E> l = c.stream().filter(e -> !contains(e)).collect(Collectors.toCollection(ArrayList::new));
if(index+l.size()>maxSize) for(int i = maxSize-index; i<l.size(); ++i) l.remove(i);
adaptLoad(l.size());
pop = pop+l.size() >= maxSize ? pop : pop+l.size();
if(l.size()+index<entries.length) System.arraycopy(entries, index, entries, l.size()+1, entries.length-l.size()-1);
for(int i = 0; i<l.size(); ++i) entries[i+index] = l.get(i);
shift(); // Ensure no misalignment happens
return true;
}
@ -197,11 +196,11 @@ public class ShiftingList<E> implements List<E> {
*/
protected void shift(){
for(int i = 0; i<entries.length; ++i)
if(entries[i]==null && i!=pop-1)
if(entries[i]==null && i!=pop)
for(int j = i; j<entries.length; ++j)
if(entries[j]!=null){
entries[i] = entries[j];
entries[i] = null;
entries[j] = null;
break;
}else if(j+1==entries.length) return; // Found all populated entries
}
@ -228,7 +227,7 @@ public class ShiftingList<E> implements List<E> {
@Override
public void add(int index, E element) {
if(index>=entries.length || index<0) return;
if(index>=entries.length || index<0 || contains(element)) return;
Object o = element==null?empty:element;
pop = pop==maxSize?pop:pop+1;
if(pop==entries.length) adaptLoad();
@ -286,7 +285,7 @@ public class ShiftingList<E> implements List<E> {
protected int counter = 0;
private final int pop;
private final Object[] entries;
public Iterator(int pop, Object[] entries){ this.pop = pop; this.entries = entries; }
public Iterator(int pop, Object[] entries){ this.pop = pop; this.entries = entries; }
@Override public boolean hasNext() { return counter<pop; }
@Override public V next() { return entries[counter++]==empty?null:(V)entries[counter-1]; }
}

114
src/com/tofvesson/reflection/EnumDefinition.java
View File

@ -1,114 +0,0 @@
package com.tofvesson.reflection;
import java.util.HashMap;
/**
* A definition for custom enum creation.
*/
public class EnumDefinition {
HashMap<Object, Class> params = new HashMap<>(); // Assign a specific type to each parameter
/**
* Put an object in the parameter list.
* @param value The parameter to supply. (Type is derived automatically)
* @return A reference to the EnumDefinition object this method was called on (for chaining).
*/
public EnumDefinition putObject(Object value){
params.put(value, value.getClass());
return this;
}
/**
* Put a primitive value in the parameter list.
* @param autoBoxed An autoboxed version of the parameter. (For example putPrimitive(5) will automatically become Integer)
* @return A reference to the EnumDefinition object this method was called on (for chaining).
* @throws NoSuchFieldException
*/
public EnumDefinition putPrimitive(Object autoBoxed) throws NotAutoBoxedException{
// All autoboxed versions of primitives have a reference to their boxed primitive
try {
params.put(autoBoxed, autoBoxed.getClass().getDeclaredField("value").getType());
}catch(Exception e){ throw new NotAutoBoxedException(); }
return this;
}
/**
* Safe wrapper of {@link #putPrimitive(Object)} for boolean.
* @param b Boolean parameter.
* @return A reference to the EnumDefinition object this method was called on (for chaining).
*/
public EnumDefinition putBoolean(boolean b){
try { return putPrimitive(b); } catch (NotAutoBoxedException e) { }
return this;
}
/**
* Safe wrapper of {@link #putPrimitive(Object)} for byte.
* @param b Byte parameter.
* @return A reference to the EnumDefinition object this method was called on (for chaining).
*/
public EnumDefinition putByte(byte b){
try { return putPrimitive(b); } catch (NotAutoBoxedException e) { }
return this;
}
/**
* Safe wrapper of {@link #putPrimitive(Object)} for char.
* @param c Character parameter.
* @return A reference to the EnumDefinition object this method was called on (for chaining).
*/
public EnumDefinition putChar(char c){
try { return putPrimitive(c); } catch (NotAutoBoxedException e) { }
return this;
}
/**
* Safe wrapper of {@link #putPrimitive(Object)} for short.
* @param s Short parameter.
* @return A reference to the EnumDefinition object this method was called on (for chaining).
*/
public EnumDefinition putShort(short s){
try { return putPrimitive(s); } catch (NotAutoBoxedException e) { }
return this;
}
/**
* Safe wrapper of {@link #putPrimitive(Object)} for int.
* @param i Integer parameter.
* @return A reference to the EnumDefinition object this method was called on (for chaining).
*/
public EnumDefinition putInt(int i){
try { return putPrimitive(i); } catch (NotAutoBoxedException e) { }
return this;
}
/**
* Safe wrapper of {@link #putPrimitive(Object)} for long.
* @param l Long parameter.
* @return A reference to the EnumDefinition object this method was called on (for chaining).
*/
public EnumDefinition putLong(long l){
try { return putPrimitive(l); } catch (NotAutoBoxedException e) { }
return this;
}
/**
* Safe wrapper of {@link #putPrimitive(Object)} for float.
* @param f Floating point parameter.
* @return A reference to the EnumDefinition object this method was called on (for chaining).
*/
public EnumDefinition putFloat(float f){
try { return putPrimitive(f); } catch (NotAutoBoxedException e) { }
return this;
}
/**
* Safe wrapper of {@link #putPrimitive(Object)} for double.
* @param d Double parameter.
* @return A reference to the EnumDefinition object this method was called on (for chaining).
*/
public EnumDefinition putDouble(double d){
try { return putPrimitive(d); } catch (NotAutoBoxedException e) { }
return this;
}
}

111
src/com/tofvesson/reflection/Helper.java
View File

@ -1,111 +0,0 @@
package com.tofvesson.reflection;
import sun.misc.Unsafe;
import sun.reflect.ConstructorAccessor;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Helper {
/**
* Allows you to create a completely custom Enum value. If the supplied value already exists, it will be returned.
* will not be created; the value of the existing one will be updated.
* @param clazz The class to attribute the new enum to.
* @param addToValuesArray Whether or not to update the internal, "immutable" values array with the new value (ignored if value already exists).
* @return A new/existing enum.
*/
@SuppressWarnings("unchecked")
public static <T extends Enum<T>> T customEnum(Class<T> clazz, boolean addToValuesArray, String name, EnumDefinition def){
T u;
try {
// Get a reference to the static method values() and get values
Method v = clazz.getDeclaredMethod("values");
v.setAccessible(true);
T[] values = (T[]) v.invoke(null);
// Return object if it already exists
for(T u2 : values) if(u2.name().equals(name)) return u2;
// Generate enum parameter definition
Class[] paramList = new Class[def.params.size()+2];
paramList[0] = String.class; // Name
paramList[1] = int.class; // Ordinal
int iterator = paramList.length;
for(Class c : def.params.values()) paramList[--iterator] = c; // Shit's fucking reversed
// Get enum constructor (inherited from Enum.class)
Constructor c = clazz.getDeclaredConstructor(paramList);
c.setAccessible(true);
Method m = Constructor.class.getDeclaredMethod("acquireConstructorAccessor");
m.setAccessible(true);
// Get constructor accessor since Constructor.newInstance throws an exception because Enums are "immutable"
ConstructorAccessor access = (ConstructorAccessor) m.invoke(c);
Object[] parameters = new Object[def.params.size()+2];
parameters[0] = name;
parameters[1] = values.length;
iterator = parameters.length;
for(Object o : def.params.keySet()) parameters[--iterator] = o;
// Create new instance of enum with valid name and ordinal
u = (T) access.newInstance(parameters);
// Get the final name field from Enum.class and make it temporarily modifiable
Field f = Enum.class.getDeclaredField("name");
f.setAccessible(true);
// Rename the newly created enum to the requested name
f.set(u, name);
if(!addToValuesArray) return u; // Stops here if
// Get the current values field from Enum (a bitch to modify)
f = clazz.getDeclaredField("$VALUES");
f.setAccessible(true);
T[] $VALUES = (T[]) Array.newInstance(clazz, values.length+1);
System.arraycopy(values, 0, $VALUES, 0, values.length); // Copy over values from old array
$VALUES[values.length] = u; // Add out custom enum to our local array
// Start doing magic by getting an instance of sun.reflect.UnsafeQualifiedStaticObjectFieldAccessorImpl.class
// Class is package-local so we can't reference it by anything other than Object
m = Field.class.getDeclaredMethod("getFieldAccessor", Object.class);
m.setAccessible(true);
Object UQSOFAImpl = m.invoke(f, u);
// Get "isReadOnly" flag ($VALUES is always read-only even if Field.setAccessible(true) is called)
// Flag is located in superclass (sun.reflect.UnsafeQualifiedStaticFieldAccessorImpl.class (also fucking package-local))
// Set flag to 'false' to allow for modification against Java's will
Field f1 = UQSOFAImpl.getClass().getSuperclass().getDeclaredField("isReadOnly");
f1.setAccessible(true);
f1.setBoolean(UQSOFAImpl, false);
// Invoke set() method on UnsafeQualifiedStaticObjectFieldAccessorImpl object which sets the
// private field $VALUES to our new array
m = UQSOFAImpl.getClass().getDeclaredMethod("set", Object.class, Object.class);
m.setAccessible(true);
m.invoke(UQSOFAImpl, f, $VALUES);
} catch (Exception wrongParams) { throw new RuntimeException(wrongParams); }
return u;
}
/**
* Create a new object without the hassle of having to construct it. WARNING: Not usually a good idea.
* @param clazz Class to instantiate.
* @return An object instance of the supplied class that hasn't been constructed.
* @throws InstantiationException
*/
public static <T> T create(Class<T> clazz) throws InstantiationException{
try {
Field f = Unsafe.class.getDeclaredField("theUnsafe");
f.setAccessible(true);
//noinspection unchecked
return (T) ((Unsafe) f.get(null)).allocateInstance(clazz);
} catch (NoSuchFieldException | IllegalAccessException e) {
System.err.println("Whatever you did, it was VERY wrong! Stop it!");
e.printStackTrace();
return null;
}
}
}

225
src/com/tofvesson/reflection/SafeReflection.java
View File

@ -1,8 +1,14 @@
package com.tofvesson.reflection;
import java.lang.reflect.Constructor;
import sun.misc.Unsafe;
import sun.reflect.ConstructorAccessor;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
/**
* Safe tools to help simplify code when dealing with reflection.
@ -41,6 +47,19 @@ public class SafeReflection {
return null;
}
private static final Unsafe unsafe;
static{
Unsafe u = null;
try{
Field f = Unsafe.class.getDeclaredField("theUnsafe");
f.setAccessible(true);
u = (Unsafe) f.get(null);
}catch(Exception ignored){} // Exception is never thrown
unsafe = u;
}
/**
* Gets the method from the defined class by name and parameters.
* Method is accessible.
@ -164,4 +183,210 @@ public class SafeReflection {
* @return File if class file exists.
*/
public static java.io.File getClassFile(Class c){ return new java.io.File(c.getResource(c.getSimpleName()+".class").getFile()); }
/**
* Allows you to create a completely custom Enum value. If the supplied value already exists, it will be returned.
* will not be created; the value of the existing one will be updated.
* @param clazz The class to attribute the new enum to.
* @param addToValuesArray Whether or not to update the internal, "immutable" values array with the new value (ignored if value already exists).
* @return A new/existing enum.
*/
@SuppressWarnings("unchecked")
public static <T extends Enum<T>> T customEnum(Class<T> clazz, boolean addToValuesArray, String name, EnumDefinition def){
T u;
try {
// Get a reference to the static method values() and get values
Method v = clazz.getDeclaredMethod("values");
v.setAccessible(true);
T[] values = (T[]) v.invoke(null);
// Return object if it already exists
for(T u2 : values) if(u2.name().equals(name)) return u2;
// Generate enum parameter definition
Class[] paramList = new Class[def.params.size()+2];
paramList[0] = String.class; // Name
paramList[1] = int.class; // Ordinal
int iterator = paramList.length;
for(Class c : def.params.values()) paramList[--iterator] = c; // Shit's fucking reversed
// Get enum constructor (inherited from Enum.class)
Constructor c = clazz.getDeclaredConstructor(paramList);
c.setAccessible(true);
Method m = Constructor.class.getDeclaredMethod("acquireConstructorAccessor");
m.setAccessible(true);
// Get constructor accessor since Constructor.newInstance throws an exception because Enums are "immutable"
ConstructorAccessor access = (ConstructorAccessor) m.invoke(c);
Object[] parameters = new Object[def.params.size()+2];
parameters[0] = name;
parameters[1] = values.length;
iterator = parameters.length;
for(Object o : def.params.keySet()) parameters[--iterator] = o;
// Create new instance of enum with valid name and ordinal
u = (T) access.newInstance(parameters);
// Get the final name field from Enum.class and make it temporarily modifiable
Field f = Enum.class.getDeclaredField("name");
f.setAccessible(true);
// Rename the newly created enum to the requested name
f.set(u, name);
if(!addToValuesArray) return u; // Stops here if
// Get the current values field from Enum (a bitch to modify)
f = clazz.getDeclaredField("$VALUES");
f.setAccessible(true);
T[] $VALUES = (T[]) Array.newInstance(clazz, values.length+1);
System.arraycopy(values, 0, $VALUES, 0, values.length); // Copy over values from old array
$VALUES[values.length] = u; // Add out custom enum to our local array
// Start doing magic by getting an instance of sun.reflect.UnsafeQualifiedStaticObjectFieldAccessorImpl.class
// Class is package-local so we can't reference it by anything other than Object
m = Field.class.getDeclaredMethod("getFieldAccessor", Object.class);
m.setAccessible(true);
Object UQSOFAImpl = m.invoke(f, u);
// Get "isReadOnly" flag ($VALUES is always read-only even if Field.setAccessible(true) is called)
// Flag is located in superclass (sun.reflect.UnsafeQualifiedStaticFieldAccessorImpl.class (also fucking package-local))
// Set flag to 'false' to allow for modification against Java's will
Field f1 = UQSOFAImpl.getClass().getSuperclass().getDeclaredField("isReadOnly");
f1.setAccessible(true);
f1.setBoolean(UQSOFAImpl, false);
// Invoke set() method on UnsafeQualifiedStaticObjectFieldAccessorImpl object which sets the
// private field $VALUES to our new array
m = UQSOFAImpl.getClass().getDeclaredMethod("set", Object.class, Object.class);
m.setAccessible(true);
m.invoke(UQSOFAImpl, f, $VALUES);
} catch (Exception wrongParams) { throw new RuntimeException(wrongParams); }
return u;
}
/**
* Create a new object without the hassle of having to construct it. WARNING: Not usually a good idea.
* @param clazz Class to instantiate.
* @return An object instance of the supplied class that hasn't been constructed.
* @throws InstantiationException Thrown if instantiating the object fails for some reason.
*/
public static <T> T createNewObject(Class<T> clazz) throws InstantiationException{
//noinspection unchecked
return (T) unsafe.allocateInstance(clazz);
}
/**
* A definition for custom enum creation.
*/
public static class EnumDefinition {
HashMap<Object, Class> params = new HashMap<>(); // Assign a specific type to each parameter
/**
* Put an object in the parameter list.
* @param value The parameter to supply. (Type is derived automatically)
* @return A reference to the EnumDefinition object this method was called on (for chaining).
*/
public EnumDefinition putObject(Object value){
params.put(value, value.getClass());
return this;
}
/**
* Put a primitive value in the parameter list.
* @param autoBoxed An autoboxed version of the parameter. (For example putPrimitive(5) will automatically become Integer)
* @return A reference to the EnumDefinition object this method was called on (for chaining).
* @throws NotAutoBoxedException Thrown if a value expected to be autoboxed isn't autoboxed.
*/
public EnumDefinition putPrimitive(Object autoBoxed) throws NotAutoBoxedException{
// All autoboxed versions of primitives have a reference to their boxed primitive
try {
params.put(autoBoxed, autoBoxed.getClass().getDeclaredField("value").getType());
}catch(Exception e){ throw new NotAutoBoxedException(); }
return this;
}
/**
* Safe wrapper of {@link #putPrimitive(Object)} for boolean.
* @param b Boolean parameter.
* @return A reference to the EnumDefinition object this method was called on (for chaining).
*/
public EnumDefinition putBoolean(boolean b){
try { return putPrimitive(b); } catch (NotAutoBoxedException e) { }
return this;
}
/**
* Safe wrapper of {@link #putPrimitive(Object)} for byte.
* @param b Byte parameter.
* @return A reference to the EnumDefinition object this method was called on (for chaining).
*/
public EnumDefinition putByte(byte b){
try { return putPrimitive(b); } catch (NotAutoBoxedException e) { }
return this;
}
/**
* Safe wrapper of {@link #putPrimitive(Object)} for char.
* @param c Character parameter.
* @return A reference to the EnumDefinition object this method was called on (for chaining).
*/
public EnumDefinition putChar(char c){
try { return putPrimitive(c); } catch (NotAutoBoxedException e) { }
return this;
}
/**
* Safe wrapper of {@link #putPrimitive(Object)} for short.
* @param s Short parameter.
* @return A reference to the EnumDefinition object this method was called on (for chaining).
*/
public EnumDefinition putShort(short s){
try { return putPrimitive(s); } catch (NotAutoBoxedException e) { }
return this;
}
/**
* Safe wrapper of {@link #putPrimitive(Object)} for int.
* @param i Integer parameter.
* @return A reference to the EnumDefinition object this method was called on (for chaining).
*/
public EnumDefinition putInt(int i){
try { return putPrimitive(i); } catch (NotAutoBoxedException e) { }
return this;
}
/**
* Safe wrapper of {@link #putPrimitive(Object)} for long.
* @param l Long parameter.
* @return A reference to the EnumDefinition object this method was called on (for chaining).
*/
public EnumDefinition putLong(long l){
try { return putPrimitive(l); } catch (NotAutoBoxedException e) { }
return this;
}
/**
* Safe wrapper of {@link #putPrimitive(Object)} for float.
* @param f Floating point parameter.
* @return A reference to the EnumDefinition object this method was called on (for chaining).
*/
public EnumDefinition putFloat(float f){
try { return putPrimitive(f); } catch (NotAutoBoxedException e) { }
return this;
}
/**
* Safe wrapper of {@link #putPrimitive(Object)} for double.
* @param d Double parameter.
* @return A reference to the EnumDefinition object this method was called on (for chaining).
*/
public EnumDefinition putDouble(double d){
try { return putPrimitive(d); } catch (NotAutoBoxedException e) { }
return this;
}
}
}