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

- Added tests

Browse Source 
- Refactored package to match my site name
- Renamed "logging" package to "stream"
- Fixed various bugs
- Fixed issues with illegal reflective access
- Added proper throwable for when a dangerous threaded action happens in async
- Added more reflective tools
  - Added ability to auto-generate simple wrapper classes
  - Added tools for converting enums to a flag-like system
  - Added annotation scanning for a supplied classloader
- Properly renamed module to "libRefTools"
This commit is contained in:
Gabriel Tofvesson 2018-01-04 01:10:08 +01:00
parent 7e6f6b7135
commit d4c53993ec
35 changed files with 734 additions and 840 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.idea/artifacts/libRefTools_jar.xml generated
View File

@ -2,7 +2,7 @@
<artifact type="jar" name="libRefTools:jar"> <artifact type="jar" name="libRefTools:jar">
<output-path>$PROJECT_DIR$/out/artifacts/libRefTools_jar</output-path> <output-path>$PROJECT_DIR$/out/artifacts/libRefTools_jar</output-path>
<root id="archive" name="libRefTools.jar"> <root id="archive" name="libRefTools.jar">
<element id="module-output" name="libGTools" /> <element id="module-output" name="libRefTools" />
<element id="dir-copy" path="$PROJECT_DIR$/src" /> <element id="dir-copy" path="$PROJECT_DIR$/src" />
<element id="file-copy" path="$PROJECT_DIR$/README.txt" /> <element id="file-copy" path="$PROJECT_DIR$/README.txt" />
<element id="file-copy" path="$PROJECT_DIR$/COPYING.txt" /> <element id="file-copy" path="$PROJECT_DIR$/COPYING.txt" />

5
.idea/misc.xml generated
View File

@ -1,9 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<project version="4"> <project version="4">
<component name="EntryPointsManager"> <component name="ProjectRootManager" version="2" languageLevel="JDK_1_5" default="false" project-jdk-name="9.0" project-jdk-type="JavaSDK">
<entry_points version="2.0" />
</component>
<component name="ProjectRootManager" version="2" languageLevel="JDK_1_5" default="false" assert-keyword="true" jdk-15="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
<output url="file://$PROJECT_DIR$/out" /> <output url="file://$PROJECT_DIR$/out" />
</component> </component>
</project> </project>

3
.idea/modules.xml generated
View File

@ -2,7 +2,8 @@
<project version="4"> <project version="4">
<component name="ProjectModuleManager"> <component name="ProjectModuleManager">
<modules> <modules>
<module fileurl="file://$PROJECT_DIR$/libGTools.iml" filepath="$PROJECT_DIR$/libGTools.iml" /> <module fileurl="file://$PROJECT_DIR$/Tests/Tests.iml" filepath="$PROJECT_DIR$/Tests/Tests.iml" />
<module fileurl="file://$PROJECT_DIR$/libRefTools.iml" filepath="$PROJECT_DIR$/libRefTools.iml" />
</modules> </modules>
</component> </component>
</project> </project>

12
Tests/Tests.iml Normal file
View File

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<module type="JAVA_MODULE" version="4">
<component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_9" inherit-compiler-output="true">
<exclude-output />
<content url="file://$MODULE_DIR$">
<sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
</content>
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
<orderEntry type="module" module-name="libRefTools" />
</component>
</module>

89
Tests/src/RunTests.java Normal file
View File

@ -0,0 +1,89 @@
import net.tofvesson.async.*;
import net.tofvesson.collections.*;
import net.tofvesson.reflection.*;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
@SuppressWarnings("ALL")
public class RunTests {
public static void main(String[] args){
asyncTest();
collectionsTest();
streamTest();
reflectionTest();
}
public static void asyncTest(){
final int batchSize = 24;
final Random random = ThreadLocalRandom.current();
final ProxiedValue<Boolean> success = new ProxiedValue<>(true);
System.out.print("Async test: ");
Async<Boolean> async = new Async<>(() -> Async.current().postReturn(true));
try{
if(async.await()!=Boolean.TRUE) throw new RuntimeException("Bad return value");
System.out.println("Passed");
}catch(Throwable t){
System.out.println("Failed ("+(t.getMessage().length()==0?"No reason given":t.getMessage())+")");
}
System.out.print("AsyncBatch test: ");
AsyncBatch<Integer> batch = new AsyncBatch<>(batchSize, i -> Async.current().postReturn(i));
Map<Integer, Integer> map = batch.awaitAll();
map.forEach((k, v) -> success.value |= k.equals(v));
System.out.println(success.value?"Passed":"Failed");
success.value = true;
System.out.print("EcoAsync test: ");
final String expected = "Hello Eco";
EcoAsync<String> eco = new EcoAsync<>(false, SafeReflection.getConstructor(String.class, String.class), expected);
try{
eco.await();
System.out.println("Failed (could await uninitialized async)");
}catch(Exception e){
eco.start();
success.value |= expected.equals(eco.await());
eco.start();
success.value |= expected.equals(eco.await());
System.out.println(success.value?"Passed":"Failed: (Awaited values did not match expected value)");
}
success.value = true;
System.out.print("Worker thread test: ");
WorkerThread thread = new WorkerThread(batchSize);
thread.start();
final Map<Long, Integer> check = new HashMap<>();
final Method invoke = SafeReflection.getFirstMethod(Supplier.class, "get");
for(int i = 0; i<batchSize; ++i){
final int expect = random.nextInt();
check.put(thread.push((Supplier<Integer>)()->expect, invoke), expect);
}
for(Long id : check.keySet()) success.value |= check.get(id).equals(thread.pop(id));
thread.stopGraceful();
System.out.println(success.value?"Passed":"Failed");
}
public static void collectionsTest(){
// TODO: Implement
}
public static void streamTest(){
// TODO: Implement
}
public static void reflectionTest(){
// TODO: Implement
}
}

0
libGTools.iml → libRefTools.iml
View File

27
src/com/tofvesson/async/AsyncBatch.java
View File

@ -1,27 +0,0 @@
package com.tofvesson.async;
import java.util.HashMap;
/**
* Creates a batch of similar async instructions.
*/
@SuppressWarnings("unused")
public class AsyncBatch {
private final HashMap<Integer, Async> all = new HashMap<Integer, Async>();
public AsyncBatch(int count, final BatchRunnable r) { for(int i = 0; i<count; ++i) add(r, i); }
private void add(final BatchRunnable r, final int idx){ all.put(idx, new Async(new Runnable() { public void run() { r.run(idx); } })); }
public HashMap<Integer, Async> getAll(){ return all; }
public HashMap<Integer, Object> awaitAll(){
HashMap<Integer, Object> al = new HashMap<Integer, Object>();
for(Integer a : all.keySet())
al.put(a, all.get(a).await());
return al;
}
public int getFinished(){ int i = 0; for(Async a : all.values()) if(!a.isAlive()) ++i; return i; }
public int size(){ return all.size(); }
public boolean allFinished(){ return getFinished()==all.size(); }
public void cancelAll(){ for(Async a : all.values()) a.cancel(); }
}

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

@ -1,102 +0,0 @@
package com.tofvesson.async;
import com.tofvesson.collections.Pair;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;
/**
* A thread tasked with accepting multiple instructions. This is useful for people who don't want to constantly create new threads for heavy work.
* Also good if the fields in an object instantiated in this thread aren't volatile.
*/
public class WorkerThread extends Thread {
List<Long> ids = new ArrayList<Long>();
volatile Queue<Pair<Long, Pair<Method, Pair<Object, Object>>>> queue;
volatile Map<Long, Object> output = new HashMap<Long, Object>();
volatile boolean alive=true, completed=false;
/**
* Create a WorkerThread.
* @param queueSize Maximum amount of instructions to be queued.
*/
public WorkerThread(int queueSize){
super();
try{
Field f = Thread.class.getDeclaredField("target");
f.setAccessible(true);
f.set(this, new Runnable()
{
public void run(){
synchronized (Thread.currentThread()) {
while (alive) {
if (queue.size() != 0) {
Pair<Long, Pair<Method, Pair<Object, Object>>> q = queue.poll();
Pair<Method, Pair<Object, Object>> instr = q.getValue();
try {
output.put(q.getKey(), instr.getKey().invoke(instr.getValue().getKey(), (Object[]) instr.getValue().getValue()));
completed = true;
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
});
}catch(Exception e){}
queue = new ArrayBlockingQueue<Pair<Long, Pair<Method, Pair<Object, Object>>>>(queueSize);
}
/**
* Add a new instruction for the worker thread.
* @param invokeOn Object to invoke method on.
* @param m Method to invoke.
* @param params Parameters for method.
* @return A UID corresponding to the queued instruction.
*/
public long push(Object invokeOn, Method m, Object... params){
m.setAccessible(true);
long id;
Random r = new Random();
do{ id = r.nextLong(); }while(ids.contains(id));
queue.add(new Pair<Long, Pair<Method, Pair<Object, Object>>>(id, new Pair<Method, Pair<Object, Object>>(m, new Pair<Object, Object>(invokeOn, params))));
ids.add(id);
return id;
}
/**
* Waits for instruction to be processed and return value to be acquired.
* @param id UID of the supplied instruction.
* @return Return value from instruction called in worker 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);
ids.remove(id);
return o;
}
/**
* Waits for current method invocation to finish before stopping thread.
*/
public void stopGraceful(){
alive = false;
}
/**
* Interrupts thread to kill it. NOTE: This method is unsafe and could cause issues if it is performing an I/O operation.
* Only call this if you are 100% sure that it won't break something or if are ready to deal with the consequences.
*/
public void stopForced(){
alive = false;
//noinspection deprecation
stop();
}
}

18
src/com/tofvesson/collections/Collections.java
View File

@ -1,18 +0,0 @@
package com.tofvesson.collections;
import java.util.ArrayList;
import java.util.Collection;
@SuppressWarnings("unchecked")
public final class Collections {
public static <T> ArrayList<T> flip(Collection<T> c){
ArrayList<T> a = new ArrayList<T>();
T[] t = (T[]) c.toArray();
for(int i = c.size()-1; i>0; --i) a.add(t[i]);
return a;
}
public static boolean arrayContains(Object[] o, PredicateCompat p){ for(Object o1 : o) if(p.apply(o1)) return true; return false; }
public interface PredicateCompat<T>{ boolean apply(T t); }
}

8
src/com/tofvesson/collections/Empty.java
View File

@ -1,8 +0,0 @@
package com.tofvesson.collections;
final class Empty {
/**
* Internal reference to reserved, unpopulated entries in collections.
*/
static final Empty empty = new Empty();
}

220
src/com/tofvesson/collections/NShiftingList.java
View File

@ -1,220 +0,0 @@
package com.tofvesson.collections;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
@SuppressWarnings("ALL")
public class NShiftingList<E> implements List<E> {
private final float load;
private final int maxSize;
private int pop = 0;
private Object[] entries = new Object[1];
public NShiftingList(int maxSize, float load){ this.maxSize = maxSize; this.load = load; }
public NShiftingList(int maxSize){ this(maxSize, 0.75f); }
public int size() { return pop; }
public boolean isEmpty() { return pop==0; }
public boolean contains(Object o) {
if(o==null) return false;
for(int i = entries.length-1; i>entries.length-pop; --i) if(o==entries[i]) return true;
return false;
}
public Iterator<E> iterator() {
//TODO: Implement
return null;
}
public Object[] toArray() {
Object[] o = new Object[pop];
System.arraycopy(entries, entries.length-pop, o, 0, pop);
return o;
}
public <T> T[] toArray(T[] a) {
System.arraycopy(entries, entries.length-pop, a, 0, pop>a.length?a.length:pop);
return a;
}
public boolean add(E e) {
if(entries.length==pop) preparePopulate(1);
entries[entries.length-(pop=pop==maxSize?maxSize:pop+1)] = e;
return true;
}
public boolean remove(Object o) {
for(int i = entries.length-1; i>entries.length-pop; --i) if(entries[i]==o){ entries[i] = null; shift(); return true; }
return false;
}
public boolean containsAll(Collection<?> c) {
for(Object o : c)
for(int i = entries.length-1; i>entries.length-pop; --i)
if(entries[i]==o) break;
else if(i==entries.length-pop+1) return false;
return true;
}
public boolean addAll(Collection<? extends E> c) {
preparePopulate(c.size());
return false;
}
public boolean addAll(int index, Collection<? extends E> c) {
//TODO: Implement
return false;
}
public boolean removeAll(Collection<?> c) {
//TODO: Implement
return false;
}
public boolean retainAll(Collection<?> c) {
//TODO: Implement
return false;
}
public void clear() {
//TODO: Implement
}
public E get(int index) {
if(index>=pop || index<0) throw new IndexOutOfBoundsException(); // Ensure that user has defined a valid index
return (E) entries[entries.length-pop+index];
}
public E set(int index, E element) {
if(index>=pop || index<0) throw new IndexOutOfBoundsException(); // Ensure that user has defined a valid index
E e = (E) entries[entries.length-pop+index];
entries[entries.length-pop+index] = element;
if(element==null) adaptLoad(0); // Handle load adaptation
return e;
}
public void add(int index, E element) {
//TODO: Implement
}
public E remove(int index) {
//TODO: Implement
return null;
}
public int indexOf(Object o) {
//TODO: Implement
return 0;
}
public int lastIndexOf(Object o) {
//TODO: Implement
return 0;
}
public ListIterator<E> listIterator() {
//TODO: Implement
return null;
}
public ListIterator<E> listIterator(int index) {
//TODO: Implement
return null;
}
public List<E> subList(int fromIndex, int toIndex) {
//TODO: Implement
return null;
}
/**
* Shift populated to replace unpopulated (removed) entries
*/
protected void shift(){
/*
Reads three data points:
1: starting position of a block of populated entries,
2: ending position,
3: starting position of next block
1 2 3
▼ ▼ ▼
[U, U, U, U, P, P, P, U, U, U, U, P, P, U, U, P] Pass 1
4 7 11
1 2 3
▼ ▼ ▼
[U, U, U, U, U, U, U, U, P, P, P, P, P, U, U, P] Pass 2
8 13 15
1
▼
[U, U, U, U, U, U, U, U, U, U, P, P, P, P, P, P] Pass 3 ("2" can't be placed because end was found)
*/
for(int i = 0; i<entries.length-1; ++i)
if(entries[i]!=null)
for(int j = i; j<entries.length; ++j)
if(entries[j]==null) {
for (int k = j; k < entries.length + 1; ++k)
if (k < entries.length && entries[k] != null) {
System.arraycopy(entries, i, entries, k - j + i, j - i);
break;
}else if (k == entries.length) System.arraycopy(entries, i, entries, k - j + i, j - i);
break;
}else if(j==entries.length-1) return; // No more unpopulated entries found
}
/**
* Array load adaptation.
*/
protected void adaptLoad(int accountFor){
if(!checkShifted()) shift(); // Ensure that array is properly shifted before adapting load.
adaptLoad0(accountFor);
}
/**
* Internal array load adaptation if it is known for a fact that array already has been shifted.
*/
private void adaptLoad0(int accountFor){
if(pop+accountFor<=0){
entries = new Object[1];
return;
}
Object[] o = new Object[(int) Math.max(1, Math.min((pop+accountFor)/load, maxSize))]; // Load adaptation algorithm capping at maxSize or 0
System.arraycopy(entries, entries.length-pop, o, o.length-pop, pop);
entries = o;
}
/**
* Check if populated space contain unpopulated entries.
* If there are unpopulated entries, it means that array isn't propperly shifted.
* @return True if values are shifted, false if there exist unpopulated entries in the populated space.
*/
protected boolean checkShifted(){
for(int i = entries.length-1; i>entries.length-pop; --i) if(entries[i]==null) return false; // Check if any unpopulated values exist in the populated range
return true;
}
/**
* Prepares entry array for population of new values.
* @param accountFor New values to account for (in pop variable hasn't been updated).
*/
protected void preparePopulate(int accountFor){
if(accountFor+pop>entries.length) adaptLoad(accountFor); // If new elements exceed limit, adapt load
if(accountFor>entries.length) return; // No need to delete elements if new values exceed limit
if(accountFor+pop>entries.length) System.arraycopy(entries, entries.length-pop, entries,
entries.length-pop+accountFor, pop+accountFor-entries.length); // Shift old values (possible deletion)
}
}

16
src/com/tofvesson/collections/Pair.java
View File

@ -1,16 +0,0 @@
package com.tofvesson.collections;
public class Pair<K, V> {
private final K k;
private V v;
public Pair(K k, V v){
this.k = k;
this.v = v;
}
public K getKey(){ return k; }
public V getValue(){ return v; }
public void setValue(V v){ this.v = v; }
}

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

@ -1,294 +0,0 @@
package com.tofvesson.collections;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import static com.tofvesson.collections.Empty.empty;
@SuppressWarnings({"unchecked", "ReturnOfInnerClass", "unused"})
public class ShiftingList<E> implements List<E> {
/**
* Holder for entries. Dur to reasons, the array holds objects.
*/
Object[] entries;
/**
* Populated entries.
*/
int pop = 0;
/**
* Maximum size of set.
*/
public final int maxSize;
/**
* Load factor used when calculating how to resize array.
*/
protected final float load;
public ShiftingList(int maxSize, float load){
this.maxSize = maxSize<1?20:maxSize;
this.load = load>0.99||load<0.1?0.75f:load;
entries = new Object[1];
}
public ShiftingList(int maxSize){
this(maxSize, 0.75f);
}
public int size() {
return pop;
}
public boolean isEmpty() {
return pop==0;
}
public boolean contains(Object o) {
if(o==empty) return false;
for(int i = 0; i<pop; ++i) if((o!=null && o.equals(entries[i])) || (o==null && entries[i]==empty)) return true;
return false;
}
public Object[] toArray() {
Object[] o = new Object[pop];
System.arraycopy(entries, 0, o, 0, pop);
for(int i = 0; i<o.length; ++i) if(o[i]==empty) o[i] = null;
return o;
}
public <T> T[] toArray(T[] a) {
for(int i = 0; i<Math.min(pop, a.length); ++i) a[i] = (T) entries[i];
return a;
}
public boolean add(E e) {
if(contains(e)) return false;
preparePopulate(1);
entries[0] = e!=null?e:empty;
pop=pop!=maxSize?pop+1:pop;
return true;
}
public boolean remove(Object o) {
for(int i = 0; i<pop; ++i)
if(entries[i]==o){
entries[i]=null;
--pop;
shift();
if(pop<entries.length*load) adaptLoad();
return true;
}
return false;
}
public boolean containsAll(Collection<?> c) {
boolean b = true;
for(Object o : c) b &= contains(o);
return b;
}
public boolean addAll(Collection<? extends E> c) {
ArrayList<? super E> l = new ArrayList<E>();
for(E e : c) if(!contains(e)) l.add(e);
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;
}
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<? super E> l = new ArrayList<E>();
for(E e : c) if(!contains(e)) l.add(e);
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;
}
public boolean retainAll(Collection<?> c) {
int removed = 0;
for(int i = 0; i<pop; ++i)
if(!c.contains(entries[i])) {
entries[i] = null;
++removed;
}
if(removed==0) return false;
shift();
if((pop-=removed)<entries.length*load) adaptLoad();
return true;
}
public boolean removeAll(Collection<?> c) {
int removed = 0;
for(int i = 0; i<pop; ++i)
if(c.contains(entries[i])) {
entries[i] = null;
++removed;
}
if(removed==0) return false;
shift();
if((pop-=removed)<entries.length*load) adaptLoad();
return true;
}
public void clear() {
pop = 0;
entries = new Object[1];
}
public int indexOf(Object o){
for(int i = 0; i<pop; ++i)
if(entries[i].equals(o)) return i;
return -1;
}
/**
* Adapts array size according to currently populated entries.
* Meant to be used when populated entries variable has already been updated.
* Same as invoking {@link #adaptLoad(int)} with parameter 0.
*/
protected void adaptLoad(){
adaptLoad(0);
}
/**
* Changes size of array to account for new entries.
* @param accountFor The amount new elements to be accounted for.
*/
protected void adaptLoad(int accountFor){
if(pop+accountFor<=0){
entries = new Object[1];
return;
}
Object[] o = new Object[(int) Math.max(1, Math.min((pop+accountFor)/load, maxSize))]; // Load adaptation algorithm capping at maxSize or 0
System.arraycopy(entries, 0, o, 0, Math.min(o.length, entries.length)); // Move as many entries as possible
entries = o;
}
/**
* Shift all elements towards the start of the arrays.
*/
protected void shift(){
for(int i = 0; i<entries.length; ++i)
if(entries[i]==null && i!=pop)
for(int j = i; j<entries.length; ++j)
if(entries[j]!=null){
entries[i] = entries[j];
entries[j] = null;
break;
}else if(j+1==entries.length) return; // Found all populated entries
}
/**
* Prepares entry array for population of new values.
* @param accountFor New values to account for (in pop variable hasn't been updated).
*/
protected void preparePopulate(int accountFor){
if(accountFor+pop>entries.length) adaptLoad(accountFor); // If new elements exceed limit, adapt load
if(accountFor>entries.length) return; // No need to delete elements if new values exceed limit
System.arraycopy(entries, 0, entries, accountFor, entries.length-accountFor); // Shift array elements to account for new elements
}
public E get(int i){
if(i>pop) return null;
return entries[i]==empty?null:(E)entries[i];
}
public E set(int index, E element) {
if(index > pop) return null;
E e = get(index);
entries[index] = element==null?empty:element;
return e;
}
public void add(int index, E element) {
if(index<0 || contains(element)) return;
Object o = element==null?empty:element;
pop = pop==maxSize?pop:pop+1;
adaptLoad();
if((index>=entries.length?index=Math.min(entries.length-1, pop):index)==entries.length-1){
entries[index] = o;
return;
}
System.arraycopy(entries, index, entries, index+1, entries.length-(index+1));
entries[index] = o;
}
public E remove(int index) {
if(index>pop || index<0) return null;
E e = entries[index]==empty?null:(E)entries[index];
entries[index] = null;
shift();
if(--pop<entries.length*load) adaptLoad();
return e;
}
public int lastIndexOf(Object o) {
for(int i = pop; i>0; --i)
if(o.equals(entries[i]))
return i;
return -1;
}
public Iterator<E> iterator(){ return new Iterator<E>(this); }
public ListIterator<E> listIterator(){ return new ListIterator<E>(this); }
public ListIterator<E> listIterator(int index) {
if(index<0) throw new RuntimeException("Invalid starting point for iterator defined: "+index);
return new ListIterator<E>(this, index);
}
public List<E> subList(int fromIndex, int toIndex) {
if(fromIndex<0 || fromIndex>=toIndex || fromIndex>pop || toIndex>pop) return new ArrayList<E>();
ShiftingList<E> l = new ShiftingList<E>(maxSize);
for(int i = toIndex-1; i>fromIndex; --i) l.add(entries[i]==empty?null:(E)entries[i]);
return l;
}
/**
* Standard iterator. For observing list.
* @param <V> Type of object stored in list.
*/
public static class Iterator<V> implements java.util.Iterator<V>{
protected int counter = 0;
private final ShiftingList ref;
private Object previous;
public Iterator(ShiftingList ref){ this.ref = ref; }
public boolean hasNext() { return counter<ref.pop; }
public V next() { return (V)(previous=ref.entries[counter++]==empty?null:ref.entries[counter-1]); }
public void remove(){ if(counter!=0){ ref.remove(previous); --counter; } }
}
/**
* List iterator. For making modifications on-the-go while going through list.
* @param <V> Type of object stored in list.
*/
public static class ListIterator<V> implements java.util.ListIterator<V>{
protected int counter = 0;
protected boolean opNxt = false;
private Object pEl = null;
private final int pop;
private final Object[] entries;
private final ShiftingList list;
public ListIterator(ShiftingList list){ this.pop = list.pop; this.entries = list.entries; this.list = list;}
public ListIterator(ShiftingList list, int start){ this(list); counter = start; }
public boolean hasNext() { return counter<pop; }
public V next() { opNxt = true; return (V)(pEl=entries[counter++]==empty?null:entries[counter-1]); }
public boolean hasPrevious() { return counter>0&&pop!=0; }
public V previous() { opNxt = false; return (V)(pEl=entries[--counter]==empty?null:entries[counter]); }
public int nextIndex() { return counter+1<pop?counter+1:pop; }
public int previousIndex() { return counter!=0?counter-1:0; }
public void remove() { list.remove(counter-(opNxt?0:1)); }
public void set(V v) { if(pEl==entries[counter-(opNxt?0:1)]) entries[counter-(opNxt?0:1)] = v==null?empty:v; }
public void add(V v) { list.add(counter, v); }
}
}

63
src/com/tofvesson/collections/ShiftingMap.java
View File

@ -1,63 +0,0 @@
package com.tofvesson.collections;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
@SuppressWarnings("ALL")
/**
* Map that shifts (and deletes overflowing values) as new values are added.
* Does not support null keys.
*/
public class ShiftingMap<K, V> implements Map<K, V> {
private final ShiftingList<Pair<K, V>> entries;
public ShiftingMap(int maxSize, float load){ entries = new ShiftingList<Pair<K, V>>(maxSize, load); }
public ShiftingMap(int maxSize){ this(maxSize, 0.75f); }
public int size() { return entries.pop; }
public boolean isEmpty() { return entries.pop==0; }
public boolean containsKey(Object key) {
return false;
}
public boolean containsValue(Object value) {
return false;
}
public V get(Object key) {
return null;
}
public V put(K key, V value) {
return null;
}
public V remove(Object key) {
return null;
}
public void putAll(Map<? extends K, ? extends V> m) {
}
public void clear() {
}
public Set<K> keySet() {
return null;
}
public Collection<V> values() {
return null;
}
public Set<Entry<K, V>> entrySet() {
return null;
}
}

64
src/com/tofvesson/async/Async.java → src/net/tofvesson/async/Async.java
View File

@ -1,10 +1,36 @@
package com.tofvesson.async; package net.tofvesson.async;
import net.tofvesson.collections.Pair;
import net.tofvesson.reflection.Classes;
import net.tofvesson.reflection.SafeReflection;
import jdk.internal.org.objectweb.asm.ClassWriter;
import jdk.internal.org.objectweb.asm.MethodVisitor;
import jdk.internal.org.objectweb.asm.Opcodes;
import java.lang.reflect.*; import java.lang.reflect.*;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Vector;
@SuppressWarnings({"WeakerAccess", "unused", "unchecked", "SameParameterValue"}) @SuppressWarnings({"WeakerAccess", "unused", "unchecked", "SameParameterValue", "JavaReflectionMemberAccess"})
public class Async<T> implements Awaitable{ public class Async<T> implements Awaitable{
private static final Field threadLocals;
private static final boolean android;
static{
Field f = null;
boolean $android = false;
try{
try{
f = Thread.class.getDeclaredField("threadLocals");
}catch(Exception ignored){ f = Thread.class.getDeclaredField("localValues"); $android = true; }
}catch(Exception e){ e.printStackTrace(); }
threadLocals = f;
android = $android;
}
/** /**
* Thread running background task. * Thread running background task.
*/ */
@ -30,6 +56,8 @@ public class Async<T> implements Awaitable{
*/ */
volatile Throwable t; volatile Throwable t;
private final LinkedHashMap<String, Object> asyncLocals = new LinkedHashMap<String, Object>();
/** /**
* Create Async object for sleeping for a while. * Create Async object for sleeping for a while.
* @param millis Milliseconds to wait. * @param millis Milliseconds to wait.
@ -197,22 +225,13 @@ public class Async<T> implements Awaitable{
public static <T> Async<T> current(){ public static <T> Async<T> current(){
try{ try{
Object holder; Object holder;
Field f; Field f = threadLocals;
boolean android = false; f = (holder= SafeReflection.getFieldValue(f, Thread.currentThread())).getClass().getDeclaredField("table");
try{ for(Object o : (Object[]) SafeReflection.getFieldValue(f, holder))
f = Thread.class.getDeclaredField("threadLocals");
}catch(Exception ignored){ f = Thread.class.getDeclaredField("localValues"); android = true; }
f.setAccessible(true);
f = (holder=f.get(Thread.currentThread())).getClass().getDeclaredField("table");
f.setAccessible(true);
for(Object o : (Object[]) f.get(holder))
if(o != null) { if(o != null) {
if(android) holder = o; if(android) holder = o;
else { else f = o.getClass().getDeclaredField("value");
f = o.getClass().getDeclaredField("value"); if((android?holder:(holder=SafeReflection.getFieldValue(f, o))) instanceof Async) return (Async<T>) holder;
f.setAccessible(true);
}
if((android?holder:(holder=f.get(o))) instanceof Async) return (Async<T>) holder;
} }
}catch(Exception e){} }catch(Exception e){}
return null; return null;
@ -266,11 +285,20 @@ public class Async<T> implements Awaitable{
return ret; return ret;
} }
/**
* Get a map of values local to this async object.
* @return Map of values if called from this async task, otherwise throw exception
*/
public Map<String, Object> getLocals(){
if(!this.equals(Async.<T>current())) throw new IllegalCallerThreadException("Cannot get locals from another thread!");
return asyncLocals;
}
/** /**
* Checks for dangerous calls to Async methods such as awaiting oneself (which would cause a freeze in that thread). * Checks for dangerous calls to Async methods such as awaiting oneself (which would cause a freeze in that thread).
*/ */
protected void checkDangerousThreadedAction(){ protected final void checkDangerousThreadedAction(){
if(this.equals(current())) throw new RuntimeException("Calling dangerous method from inside thread is forbidden!"); if(this.equals(current())) throw new IllegalCallerThreadException("Calling dangerous method from inside thread is forbidden!");
} }
/** /**

27
src/net/tofvesson/async/AsyncBatch.java Normal file
View File

@ -0,0 +1,27 @@
package net.tofvesson.async;
import java.util.HashMap;
/**
* Creates a batch of similar async instructions.
*/
@SuppressWarnings("unused")
public class AsyncBatch<T> {
private final HashMap<Integer, Async<T>> all = new HashMap<Integer, Async<T>>();
public AsyncBatch(int count, final BatchRunnable r) { for(int i = 0; i<count; ++i) add(r, i); }
private void add(final BatchRunnable r, final int idx){ all.put(idx, new Async<T>(new Runnable() { public void run() { r.run(idx); } })); }
public HashMap<Integer, Async<T>> getAll(){ return all; }
public HashMap<Integer, T> awaitAll(){
HashMap<Integer, T> al = new HashMap<Integer, T>();
for(Integer a : all.keySet())
al.put(a, all.get(a).await());
return al;
}
public int getFinished(){ int i = 0; for(Async<T> a : all.values()) if(!a.isAlive()) ++i; return i; }
public int size(){ return all.size(); }
public boolean allFinished(){ return getFinished()==all.size(); }
public void cancelAll(){ for(Async<T> a : all.values()) a.cancel(); }
}

2
src/com/tofvesson/async/Awaitable.java → src/net/tofvesson/async/Awaitable.java
View File

@ -1,4 +1,4 @@
package com.tofvesson.async; package net.tofvesson.async;
public interface Awaitable<T> { public interface Awaitable<T> {
T await(); T await();

2
src/com/tofvesson/async/BatchRunnable.java → src/net/tofvesson/async/BatchRunnable.java
View File

@ -1,4 +1,4 @@
package com.tofvesson.async; package net.tofvesson.async;
public interface BatchRunnable { public interface BatchRunnable {
void run(int index); void run(int index);

35
src/com/tofvesson/async/EcoAsync.java → src/net/tofvesson/async/EcoAsync.java
View File

@ -1,6 +1,8 @@
package com.tofvesson.async; package net.tofvesson.async;
import net.tofvesson.reflection.SafeReflection;
import java.lang.reflect.Constructor; import java.lang.reflect.Constructor;
import java.lang.reflect.Field; import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException; import java.lang.reflect.InvocationTargetException;
@ -13,27 +15,13 @@ import java.lang.reflect.Method;
@SuppressWarnings("unused") @SuppressWarnings("unused")
public class EcoAsync<T> extends Async<T> { public class EcoAsync<T> extends Async<T> {
private static final Field threadTarget, runnableObjToCall, runnableMethod, runnableParams; private static final Field
threadTarget = SafeReflection.getField(Thread.class, "target"),
runnableObjToCall = SafeReflection.getField(EcoRunnable.class, "val$o"),
runnableMethod = SafeReflection.getField(EcoRunnable.class, "val$method"),
runnableParams = SafeReflection.getField(EcoRunnable.class, "val$params");
private Thread previousThread; private Thread previousThread;
static{
Field f4 = null, f3 = null, f2 = null, f1 = null;
try{
f1 = Thread.class.getDeclaredField("target");
f1.setAccessible(true);
f2 = EcoAsync$1.class.getDeclaredField("val$o");
f2.setAccessible(true);
f3 = EcoAsync$1.class.getDeclaredField("val$method");
f3.setAccessible(true);
f4 = EcoAsync$1.class.getDeclaredField("val$params");
f4.setAccessible(true);
}catch(Exception ignored){}
threadTarget = f1;
runnableObjToCall = f2;
runnableMethod = f3;
runnableParams = f4;
}
/** /**
* Initiates an economic version of async task that invokes the defined method. If object is null, the method must be static. * Initiates an economic version of async task that invokes the defined method. If object is null, the method must be static.
* Note that though this is optimized for larger tasks id est tasks that take more than 5 milliseconds to process, this class was designed with re-usability in mind and, as such, doesn't have to be re-instantiated * Note that though this is optimized for larger tasks id est tasks that take more than 5 milliseconds to process, this class was designed with re-usability in mind and, as such, doesn't have to be re-instantiated
@ -143,6 +131,7 @@ public class EcoAsync<T> extends Async<T> {
@Override @Override
public T await() { public T await() {
checkDangerousThreadedAction(); checkDangerousThreadedAction();
if(!isAlive()) throw new IllegalStateException("Cannot await async that isn't alive!");
//noinspection StatementWithEmptyBody //noinspection StatementWithEmptyBody
while(!failed && !complete); while(!failed && !complete);
if(ret==null && t!=null){ if(ret==null && t!=null){
@ -156,7 +145,7 @@ public class EcoAsync<T> extends Async<T> {
@Override @Override
public boolean isAlive() { public boolean isAlive() {
return !super.failed && !complete && previousThread!=null; // Due to the overridden operation, we need another way of checking if worker is alive. return !super.failed && !complete && task!=null && task.isAlive(); // Due to the overridden operation, we need another way of checking if worker is alive.
} }
@Override @Override
@ -177,7 +166,7 @@ public class EcoAsync<T> extends Async<T> {
if(isAlive()) cancel(); if(isAlive()) cancel();
// Dig parameters out from memory rather than wasting space with our own copy // Dig parameters out from memory rather than wasting space with our own copy
try { try {
EcoAsync$1 t_run = (EcoAsync$1) threadTarget.get(task); EcoRunnable t_run = (EcoRunnable) threadTarget.get(task);
newThread(runnableObjToCall.get(t_run), newThread(runnableObjToCall.get(t_run),
(Method) runnableMethod.get(t_run), (Method) runnableMethod.get(t_run),
(Object[]) runnableParams.get(t_run)); (Object[]) runnableParams.get(t_run));
@ -188,7 +177,7 @@ public class EcoAsync<T> extends Async<T> {
void newThread(Object o, Method method, Object... params){ void newThread(Object o, Method method, Object... params){
previousThread = null; previousThread = null;
try { try {
task = new Thread(new EcoAsync$1(this, o, method, params), "Worker_"+method.getDeclaringClass().getName()+"_"+method.getName()); task = new Thread(new EcoRunnable(this, o, method, params), "Worker_"+method.getDeclaringClass().getName()+"_"+method.getName());
task.setDaemon(true); task.setDaemon(true);
} catch (Exception ignored) { } } catch (Exception ignored) { }
} }

6
src/com/tofvesson/async/EcoAsync$1.java → src/net/tofvesson/async/EcoRunnable.java
View File

@ -1,4 +1,4 @@
package com.tofvesson.async; package net.tofvesson.async;
import java.lang.reflect.Method; import java.lang.reflect.Method;
@ -6,14 +6,14 @@ import java.lang.reflect.Method;
* Pre-written anonymous class. Follows all naming conventions of an anonymous class, acts like an anonymous class and handles data like an anonymous class. * Pre-written anonymous class. Follows all naming conventions of an anonymous class, acts like an anonymous class and handles data like an anonymous class.
* It just isn't an anonymous class technically speaking... * It just isn't an anonymous class technically speaking...
*/ */
class EcoAsync$1 implements Runnable{ class EcoRunnable implements Runnable{
private final EcoAsync this$0; private final EcoAsync this$0;
private final Object val$o; private final Object val$o;
private final Method val$method; private final Method val$method;
private final Object[] val$params; private final Object[] val$params;
EcoAsync$1(EcoAsync this$0, Object val$o, Method val$method, Object[] val$params){ EcoRunnable(EcoAsync this$0, Object val$o, Method val$method, Object[] val$params){
this.this$0 = this$0; this.this$0 = this$0;
this.val$o = val$o; this.val$o = val$o;
this.val$method = val$method; this.val$method = val$method;

4
src/com/tofvesson/async/IgnorantRunnable.java → src/net/tofvesson/async/IgnorantRunnable.java
View File

@ -1,9 +1,9 @@
package com.tofvesson.async; package net.tofvesson.async;
/** /**
* A Runnable-esque interface that allows for running code without try-catch blocks. * A Runnable-esque interface that allows for running code without try-catch blocks.
*/ */
public abstract class IgnorantRunnable implements Runnable{ public abstract class IgnorantRunnable implements Runnable{
public final void run(){ try { irun(); } catch (Throwable throwable) { throw new RuntimeException(throwable); } } public void run(){ try { irun(); } catch (Throwable throwable) { throw new RuntimeException(throwable); } }
public abstract void irun() throws Throwable; public abstract void irun() throws Throwable;
} }

18
src/net/tofvesson/async/IllegalCallerThreadException.java Normal file
View File

@ -0,0 +1,18 @@
package net.tofvesson.async;
public class IllegalCallerThreadException extends RuntimeException {
public IllegalCallerThreadException() {
}
public IllegalCallerThreadException(String message) {
super(message);
}
public IllegalCallerThreadException(String message, Throwable cause) {
super(message, cause);
}
public IllegalCallerThreadException(Throwable cause) {
super(cause);
}
}

120
src/net/tofvesson/async/WorkerThread.java Normal file
View File

@ -0,0 +1,120 @@
package net.tofvesson.async;
import net.tofvesson.collections.Pair;
import net.tofvesson.reflection.SafeReflection;
import java.lang.reflect.Method;
import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* A thread tasked with accepting multiple instructions. This is useful for people who don't want to constantly create new threads for heavy work.
* Also good if the fields in an object instantiated in this thread aren't volatile.
*/
public class WorkerThread extends Thread {
protected final List<Long> ids = new ArrayList<Long>();
protected final Queue<Pair<Long, Pair<Method, Pair<Object, Object>>>> queue;
protected final Map<Long, Object> output = new HashMap<Long, Object>();
protected final AtomicBoolean alive = new AtomicBoolean(true);
/**
* Create a WorkerThread.
* @param queueSize Maximum amount of instructions to be queued.
*/
public WorkerThread(int queueSize){
super();
SafeReflection.setValue(this, Thread.class, "target", new Runnable()
{
public void run(){
while (getAlive()) {
if (queue.size() != 0) {
final Pair<Long, Pair<Method, Pair<Object, Object>>> q;
synchronized (queue){
q = queue.poll();
}
final Pair<Method, Pair<Object, Object>> instr = q.getValue();
try {
synchronized (output) {
output.put(q.getKey(), instr.getKey().invoke(instr.getValue().getKey(), (Object[]) instr.getValue().getValue()));
}
} catch (Exception e) {
e.printStackTrace();
}
}else
try {
Thread.sleep(5);
} catch (InterruptedException e) { }
}
}
});
queue = new ArrayBlockingQueue<Pair<Long, Pair<Method, Pair<Object, Object>>>>(queueSize);
}
/**
* Add a new instruction for the worker thread.
* @param invokeOn Object to invoke method on.
* @param m Method to invoke.
* @param params Parameters for method.
* @return A UID corresponding to the queued instruction.
*/
public long push(Object invokeOn, Method m, Object... params){
m.setAccessible(true);
long id;
Random r = new Random();
do{ id = r.nextLong(); }while(ids.contains(id));
synchronized (queue) {
queue.add(new Pair<Long, Pair<Method, Pair<Object, Object>>>(id, new Pair<Method, Pair<Object, Object>>(m, new Pair<Object, Object>(invokeOn, params))));
}
ids.add(id);
return id;
}
/**
* Waits for instruction to be processed and return value to be acquired.
* @param id UID of the supplied instruction.
* @return Return value from instruction called in worker thread.
*/
public Object pop(long id){
if(!isAlive()) throw new IllegalStateException("Cannot pop value from inactive thread");
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
try {
Thread.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
Object o;
synchronized (output) {
o = output.get(id);
output.remove(id);
}
ids.remove(id);
return o;
}
/**
* Waits for current method invocation to finish before stopping thread.
*/
public void stopGraceful(){
synchronized (alive) { alive.set(false); }
}
protected final boolean getAlive(){
boolean b;
synchronized (alive) { b = alive.get(); }
return b;
}
/**
* Interrupts thread to kill it. NOTE: This method is unsafe and could cause issues if it is performing an I/O operation.
* Only call this if you are 100% sure that it won't break something or if are ready to deal with the consequences.
*/
public void stopForced(){
stopGraceful();
//noinspection deprecation
stop();
}
}

109
src/net/tofvesson/collections/Collections.java Normal file
View File

@ -0,0 +1,109 @@
package net.tofvesson.collections;
import net.tofvesson.reflection.SafeReflection;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collection;
@SuppressWarnings("unchecked")
public final class Collections {
private static final Field arrayListElements;
private static final Field arrayListSize;
static{
arrayListElements = SafeReflection.getField(ArrayList.class, "elementData");
arrayListSize = SafeReflection.getField(ArrayList.class, "size");
}
/**
* Flip a collection and return the given collection with it's contents flipped.
* @param c Collection to flip/reverse.
* @param <T> Type of elements in collection.
* @param <V> Type of collection to flip
* @return The given collection.
*/
public static <T, V extends Collection<T>> V flip(V c){
ArrayList<T> a = flipNew(c);
c.clear();
c.addAll(a);
return c;
}
/**
* Reverse a collection and store the result in a new {@link ArrayList}.
* @param c Collection to reverse.
* @param <T> Type of the elements contained in the collection
* @return ArrayList containing a reversed set of the collection.
*/
public static <T> ArrayList<T> flipNew(Collection<T> c){
ArrayList<T> a = new ArrayList<T>();
T[] t = (T[]) c.toArray();
for(int i = c.size(); i>0; --i) a.add(t[i-1]);
return a;
}
/**
* Check if a given array contains a value that fulfills the predicate.
* @param o Values to check
* @param p Predicate to use for checks.
* @return True of any of the values matched.
*/
public static <T> boolean arrayContains(T[] o, PredicateCompat<T> p){ for(T o1 : o) if(p.apply(o1)) return true; return false; }
/**
* Create an {@link ArrayList} from a given set of values.
* @param t Values to create ArrayList from.
* @param <T> Type of the values to insert.
* @return An ArrayList containing the given set of values.
*/
public static <T> ArrayList<T> fromArray(T[] t){ return setValues(new ArrayList<T>(), t); }
/**
* Overwrite values in {@link ArrayList} with the given value set.
* @param a ArrayList to replace values in
* @param t Values to insert
* @param <T> Type of the values being inserted
* @return The given ArrayList.
*/
public static <T> ArrayList<T> setValues(ArrayList<T> a, T[] t){
try{
arrayListElements.set(a, t);
arrayListSize.setInt(a, t.length);
}
catch(NoSuchFieldError e){}
catch (IllegalAccessException e){}
return a;
}
/**
* Add an array to an {@link ArrayList} without having to loop.
* @param a ArrayList to add elements to
* @param values Elements to add
* @param <T> Type of the elements to add
* @return The given ArrayList
*/
public static <T> ArrayList<T> addAll(ArrayList<T> a, T[] values){
try{
int size = arrayListSize.getInt(a);
T[] t = (T[]) arrayListElements.get(a);
T[] t1 = (T[]) Array.newInstance(values.getClass().getComponentType(), size+values.length);
System.arraycopy(t, 0, t1, 0, size);
System.arraycopy(values, 0, t1, t.length, values.length);
arrayListElements.set(a, t1);
arrayListSize.setInt(a, t1.length);
}
catch(NoSuchFieldError e){}
catch (IllegalAccessException e){}
return a;
}
/**
* Predicate interface to add compatibility with older versions of Java that don't include it
* @param <T> The type to evaluate
*/
public interface PredicateCompat<T>{ boolean apply(T t); }
}

52
src/net/tofvesson/collections/Optional.java Normal file
View File

@ -0,0 +1,52 @@
package net.tofvesson.collections;
/**
* Compat version of java.util.Optional
* @param <T>
*/
@SuppressWarnings("unchecked")
public class Optional<T> {
private final T value;
private final boolean hasValue;
private Optional(T t){
value = nonNull(t);
hasValue = true;
}
private Optional(){
value = null;
hasValue = false;
}
protected T getValue(){ return value; }
public boolean isPresent(){ return hasValue; }
public T get(){ return valueOrThrow(getValue(), isPresent()); }
public T or(Supplier<? extends Optional<? extends T>> s){
nonNull(s);
if(isPresent()) return getValue();
Optional<? extends T> o = s.get();
return valueOrThrow(o.getValue(), o.isPresent());
}
public Optional<T> filter(Collections.PredicateCompat<T> p){
nonNull(p);
if(!isPresent()) return this;
return p.apply(getValue())?this:(Optional<T>) empty();
}
public static <T> Optional<T> empty(){ return new Optional<T>(); }
public static <T> Optional<T> of(T value){ return new Optional<T>(value); }
public static <T> Optional<T> ofNullable(T value){ return value==null?(Optional<T>) empty() : of(value); }
private static <T> T nonNull(T o){
if(o==null) throw new NullPointerException();
return o;
}
private static <T> T valueOrThrow(T t, boolean thr){
if(thr) throw new NullPointerException();
return nonNull(t);
}
}

17
src/net/tofvesson/collections/Pair.java Normal file
View File

@ -0,0 +1,17 @@
package net.tofvesson.collections;
public final class Pair<K, V> {
private K key;
private V value;
public Pair(K key, V value){
this.key = key;
this.value = value;
}
public K getKey(){ return key; }
public V getValue(){ return value; }
public void setKey(K key){ this.key = key; }
public void setValue(V value){ this.value = value; }
}

6
src/net/tofvesson/collections/ProxiedValue.java Normal file
View File

@ -0,0 +1,6 @@
package net.tofvesson.collections;
public final class ProxiedValue<T> {
public T value;
public ProxiedValue(T value){ this.value = value; }
}

9
src/net/tofvesson/collections/Supplier.java Normal file
View File

@ -0,0 +1,9 @@
package net.tofvesson.collections;
/**
* Compat version of Java 8 java.util.function.Supplier
* @param <T>
*/
public interface Supplier<T> {
T get();
}

19
src/net/tofvesson/reflection/Annotations.java Normal file
View File

@ -0,0 +1,19 @@
package net.tofvesson.reflection;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;
public class Annotations {
public static List<Class<?>> getAllAnnotatedClasses(Class<? extends Annotation> annotation){
@SuppressWarnings("unchecked")
Vector<Class<?>> classes = (Vector<Class<?>>) SafeReflection.getValue(annotation.getClassLoader(), ClassLoader.class, "classes");
ArrayList<Class<?>> a = new ArrayList<Class<?>>();
if(classes==null) return a;
for(Class<?> c : classes)
if(c.isAnnotationPresent(annotation))
a.add(c);
return a;
}
}

98
src/net/tofvesson/reflection/Classes.java Normal file
View File

@ -0,0 +1,98 @@
package net.tofvesson.reflection;
import jdk.internal.org.objectweb.asm.ClassWriter;
import jdk.internal.org.objectweb.asm.MethodVisitor;
import jdk.internal.org.objectweb.asm.Opcodes;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.security.ProtectionDomain;
import java.util.Collection;
import java.util.Random;
import java.util.Vector;
@SuppressWarnings("unchecked")
public class Classes {
private static final Field classLoader_loadedClasses = SafeReflection.getField(ClassLoader.class, "classes");
private static final char[] randomSet =
{
'1', '2', '3', '4', '5',
'6', '7', '8', '9', '0',
'$', '_', '£', '¤', 'a',
'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k',
'l', 'm', 'o', 'o', 'p',
'q', 'r', 's', 't', 'u',
'v', 'w', 'x', 'y', 'z',
};
public static String generateNewRandomClassName(ClassLoader loader, String prefix, String suffix, int minLength, int maxLength){
final StringBuilder rand = new StringBuilder();
final int range = maxLength-minLength;
if(range<=0) throw new IndexOutOfBoundsException("Range must be a positive, non-zero value!");
// Select an appropriate randomizer
Random r;
try{
r = (Random) SafeReflection.invokeStaticMethod(SafeReflection.getMethod(Class.forName("java.util.concurrent.ThreadLocalRandom"), "current"));
}catch (ClassNotFoundException e){
r = new Random(System.currentTimeMillis());
}
assert r != null;
// Generate name
do{
// Reset builder
rand.setLength(0);
// Generate a target length
int targetLength = (r.nextInt()%range) + minLength;
for(int i = 0; i<targetLength; ++i){
// Select and appropriate index
int rIdx = r.nextInt();
rand.append(randomSet[rand.length()==0?(rIdx%(randomSet.length-10))+10:rIdx%randomSet.length]);
}
// Continue until an appropriate name has been found
}while(classExists(loader, prefix+rand.toString()+suffix));
return prefix+rand.toString()+suffix;
}
public static boolean classExists(ClassLoader loader, String name){
if(
containsClassWithSignature(
(Vector<Class<?>>) SafeReflection.getFieldValue(classLoader_loadedClasses, loader),
name.replace('/', '.')
)) return true;
try {
loader.loadClass(name);
return true;
} catch (ClassNotFoundException e) { }
return false;
}
public static boolean containsClassWithSignature(Collection<Class<?>> collection, String signature){
for(Class<?> c : collection) if(c.getName().equals(signature)) return true;
return false;
}
public static Field reference(ClassLoader loader, Object value){
Class<?> synthetic = createClassWithStaticField(loader, generateNewRandomClassName(loader, "", "", 1, 64), "synth$value", Object.class);
SafeReflection.setValue(synthetic, "synth$value", value);
return SafeReflection.getField(synthetic, "synth$value");
}
public static Class<?> createClassWithStaticField(ClassLoader loader, String className, String fieldName, Class<?> classType){
ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
writer.visit(Opcodes.V1_5, Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, className.replace('.', '/'), null, null, null);
writer.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, fieldName, classType.getName().replace('.', '/'), null, null).visitEnd();
writer.visitEnd();
byte[] bytecode = writer.toByteArray();
return (Class<?>) SafeReflection.invokeMethod(
loader,
SafeReflection.getMethod(ClassLoader.class, "defineClass", String.class, byte[].class, int.class, int.class, ProtectionDomain.class),
className.replace('.', '/'), bytecode, 0, bytecode.length, null
);
}
}

32
src/net/tofvesson/reflection/Enums.java Normal file
View File

@ -0,0 +1,32 @@
package net.tofvesson.reflection;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
public class Enums {
public static <T extends Enum<T>> boolean isFlagSet(int flags, T flag){
return (flags&flag.ordinal())!=0;
}
public static void asFlags(){
Class<?> c = SafeReflection.getCallerClass();
if(c==null || !c.isEnum()) return;
//noinspection unchecked
asFlags((Class<? extends Enum<?>>)c);
}
public static void asFlags(Class<? extends Enum<?>> type){
int increment = -1;
for(Field f : type.getDeclaredFields())
if(Modifier.isStatic(f.getModifiers()) && f.getType().equals(type))
try {
SafeReflection.setValue(f.get(null), Enum.class, "ordinal", (int) Math.pow(2, ++increment));
}catch(Exception e){ e.printStackTrace(); }
}
public static void asOrdinals(Class<? extends Enum<?>> type){
int increment = -1;
for(Field f : type.getDeclaredFields())
if(Modifier.isStatic(f.getModifiers()) && f.getType().equals(type))
try {
SafeReflection.setValue(f.get(null), Enum.class, "ordinal", ++increment);
}catch(Exception e){ e.printStackTrace(); }
}
}

2
src/com/tofvesson/reflection/NotAutoBoxedException.java → src/net/tofvesson/reflection/NotAutoBoxedException.java
View File

@ -1,4 +1,4 @@
package com.tofvesson.reflection; package net.tofvesson.reflection;
public class NotAutoBoxedException extends Exception { public class NotAutoBoxedException extends Exception {
public NotAutoBoxedException(){ super(); } public NotAutoBoxedException(){ super(); }

89
src/com/tofvesson/reflection/SafeReflection.java → src/net/tofvesson/reflection/SafeReflection.java
View File

@ -1,18 +1,17 @@
package com.tofvesson.reflection; package net.tofvesson.reflection;
import com.sun.istack.internal.NotNull; import net.tofvesson.collections.Optional;
import sun.misc.Unsafe; import sun.misc.Unsafe;
import java.lang.reflect.*; import java.lang.reflect.*;
import java.util.*; import java.util.*;
import java.util.Collections;
/** /**
* Safe tools to help simplify code when dealing with reflection. * Safe tools to help simplify code when dealing with reflection.
*/ */
@SuppressWarnings({"unused", "SameParameterValue", "UnusedReturnValue", "ConstantConditions", "unchecked"}) @SuppressWarnings({"unused", "SameParameterValue", "UnusedReturnValue", "ConstantConditions", "unchecked", "JavaReflectionMemberAccess"})
public final class SafeReflection { public final class SafeReflection {
public static final ClassLoader rootClassLoader;
public static final Unsafe unsafe; public static final Unsafe unsafe;
private static final Method newInstance, aConAccess; private static final Method newInstance, aConAccess;
private static final Field modifiers; private static final Field modifiers;
@ -25,11 +24,12 @@ public final class SafeReflection {
Method m = null, m1 = null; Method m = null, m1 = null;
Field f = null; Field f = null;
long l = 0; long l = 0;
String ver = ""; String ver;
boolean b = true; boolean b = true;
//Get package based on java version (Java 9+ use "jdk.internal.reflect" while "sun.reflect" is used by earlier versions) //Get package based on java version (Java 9+ use "jdk.internal.reflect" while "sun.reflect" is used by earlier versions)
try{ try{
ClassLoader.getSystemClassLoader().loadClass("jdk.internal.reflect.DelegatingConstructorAccessorImpl"); ClassLoader.getSystemClassLoader().loadClass("jdk.internal.reflect.DelegatingConstructorAccessorImpl");
ver="jdk.internal.reflect";
}catch(Throwable ignored){ }catch(Throwable ignored){
ver="sun.reflect"; // If class can't be found in sun.reflect; we know that user is running Java 9+ ver="sun.reflect"; // If class can't be found in sun.reflect; we know that user is running Java 9+
} }
@ -39,11 +39,9 @@ public final class SafeReflection {
u = (Unsafe) f.get(null); u = (Unsafe) f.get(null);
try { try {
f = Field.class.getDeclaredField("modifiers"); f = Field.class.getDeclaredField("modifiers");
f.setAccessible(true);
}catch(Exception e){ }catch(Exception e){
try { f = Field.class.getDeclaredField("artField").getType().getDeclaredField("accessFlags"); } try { f = Field.class.getDeclaredField("artField").getType().getDeclaredField("accessFlags"); }
catch(Exception ignored){ f = Field.class.getDeclaredField("accessFlags"); } catch(Exception ignored){ f = Field.class.getDeclaredField("accessFlags"); }
f.setAccessible(true);
} }
try { try {
l = u.objectFieldOffset(AccessibleObject.class.getDeclaredField("override")); // Most desktop versions of Java l = u.objectFieldOffset(AccessibleObject.class.getDeclaredField("override")); // Most desktop versions of Java
@ -52,7 +50,7 @@ public final class SafeReflection {
} }
try { try {
m1 = Constructor.class.getDeclaredMethod("acquireConstructorAccessor"); m1 = Constructor.class.getDeclaredMethod("acquireConstructorAccessor");
m1.setAccessible(true); u.putInt(m1, l, 1);
m = Class.forName(ver + ".DelegatingConstructorAccessorImpl").getDeclaredMethod("newInstance", Object[].class); m = Class.forName(ver + ".DelegatingConstructorAccessorImpl").getDeclaredMethod("newInstance", Object[].class);
u.putInt(m, l, 1); u.putInt(m, l, 1);
}catch(Exception e){ }catch(Exception e){
@ -67,6 +65,24 @@ public final class SafeReflection {
version = ver; version = ver;
hasAConAccess = b; hasAConAccess = b;
modifiers = f; modifiers = f;
ClassLoader cl = ClassLoader.getSystemClassLoader();
while(cl.getParent()!=null) cl = cl.getParent();
rootClassLoader = cl;
}
public static Object getFieldValue(Field f, Object o){
try{
return o==null?unsafe.getObject(f.getDeclaringClass(), unsafe.staticFieldOffset(f)):unsafe.getObject(o, unsafe.objectFieldOffset(f));
}catch(Exception e){ throw new RuntimeException(e); } // Fatal and unexpected error
}
/**
* Java 9-safe version of {@link Field#setAccessible(boolean)}
* @param f Field to set accessible
*/
private static void setAccessible(AccessibleObject f){
unsafe.putInt(f, override, 1);
} }
/** /**
@ -201,8 +217,8 @@ public final class SafeReflection {
* @return Object or null if object is null or field doesn't exist. * @return Object or null if object is null or field doesn't exist.
*/ */
public static Object getValue(Object from, Class<?> c, String name){ public static Object getValue(Object from, Class<?> c, String name){
try{ return getField(from!=null?from.getClass():c, name).get(from); }catch(Throwable ignored){} try{ return getFieldValue(getField(from!=null?from.getClass():c, name), from); }catch(Throwable ignored){}
for(Class<?> c1 : getSupers(from!=null?from.getClass():c)) try{ return getField(c1, name).get(from); }catch(Exception e){} // Find first field with the given value for(Class<?> c1 : getSupers(from!=null?from.getClass():c)) try{ return getFieldValue(getField(c1, name), from); }catch(Exception e){} // Find first field with the given value
return null; return null;
} }
@ -212,7 +228,7 @@ public final class SafeReflection {
* @param name Name of field. * @param name Name of field.
* @return Object or null if object is null or field doesn't exist. * @return Object or null if object is null or field doesn't exist.
*/ */
public static Object getValue(@NotNull Object from, String name){ return getValue(from, null, name); } public static Object getValue(Object from, String name){ return getValue(from, null, name); }
/** /**
* Gets the object stored in the static field with the specified name in the class of the defined object. * Gets the object stored in the static field with the specified name in the class of the defined object.
@ -229,7 +245,7 @@ public final class SafeReflection {
* @param name Name of field * @param name Name of field
* @return Object or null if anything goes wrong. * @return Object or null if anything goes wrong.
*/ */
public static Object getFieldObject(Class<?> supr, Object o, String name){ try{ return getField(o.getClass(), name).get(o); }catch(Exception e){ return null; } } public static Object getFieldObject(Class<?> supr, Object o, String name){ try{ return getFieldValue(getField(o.getClass(), name), o); }catch(Exception e){ return null; } }
/** /**
* Get a collection of all superclasses of supplied class. * Get a collection of all superclasses of supplied class.
@ -255,6 +271,19 @@ public final class SafeReflection {
} }
} }
public static Optional<Object> lazyCall(Class<?> in, Object on, String name, Object... params){
for(Method m : in.getDeclaredMethods())
if(m.getName().equals(name))
try{
SafeReflection.setAccessible(m);
return Optional.ofNullable(m.invoke(on, (Object[]) params));
}
catch (IllegalArgumentException e){ }
catch (IllegalAccessException e) { throw new RuntimeException(e); }
catch (InvocationTargetException e) { throw new RuntimeException(e.getCause()); }
return Optional.empty();
}
/** /**
* Set field to specified value. * Set field to specified value.
* <br><h1 style="text-align: center; color: red;">Please note:</h1>A JIT compiler may inline private final fields in methods which will prevent the actual value * <br><h1 style="text-align: center; color: red;">Please note:</h1>A JIT compiler may inline private final fields in methods which will prevent the actual value
@ -378,8 +407,8 @@ public final class SafeReflection {
public static Object getEnclosingClassObjectRef(Object nested){ public static Object getEnclosingClassObjectRef(Object nested){
try{ try{
Field f = nested.getClass().getDeclaredField("this$0"); Field f = nested.getClass().getDeclaredField("this$0");
unsafe.putInt(f, override, 1); //unsafe.putInt(f, override, 1);
return f.get(nested); return getFieldValue(f, nested);
}catch(Exception e){} }catch(Exception e){}
return null; return null;
} }
@ -428,7 +457,7 @@ public final class SafeReflection {
// Get enum constructor (inherited from Enum.class) // Get enum constructor (inherited from Enum.class)
Constructor<T> c = clazz.getDeclaredConstructor(paramList); Constructor<T> c = clazz.getDeclaredConstructor(paramList);
if(hasAConAccess) unsafe.putInt(c, override, 1); if(hasAConAccess) unsafe.putInt(c, override, 1);
else c.setAccessible(true); else setAccessible(c);
Object[] parameters = new Object[def.params.size()+2]; Object[] parameters = new Object[def.params.size()+2];
parameters[0] = name; parameters[0] = name;
@ -442,7 +471,7 @@ public final class SafeReflection {
// Get the final name field from Enum.class and make it temporarily modifiable // Get the final name field from Enum.class and make it temporarily modifiable
Field f = Enum.class.getDeclaredField("name"); Field f = Enum.class.getDeclaredField("name");
f.setAccessible(true); setAccessible(f);
// Rename the newly created enum to the requested name // Rename the newly created enum to the requested name
f.set(u, name); f.set(u, name);
@ -451,7 +480,7 @@ public final class SafeReflection {
// Get the current values field from Enum (a female dog to modify) // Get the current values field from Enum (a female dog to modify)
f = clazz.getDeclaredField("$VALUES"); f = clazz.getDeclaredField("$VALUES");
f.setAccessible(true); setAccessible(f);
T[] $VALUES = (T[]) Array.newInstance(clazz, values.length+1); T[] $VALUES = (T[]) Array.newInstance(clazz, values.length+1);
System.arraycopy(values, 0, $VALUES, 0, values.length); // Copy over values from old array 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 $VALUES[values.length] = u; // Add out custom enum to our local array
@ -594,21 +623,11 @@ public final class SafeReflection {
*/ */
public static Class<?> getCallerClass(){ public static Class<?> getCallerClass(){
ArrayList<StackTraceElement> s = getStacktraceWithoutReflection(); ArrayList<StackTraceElement> s = getStacktraceWithoutReflection();
try { return Class.forName(s.get(s.size()==3?2:s.size()==2?1:0).getClassName()); } catch (ClassNotFoundException e) { } try { return Class.forName(s.get(s.size()>3?3:s.size()-1).getClassName()); } catch (ClassNotFoundException e) { }
assert false:"Unreachable code reached"; assert false:"Unreachable code reached";
return null; return null;
} }
public static Method getCallerMethod(){
ArrayList<StackTraceElement> s = getStacktraceWithoutReflection();
try{
Method m = SafeReflection.class.getDeclaredMethod("getCallerMethod");
return null;
}catch(Exception e){}
return null;
}
/** /**
* Get a stacktrace without listing reflection methods. * Get a stacktrace without listing reflection methods.
* @return Ordered list of stacktrace without method reflections steps. * @return Ordered list of stacktrace without method reflections steps.
@ -629,10 +648,10 @@ public final class SafeReflection {
return s; return s;
} }
public static Method getSetMethod(Class<?> c){ private static Method getSetMethod(Class<?> c){
try { try {
Method m = Field.class.getDeclaredMethod(getSetMethodName(c), Object.class, isAutoBoxedClass(c)?unbox(c):c.isPrimitive()?c:Object.class); Method m = Field.class.getDeclaredMethod(getSetMethodName(c), Object.class, isAutoBoxedClass(c)?unbox(c):c.isPrimitive()?c:Object.class);
m.setAccessible(true); setAccessible(m);
return m; return m;
} catch (Exception e) { e.printStackTrace(); } } catch (Exception e) { e.printStackTrace(); }
return null; // Not object version of primitive return null; // Not object version of primitive
@ -646,7 +665,7 @@ public final class SafeReflection {
try{ try{
f = c.getDeclaredField("value"); f = c.getDeclaredField("value");
}catch(Exception e){} }catch(Exception e){}
if(f!=null) f.setAccessible(true); if(f!=null) setAccessible(f);
return"set"+ return"set"+
(f!=null && Number.class.isAssignableFrom(f.getType()) && f.getType().isPrimitive()? (f!=null && Number.class.isAssignableFrom(f.getType()) && f.getType().isPrimitive()?
(s=f.getType().getSimpleName()).replaceFirst(s.charAt(0)+"", Character.toUpperCase(s.charAt(0))+""): (s=f.getType().getSimpleName()).replaceFirst(s.charAt(0)+"", Character.toUpperCase(s.charAt(0))+""):
@ -657,8 +676,8 @@ public final class SafeReflection {
} }
public static boolean isAutoBoxedClass(final Class<?> c){ public static boolean isAutoBoxedClass(final Class<?> c){
return Number.class.isAssignableFrom(c) && com.tofvesson.collections.Collections.arrayContains(c.getDeclaredFields(), return Number.class.isAssignableFrom(c) && net.tofvesson.collections.Collections.arrayContains(c.getDeclaredFields(),
new com.tofvesson.collections.Collections.PredicateCompat() { new net.tofvesson.collections.Collections.PredicateCompat() {
public boolean apply(Object o) { public boolean apply(Object o) {
return ((Field) o).getName().equals("value") && box(((Field) o).getType())==c; return ((Field) o).getName().equals("value") && box(((Field) o).getType())==c;
} }
@ -673,7 +692,7 @@ public final class SafeReflection {
long.class, long.class,
c.isPrimitive()?c:Object.class c.isPrimitive()?c:Object.class
); );
m.setAccessible(true); setAccessible(m);
return m; return m;
}catch(Exception ignored){ ignored.printStackTrace(); } }catch(Exception ignored){ ignored.printStackTrace(); }
return null; // Something went wrong... return null; // Something went wrong...

2
src/com/tofvesson/logging/Tag.java → src/net/tofvesson/stream/Tag.java
View File

@ -1,4 +1,4 @@
package com.tofvesson.logging; package net.tofvesson.stream;
public interface Tag { public interface Tag {
String apply(String output); String apply(String output);

2
src/com/tofvesson/logging/TagStream.java → src/net/tofvesson/stream/TagStream.java
View File

@ -1,4 +1,4 @@
package com.tofvesson.logging; package net.tofvesson.stream;
import java.io.IOException; import java.io.IOException;
import java.io.OutputStream; import java.io.OutputStream;