1 /* 2 * Copyright (c) 2000, 2014, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package sun.nio.ch; 27 28 import java.io.*; 29 import java.lang.reflect.*; 30 import java.security.AccessController; 31 import java.security.PrivilegedAction; 32 33 34 class Reflect { // package-private 35 36 private Reflect() { } 37 38 private static class ReflectionError extends Error { 39 private static final long serialVersionUID = -8659519328078164097L; 40 ReflectionError(Throwable x) { 41 super(x); 42 } 43 } 44 45 private static void setAccessible(final AccessibleObject ao) { 46 AccessController.doPrivileged(new PrivilegedAction<Void>() { 47 public Void run() { 48 ao.setAccessible(true); 49 return null; 50 }}); 51 } 52 53 static Constructor<?> lookupConstructor(String className, 54 Class<?>[] paramTypes) 55 { 56 try { 57 Class<?> cl = Class.forName(className); 58 Constructor<?> c = cl.getDeclaredConstructor(paramTypes); 59 setAccessible(c); 60 return c; 61 } catch (ClassNotFoundException | NoSuchMethodException x) { 62 throw new ReflectionError(x); 63 } 64 } 65 66 static Object invoke(Constructor<?> c, Object[] args) { 67 try { 68 return c.newInstance(args); 69 } catch (InstantiationException | 70 IllegalAccessException | 71 InvocationTargetException x) { 72 throw new ReflectionError(x); 73 } 74 } 75 76 static Method lookupMethod(String className, 77 String methodName, 78 Class<?>... paramTypes) 79 { 80 try { 81 Class<?> cl = Class.forName(className); 82 Method m = cl.getDeclaredMethod(methodName, paramTypes); 83 setAccessible(m); 84 return m; 85 } catch (ClassNotFoundException | NoSuchMethodException x) { 86 throw new ReflectionError(x); 87 } 88 } 89 90 static Object invoke(Method m, Object ob, Object[] args) { 91 try { 92 return m.invoke(ob, args); 93 } catch (IllegalAccessException | InvocationTargetException x) { 94 throw new ReflectionError(x); 95 } 96 } 97 98 static Object invokeIO(Method m, Object ob, Object[] args) 99 throws IOException 100 { 101 try { 102 return m.invoke(ob, args); 103 } catch (IllegalAccessException x) { 104 throw new ReflectionError(x); 105 } catch (InvocationTargetException x) { 106 if (IOException.class.isInstance(x.getCause())) 107 throw (IOException)x.getCause(); 108 throw new ReflectionError(x); 109 } 110 } 111 112 static Field lookupField(String className, String fieldName) { 113 try { 114 Class<?> cl = Class.forName(className); 115 Field f = cl.getDeclaredField(fieldName); 116 setAccessible(f); 117 return f; 118 } catch (ClassNotFoundException | NoSuchFieldException x) { 119 throw new ReflectionError(x); 120 } 121 } 122 123 static Object get(Object ob, Field f) { 124 try { 125 return f.get(ob); 126 } catch (IllegalAccessException x) { 127 throw new ReflectionError(x); 128 } 129 } 130 131 static Object get(Field f) { 132 return get(null, f); 133 } 134 135 static void set(Object ob, Field f, Object val) { 136 try { 137 f.set(ob, val); 138 } catch (IllegalAccessException x) { 139 throw new ReflectionError(x); 140 } 141 } 142 143 static void setInt(Object ob, Field f, int val) { 144 try { 145 f.setInt(ob, val); 146 } catch (IllegalAccessException x) { 147 throw new ReflectionError(x); 148 } 149 } 150 151 static void setBoolean(Object ob, Field f, boolean val) { 152 try { 153 f.setBoolean(ob, val); 154 } catch (IllegalAccessException x) { 155 throw new ReflectionError(x); 156 } 157 } 158 159 }