From d4c53993eca7376e818124243102e4bd0c3044b0 Mon Sep 17 00:00:00 2001 From: Gabriel Tofvesson Date: Thu, 4 Jan 2018 01:10:08 +0100 Subject: [PATCH] - Added tests - 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" --- .idea/artifacts/libRefTools_jar.xml | 2 +- .idea/misc.xml | 5 +- .idea/modules.xml | 3 +- Tests/Tests.iml | 12 + Tests/src/RunTests.java | 89 ++++++ libGTools.iml => libRefTools.iml | 0 src/com/tofvesson/async/AsyncBatch.java | 27 -- src/com/tofvesson/async/WorkerThread.java | 102 ------ .../tofvesson/collections/Collections.java | 18 -- src/com/tofvesson/collections/Empty.java | 8 - .../tofvesson/collections/NShiftingList.java | 220 ------------- src/com/tofvesson/collections/Pair.java | 16 - .../tofvesson/collections/ShiftingList.java | 294 ------------------ .../tofvesson/collections/ShiftingMap.java | 63 ---- src/{com => net}/tofvesson/async/Async.java | 64 ++-- src/net/tofvesson/async/AsyncBatch.java | 27 ++ .../tofvesson/async/Awaitable.java | 2 +- .../tofvesson/async/BatchRunnable.java | 2 +- .../tofvesson/async/EcoAsync.java | 35 +-- .../tofvesson/async/EcoRunnable.java} | 6 +- .../tofvesson/async/IgnorantRunnable.java | 4 +- .../async/IllegalCallerThreadException.java | 18 ++ src/net/tofvesson/async/WorkerThread.java | 120 +++++++ .../tofvesson/collections/Collections.java | 109 +++++++ src/net/tofvesson/collections/Optional.java | 52 ++++ src/net/tofvesson/collections/Pair.java | 17 + .../tofvesson/collections/ProxiedValue.java | 6 + src/net/tofvesson/collections/Supplier.java | 9 + src/net/tofvesson/reflection/Annotations.java | 19 ++ src/net/tofvesson/reflection/Classes.java | 98 ++++++ src/net/tofvesson/reflection/Enums.java | 32 ++ .../reflection/NotAutoBoxedException.java | 2 +- .../tofvesson/reflection/SafeReflection.java | 89 +++--- .../logging => net/tofvesson/stream}/Tag.java | 2 +- .../tofvesson/stream}/TagStream.java | 2 +- 35 files changed, 734 insertions(+), 840 deletions(-) create mode 100644 Tests/Tests.iml create mode 100644 Tests/src/RunTests.java rename libGTools.iml => libRefTools.iml (100%) delete mode 100644 src/com/tofvesson/async/AsyncBatch.java delete mode 100644 src/com/tofvesson/async/WorkerThread.java delete mode 100644 src/com/tofvesson/collections/Collections.java delete mode 100644 src/com/tofvesson/collections/Empty.java delete mode 100644 src/com/tofvesson/collections/NShiftingList.java delete mode 100644 src/com/tofvesson/collections/Pair.java delete mode 100644 src/com/tofvesson/collections/ShiftingList.java delete mode 100644 src/com/tofvesson/collections/ShiftingMap.java rename src/{com => net}/tofvesson/async/Async.java (86%) create mode 100644 src/net/tofvesson/async/AsyncBatch.java rename src/{com => net}/tofvesson/async/Awaitable.java (71%) rename src/{com => net}/tofvesson/async/BatchRunnable.java (67%) rename src/{com => net}/tofvesson/async/EcoAsync.java (86%) rename src/{com/tofvesson/async/EcoAsync$1.java => net/tofvesson/async/EcoRunnable.java} (87%) rename src/{com => net}/tofvesson/async/IgnorantRunnable.java (58%) create mode 100644 src/net/tofvesson/async/IllegalCallerThreadException.java create mode 100644 src/net/tofvesson/async/WorkerThread.java create mode 100644 src/net/tofvesson/collections/Collections.java create mode 100644 src/net/tofvesson/collections/Optional.java create mode 100644 src/net/tofvesson/collections/Pair.java create mode 100644 src/net/tofvesson/collections/ProxiedValue.java create mode 100644 src/net/tofvesson/collections/Supplier.java create mode 100644 src/net/tofvesson/reflection/Annotations.java create mode 100644 src/net/tofvesson/reflection/Classes.java create mode 100644 src/net/tofvesson/reflection/Enums.java rename src/{com => net}/tofvesson/reflection/NotAutoBoxedException.java (87%) rename src/{com => net}/tofvesson/reflection/SafeReflection.java (92%) rename src/{com/tofvesson/logging => net/tofvesson/stream}/Tag.java (65%) rename src/{com/tofvesson/logging => net/tofvesson/stream}/TagStream.java (96%) diff --git a/.idea/artifacts/libRefTools_jar.xml b/.idea/artifacts/libRefTools_jar.xml index 1998203..74a747e 100644 --- a/.idea/artifacts/libRefTools_jar.xml +++ b/.idea/artifacts/libRefTools_jar.xml @@ -2,7 +2,7 @@ $PROJECT_DIR$/out/artifacts/libRefTools_jar - + diff --git a/.idea/misc.xml b/.idea/misc.xml index 3b36119..f07216f 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -1,9 +1,6 @@ - - - - + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml index 39e214d..9c8ed5c 100644 --- a/.idea/modules.xml +++ b/.idea/modules.xml @@ -2,7 +2,8 @@ - + + \ No newline at end of file diff --git a/Tests/Tests.iml b/Tests/Tests.iml new file mode 100644 index 0000000..badfc9c --- /dev/null +++ b/Tests/Tests.iml @@ -0,0 +1,12 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/Tests/src/RunTests.java b/Tests/src/RunTests.java new file mode 100644 index 0000000..4de7ad2 --- /dev/null +++ b/Tests/src/RunTests.java @@ -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 success = new ProxiedValue<>(true); + + System.out.print("Async test: "); + Async 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 batch = new AsyncBatch<>(batchSize, i -> Async.current().postReturn(i)); + Map 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 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 check = new HashMap<>(); + final Method invoke = SafeReflection.getFirstMethod(Supplier.class, "get"); + for(int i = 0; i)()->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 + } +} diff --git a/libGTools.iml b/libRefTools.iml similarity index 100% rename from libGTools.iml rename to libRefTools.iml diff --git a/src/com/tofvesson/async/AsyncBatch.java b/src/com/tofvesson/async/AsyncBatch.java deleted file mode 100644 index ff35b72..0000000 --- a/src/com/tofvesson/async/AsyncBatch.java +++ /dev/null @@ -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 all = new HashMap(); - - public AsyncBatch(int count, final BatchRunnable r) { for(int i = 0; i getAll(){ return all; } - public HashMap awaitAll(){ - HashMap al = new HashMap(); - 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(); } -} diff --git a/src/com/tofvesson/async/WorkerThread.java b/src/com/tofvesson/async/WorkerThread.java deleted file mode 100644 index f4080c3..0000000 --- a/src/com/tofvesson/async/WorkerThread.java +++ /dev/null @@ -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 ids = new ArrayList(); - volatile Queue>>> queue; - volatile Map output = new HashMap(); - 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>> q = queue.poll(); - Pair> 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>>>(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>>(id, new Pair>(m, new Pair(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(); - } -} diff --git a/src/com/tofvesson/collections/Collections.java b/src/com/tofvesson/collections/Collections.java deleted file mode 100644 index 43c26f3..0000000 --- a/src/com/tofvesson/collections/Collections.java +++ /dev/null @@ -1,18 +0,0 @@ -package com.tofvesson.collections; - -import java.util.ArrayList; -import java.util.Collection; - -@SuppressWarnings("unchecked") -public final class Collections { - public static ArrayList flip(Collection c){ - ArrayList a = new ArrayList(); - 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{ boolean apply(T t); } -} diff --git a/src/com/tofvesson/collections/Empty.java b/src/com/tofvesson/collections/Empty.java deleted file mode 100644 index b87f7b0..0000000 --- a/src/com/tofvesson/collections/Empty.java +++ /dev/null @@ -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(); -} \ No newline at end of file diff --git a/src/com/tofvesson/collections/NShiftingList.java b/src/com/tofvesson/collections/NShiftingList.java deleted file mode 100644 index 1d90a2f..0000000 --- a/src/com/tofvesson/collections/NShiftingList.java +++ /dev/null @@ -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 implements List { - - 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 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[] 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 c) { - preparePopulate(c.size()); - return false; - } - - public boolean addAll(int index, Collection 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 listIterator() { - //TODO: Implement - return null; - } - - public ListIterator listIterator(int index) { - //TODO: Implement - return null; - } - - public List 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; ientries.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) - } -} diff --git a/src/com/tofvesson/collections/Pair.java b/src/com/tofvesson/collections/Pair.java deleted file mode 100644 index 2cf99b5..0000000 --- a/src/com/tofvesson/collections/Pair.java +++ /dev/null @@ -1,16 +0,0 @@ -package com.tofvesson.collections; - -public class Pair { - - 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; } -} diff --git a/src/com/tofvesson/collections/ShiftingList.java b/src/com/tofvesson/collections/ShiftingList.java deleted file mode 100644 index 2cc84c8..0000000 --- a/src/com/tofvesson/collections/ShiftingList.java +++ /dev/null @@ -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 implements List { - /** - * 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 T[] toArray(T[] a) { - for(int i = 0; i c) { - boolean b = true; - for(Object o : c) b &= contains(o); - return b; - } - - public boolean addAll(Collection c) { - ArrayList l = new ArrayList(); - for(E e : c) if(!contains(e)) l.add(e); - if(l.size()>maxSize) for(int i = maxSize; i c) { - if(index>=maxSize) return false; - if(index>=entries.length || index<0 || c.size()==0) return false; - ArrayList l = new ArrayList(); - for(E e : c) if(!contains(e)) l.add(e); - if(index+l.size()>maxSize) for(int i = maxSize-index; i= maxSize ? pop : pop+l.size(); - if(l.size()+index c) { - int removed = 0; - for(int i = 0; i c) { - int removed = 0; - for(int i = 0; ientries.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(--pop0; --i) - if(o.equals(entries[i])) - return i; - return -1; - } - - public Iterator iterator(){ return new Iterator(this); } - - public ListIterator listIterator(){ return new ListIterator(this); } - - public ListIterator listIterator(int index) { - if(index<0) throw new RuntimeException("Invalid starting point for iterator defined: "+index); - return new ListIterator(this, index); - } - - public List subList(int fromIndex, int toIndex) { - if(fromIndex<0 || fromIndex>=toIndex || fromIndex>pop || toIndex>pop) return new ArrayList(); - ShiftingList l = new ShiftingList(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 Type of object stored in list. - */ - public static class Iterator implements java.util.Iterator{ - protected int counter = 0; - private final ShiftingList ref; - private Object previous; - public Iterator(ShiftingList ref){ this.ref = ref; } - public boolean hasNext() { return counter Type of object stored in list. - */ - public static class ListIterator implements java.util.ListIterator{ - 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 counter0&&pop!=0; } - public V previous() { opNxt = false; return (V)(pEl=entries[--counter]==empty?null:entries[counter]); } - public int nextIndex() { return counter+1 implements Map { - - private final ShiftingList> entries; - - public ShiftingMap(int maxSize, float load){ entries = new ShiftingList>(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 m) { - - } - - public void clear() { - - } - - public Set keySet() { - return null; - } - - public Collection values() { - return null; - } - - public Set> entrySet() { - return null; - } -} diff --git a/src/com/tofvesson/async/Async.java b/src/net/tofvesson/async/Async.java similarity index 86% rename from src/com/tofvesson/async/Async.java rename to src/net/tofvesson/async/Async.java index 3995910..f5cce7d 100644 --- a/src/com/tofvesson/async/Async.java +++ b/src/net/tofvesson/async/Async.java @@ -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.util.LinkedHashMap; +import java.util.Map; +import java.util.Vector; -@SuppressWarnings({"WeakerAccess", "unused", "unchecked", "SameParameterValue"}) +@SuppressWarnings({"WeakerAccess", "unused", "unchecked", "SameParameterValue", "JavaReflectionMemberAccess"}) public class Async 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. */ @@ -30,6 +56,8 @@ public class Async implements Awaitable{ */ volatile Throwable t; + private final LinkedHashMap asyncLocals = new LinkedHashMap(); + /** * Create Async object for sleeping for a while. * @param millis Milliseconds to wait. @@ -197,22 +225,13 @@ public class Async implements Awaitable{ public static Async current(){ try{ Object holder; - Field f; - boolean android = false; - try{ - 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)) + Field f = threadLocals; + f = (holder= SafeReflection.getFieldValue(f, Thread.currentThread())).getClass().getDeclaredField("table"); + for(Object o : (Object[]) SafeReflection.getFieldValue(f, holder)) if(o != null) { if(android) holder = o; - else { - f = o.getClass().getDeclaredField("value"); - f.setAccessible(true); - } - if((android?holder:(holder=f.get(o))) instanceof Async) return (Async) holder; + else f = o.getClass().getDeclaredField("value"); + if((android?holder:(holder=SafeReflection.getFieldValue(f, o))) instanceof Async) return (Async) holder; } }catch(Exception e){} return null; @@ -266,11 +285,20 @@ public class Async implements Awaitable{ 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 getLocals(){ + if(!this.equals(Async.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). */ - protected void checkDangerousThreadedAction(){ - if(this.equals(current())) throw new RuntimeException("Calling dangerous method from inside thread is forbidden!"); + protected final void checkDangerousThreadedAction(){ + if(this.equals(current())) throw new IllegalCallerThreadException("Calling dangerous method from inside thread is forbidden!"); } /** diff --git a/src/net/tofvesson/async/AsyncBatch.java b/src/net/tofvesson/async/AsyncBatch.java new file mode 100644 index 0000000..03f06ed --- /dev/null +++ b/src/net/tofvesson/async/AsyncBatch.java @@ -0,0 +1,27 @@ +package net.tofvesson.async; + +import java.util.HashMap; + +/** + * Creates a batch of similar async instructions. + */ +@SuppressWarnings("unused") +public class AsyncBatch { + + private final HashMap> all = new HashMap>(); + + public AsyncBatch(int count, final BatchRunnable r) { for(int i = 0; i(new Runnable() { public void run() { r.run(idx); } })); } + public HashMap> getAll(){ return all; } + public HashMap awaitAll(){ + HashMap al = new HashMap(); + 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(); } +} diff --git a/src/com/tofvesson/async/Awaitable.java b/src/net/tofvesson/async/Awaitable.java similarity index 71% rename from src/com/tofvesson/async/Awaitable.java rename to src/net/tofvesson/async/Awaitable.java index 190b88e..db29634 100644 --- a/src/com/tofvesson/async/Awaitable.java +++ b/src/net/tofvesson/async/Awaitable.java @@ -1,4 +1,4 @@ -package com.tofvesson.async; +package net.tofvesson.async; public interface Awaitable { T await(); diff --git a/src/com/tofvesson/async/BatchRunnable.java b/src/net/tofvesson/async/BatchRunnable.java similarity index 67% rename from src/com/tofvesson/async/BatchRunnable.java rename to src/net/tofvesson/async/BatchRunnable.java index 67a87c5..27bb503 100644 --- a/src/com/tofvesson/async/BatchRunnable.java +++ b/src/net/tofvesson/async/BatchRunnable.java @@ -1,4 +1,4 @@ -package com.tofvesson.async; +package net.tofvesson.async; public interface BatchRunnable { void run(int index); diff --git a/src/com/tofvesson/async/EcoAsync.java b/src/net/tofvesson/async/EcoAsync.java similarity index 86% rename from src/com/tofvesson/async/EcoAsync.java rename to src/net/tofvesson/async/EcoAsync.java index ef46b87..18a3413 100644 --- a/src/com/tofvesson/async/EcoAsync.java +++ b/src/net/tofvesson/async/EcoAsync.java @@ -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.Field; import java.lang.reflect.InvocationTargetException; @@ -13,27 +15,13 @@ import java.lang.reflect.Method; @SuppressWarnings("unused") public class EcoAsync extends Async { - 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; - 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. * 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 extends Async { @Override public T await() { checkDangerousThreadedAction(); + if(!isAlive()) throw new IllegalStateException("Cannot await async that isn't alive!"); //noinspection StatementWithEmptyBody while(!failed && !complete); if(ret==null && t!=null){ @@ -156,7 +145,7 @@ public class EcoAsync extends Async { @Override 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 @@ -177,7 +166,7 @@ public class EcoAsync extends Async { if(isAlive()) cancel(); // Dig parameters out from memory rather than wasting space with our own copy try { - EcoAsync$1 t_run = (EcoAsync$1) threadTarget.get(task); + EcoRunnable t_run = (EcoRunnable) threadTarget.get(task); newThread(runnableObjToCall.get(t_run), (Method) runnableMethod.get(t_run), (Object[]) runnableParams.get(t_run)); @@ -188,7 +177,7 @@ public class EcoAsync extends Async { void newThread(Object o, Method method, Object... params){ previousThread = null; 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); } catch (Exception ignored) { } } diff --git a/src/com/tofvesson/async/EcoAsync$1.java b/src/net/tofvesson/async/EcoRunnable.java similarity index 87% rename from src/com/tofvesson/async/EcoAsync$1.java rename to src/net/tofvesson/async/EcoRunnable.java index 3eaebf9..c140035 100644 --- a/src/com/tofvesson/async/EcoAsync$1.java +++ b/src/net/tofvesson/async/EcoRunnable.java @@ -1,4 +1,4 @@ -package com.tofvesson.async; +package net.tofvesson.async; 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. * 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 Object val$o; private final Method val$method; 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.val$o = val$o; this.val$method = val$method; diff --git a/src/com/tofvesson/async/IgnorantRunnable.java b/src/net/tofvesson/async/IgnorantRunnable.java similarity index 58% rename from src/com/tofvesson/async/IgnorantRunnable.java rename to src/net/tofvesson/async/IgnorantRunnable.java index 52cdd92..2bdce31 100644 --- a/src/com/tofvesson/async/IgnorantRunnable.java +++ b/src/net/tofvesson/async/IgnorantRunnable.java @@ -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. */ 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; } diff --git a/src/net/tofvesson/async/IllegalCallerThreadException.java b/src/net/tofvesson/async/IllegalCallerThreadException.java new file mode 100644 index 0000000..7511656 --- /dev/null +++ b/src/net/tofvesson/async/IllegalCallerThreadException.java @@ -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); + } +} diff --git a/src/net/tofvesson/async/WorkerThread.java b/src/net/tofvesson/async/WorkerThread.java new file mode 100644 index 0000000..ce83561 --- /dev/null +++ b/src/net/tofvesson/async/WorkerThread.java @@ -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 ids = new ArrayList(); + protected final Queue>>> queue; + protected final Map output = new HashMap(); + 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>> q; + synchronized (queue){ + q = queue.poll(); + } + final Pair> 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>>>(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>>(id, new Pair>(m, new Pair(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(); + } +} diff --git a/src/net/tofvesson/collections/Collections.java b/src/net/tofvesson/collections/Collections.java new file mode 100644 index 0000000..ff7291d --- /dev/null +++ b/src/net/tofvesson/collections/Collections.java @@ -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 Type of elements in collection. + * @param Type of collection to flip + * @return The given collection. + */ + public static > V flip(V c){ + ArrayList 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 Type of the elements contained in the collection + * @return ArrayList containing a reversed set of the collection. + */ + public static ArrayList flipNew(Collection c){ + ArrayList a = new ArrayList(); + 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 boolean arrayContains(T[] o, PredicateCompat 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 Type of the values to insert. + * @return An ArrayList containing the given set of values. + */ + public static ArrayList fromArray(T[] t){ return setValues(new ArrayList(), t); } + + /** + * Overwrite values in {@link ArrayList} with the given value set. + * @param a ArrayList to replace values in + * @param t Values to insert + * @param Type of the values being inserted + * @return The given ArrayList. + */ + public static ArrayList setValues(ArrayList 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 Type of the elements to add + * @return The given ArrayList + */ + public static ArrayList addAll(ArrayList 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 The type to evaluate + */ + public interface PredicateCompat{ boolean apply(T t); } +} diff --git a/src/net/tofvesson/collections/Optional.java b/src/net/tofvesson/collections/Optional.java new file mode 100644 index 0000000..0d5f389 --- /dev/null +++ b/src/net/tofvesson/collections/Optional.java @@ -0,0 +1,52 @@ +package net.tofvesson.collections; + +/** + * Compat version of java.util.Optional + * @param + */ +@SuppressWarnings("unchecked") +public class Optional { + + 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> s){ + nonNull(s); + if(isPresent()) return getValue(); + Optional o = s.get(); + return valueOrThrow(o.getValue(), o.isPresent()); + } + public Optional filter(Collections.PredicateCompat p){ + nonNull(p); + if(!isPresent()) return this; + return p.apply(getValue())?this:(Optional) empty(); + } + + + public static Optional empty(){ return new Optional(); } + public static Optional of(T value){ return new Optional(value); } + public static Optional ofNullable(T value){ return value==null?(Optional) empty() : of(value); } + + private static T nonNull(T o){ + if(o==null) throw new NullPointerException(); + return o; + } + + private static T valueOrThrow(T t, boolean thr){ + if(thr) throw new NullPointerException(); + return nonNull(t); + } +} diff --git a/src/net/tofvesson/collections/Pair.java b/src/net/tofvesson/collections/Pair.java new file mode 100644 index 0000000..5ec108b --- /dev/null +++ b/src/net/tofvesson/collections/Pair.java @@ -0,0 +1,17 @@ +package net.tofvesson.collections; + +public final class Pair { + + 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; } +} diff --git a/src/net/tofvesson/collections/ProxiedValue.java b/src/net/tofvesson/collections/ProxiedValue.java new file mode 100644 index 0000000..3a56a58 --- /dev/null +++ b/src/net/tofvesson/collections/ProxiedValue.java @@ -0,0 +1,6 @@ +package net.tofvesson.collections; + +public final class ProxiedValue { + public T value; + public ProxiedValue(T value){ this.value = value; } +} diff --git a/src/net/tofvesson/collections/Supplier.java b/src/net/tofvesson/collections/Supplier.java new file mode 100644 index 0000000..dec0197 --- /dev/null +++ b/src/net/tofvesson/collections/Supplier.java @@ -0,0 +1,9 @@ +package net.tofvesson.collections; + +/** + * Compat version of Java 8 java.util.function.Supplier + * @param + */ +public interface Supplier { + T get(); +} diff --git a/src/net/tofvesson/reflection/Annotations.java b/src/net/tofvesson/reflection/Annotations.java new file mode 100644 index 0000000..810fc27 --- /dev/null +++ b/src/net/tofvesson/reflection/Annotations.java @@ -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> getAllAnnotatedClasses(Class annotation){ + @SuppressWarnings("unchecked") + Vector> classes = (Vector>) SafeReflection.getValue(annotation.getClassLoader(), ClassLoader.class, "classes"); + ArrayList> a = new ArrayList>(); + if(classes==null) return a; + for(Class c : classes) + if(c.isAnnotationPresent(annotation)) + a.add(c); + return a; + } +} diff --git a/src/net/tofvesson/reflection/Classes.java b/src/net/tofvesson/reflection/Classes.java new file mode 100644 index 0000000..deee4fe --- /dev/null +++ b/src/net/tofvesson/reflection/Classes.java @@ -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>) 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> 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 + ); + } +} diff --git a/src/net/tofvesson/reflection/Enums.java b/src/net/tofvesson/reflection/Enums.java new file mode 100644 index 0000000..84f6804 --- /dev/null +++ b/src/net/tofvesson/reflection/Enums.java @@ -0,0 +1,32 @@ +package net.tofvesson.reflection; + +import java.lang.reflect.Field; +import java.lang.reflect.Modifier; + +public class Enums { + public static > 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>)c); + } + public static void asFlags(Class> 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> 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(); } + } +} diff --git a/src/com/tofvesson/reflection/NotAutoBoxedException.java b/src/net/tofvesson/reflection/NotAutoBoxedException.java similarity index 87% rename from src/com/tofvesson/reflection/NotAutoBoxedException.java rename to src/net/tofvesson/reflection/NotAutoBoxedException.java index 168d73d..22e0738 100644 --- a/src/com/tofvesson/reflection/NotAutoBoxedException.java +++ b/src/net/tofvesson/reflection/NotAutoBoxedException.java @@ -1,4 +1,4 @@ -package com.tofvesson.reflection; +package net.tofvesson.reflection; public class NotAutoBoxedException extends Exception { public NotAutoBoxedException(){ super(); } diff --git a/src/com/tofvesson/reflection/SafeReflection.java b/src/net/tofvesson/reflection/SafeReflection.java similarity index 92% rename from src/com/tofvesson/reflection/SafeReflection.java rename to src/net/tofvesson/reflection/SafeReflection.java index ea7d24c..238bf0b 100644 --- a/src/com/tofvesson/reflection/SafeReflection.java +++ b/src/net/tofvesson/reflection/SafeReflection.java @@ -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 java.lang.reflect.*; import java.util.*; -import java.util.Collections; /** * 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 static final ClassLoader rootClassLoader; public static final Unsafe unsafe; private static final Method newInstance, aConAccess; private static final Field modifiers; @@ -25,11 +24,12 @@ public final class SafeReflection { Method m = null, m1 = null; Field f = null; long l = 0; - String ver = ""; + String ver; boolean b = true; //Get package based on java version (Java 9+ use "jdk.internal.reflect" while "sun.reflect" is used by earlier versions) try{ ClassLoader.getSystemClassLoader().loadClass("jdk.internal.reflect.DelegatingConstructorAccessorImpl"); + ver="jdk.internal.reflect"; }catch(Throwable ignored){ 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); try { f = Field.class.getDeclaredField("modifiers"); - f.setAccessible(true); }catch(Exception e){ try { f = Field.class.getDeclaredField("artField").getType().getDeclaredField("accessFlags"); } catch(Exception ignored){ f = Field.class.getDeclaredField("accessFlags"); } - f.setAccessible(true); } try { l = u.objectFieldOffset(AccessibleObject.class.getDeclaredField("override")); // Most desktop versions of Java @@ -52,7 +50,7 @@ public final class SafeReflection { } try { m1 = Constructor.class.getDeclaredMethod("acquireConstructorAccessor"); - m1.setAccessible(true); + u.putInt(m1, l, 1); m = Class.forName(ver + ".DelegatingConstructorAccessorImpl").getDeclaredMethod("newInstance", Object[].class); u.putInt(m, l, 1); }catch(Exception e){ @@ -67,6 +65,24 @@ public final class SafeReflection { version = ver; hasAConAccess = b; 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. */ public static Object getValue(Object from, Class c, String name){ - try{ return getField(from!=null?from.getClass():c, name).get(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 + 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 getFieldValue(getField(c1, name), from); }catch(Exception e){} // Find first field with the given value return null; } @@ -212,7 +228,7 @@ public final class SafeReflection { * @param name Name of field. * @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. @@ -229,7 +245,7 @@ public final class SafeReflection { * @param name Name of field * @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. @@ -255,6 +271,19 @@ public final class SafeReflection { } } + public static Optional 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. *

Please note:

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){ try{ Field f = nested.getClass().getDeclaredField("this$0"); - unsafe.putInt(f, override, 1); - return f.get(nested); + //unsafe.putInt(f, override, 1); + return getFieldValue(f, nested); }catch(Exception e){} return null; } @@ -428,7 +457,7 @@ public final class SafeReflection { // Get enum constructor (inherited from Enum.class) Constructor c = clazz.getDeclaredConstructor(paramList); if(hasAConAccess) unsafe.putInt(c, override, 1); - else c.setAccessible(true); + else setAccessible(c); Object[] parameters = new Object[def.params.size()+2]; parameters[0] = name; @@ -442,7 +471,7 @@ public final class SafeReflection { // Get the final name field from Enum.class and make it temporarily modifiable Field f = Enum.class.getDeclaredField("name"); - f.setAccessible(true); + setAccessible(f); // Rename the newly created enum to the requested 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) f = clazz.getDeclaredField("$VALUES"); - f.setAccessible(true); + setAccessible(f); 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 @@ -594,21 +623,11 @@ public final class SafeReflection { */ public static Class getCallerClass(){ ArrayList 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"; return null; } - public static Method getCallerMethod(){ - ArrayList s = getStacktraceWithoutReflection(); - try{ - Method m = SafeReflection.class.getDeclaredMethod("getCallerMethod"); - - return null; - }catch(Exception e){} - return null; - } - /** * Get a stacktrace without listing reflection methods. * @return Ordered list of stacktrace without method reflections steps. @@ -629,10 +648,10 @@ public final class SafeReflection { return s; } - public static Method getSetMethod(Class c){ + private static Method getSetMethod(Class c){ try { 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; } catch (Exception e) { e.printStackTrace(); } return null; // Not object version of primitive @@ -646,7 +665,7 @@ public final class SafeReflection { try{ f = c.getDeclaredField("value"); }catch(Exception e){} - if(f!=null) f.setAccessible(true); + if(f!=null) setAccessible(f); return"set"+ (f!=null && Number.class.isAssignableFrom(f.getType()) && f.getType().isPrimitive()? (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){ - return Number.class.isAssignableFrom(c) && com.tofvesson.collections.Collections.arrayContains(c.getDeclaredFields(), - new com.tofvesson.collections.Collections.PredicateCompat() { + return Number.class.isAssignableFrom(c) && net.tofvesson.collections.Collections.arrayContains(c.getDeclaredFields(), + new net.tofvesson.collections.Collections.PredicateCompat() { public boolean apply(Object o) { return ((Field) o).getName().equals("value") && box(((Field) o).getType())==c; } @@ -673,7 +692,7 @@ public final class SafeReflection { long.class, c.isPrimitive()?c:Object.class ); - m.setAccessible(true); + setAccessible(m); return m; }catch(Exception ignored){ ignored.printStackTrace(); } return null; // Something went wrong... diff --git a/src/com/tofvesson/logging/Tag.java b/src/net/tofvesson/stream/Tag.java similarity index 65% rename from src/com/tofvesson/logging/Tag.java rename to src/net/tofvesson/stream/Tag.java index acb4c1c..43275af 100644 --- a/src/com/tofvesson/logging/Tag.java +++ b/src/net/tofvesson/stream/Tag.java @@ -1,4 +1,4 @@ -package com.tofvesson.logging; +package net.tofvesson.stream; public interface Tag { String apply(String output); diff --git a/src/com/tofvesson/logging/TagStream.java b/src/net/tofvesson/stream/TagStream.java similarity index 96% rename from src/com/tofvesson/logging/TagStream.java rename to src/net/tofvesson/stream/TagStream.java index b56b6cd..008aae3 100644 --- a/src/com/tofvesson/logging/TagStream.java +++ b/src/net/tofvesson/stream/TagStream.java @@ -1,4 +1,4 @@ -package com.tofvesson.logging; +package net.tofvesson.stream; import java.io.IOException; import java.io.OutputStream;