/**
* Factory method, equivalent to a "fromXML" for step creation. Looks for a class with the same
* name as the XML tag, with the first letter capitalized. For example, <call /> is
* abbot.script.Call.
*/
public static Step createStep(Resolver resolver, Element el) throws InvalidScriptException {
String tag = el.getName();
Map attributes = createAttributeMap(el);
String name = tag.substring(0, 1).toUpperCase() + tag.substring(1);
if (tag.equals(TAG_WAIT)) {
attributes.put(TAG_WAIT, "true");
name = "Assert";
}
try {
name = "abbot.script." + name;
Log.debug("Instantiating " + name);
Class cls = Class.forName(name);
try {
// Steps with contents require access to the XML element
Class[] argTypes = new Class[] {Resolver.class, Element.class, Map.class};
Constructor ctor = cls.getConstructor(argTypes);
return (Step) ctor.newInstance(new Object[] {resolver, el, attributes});
} catch (NoSuchMethodException nsm) {
// All steps must support this ctor
Class[] argTypes = new Class[] {Resolver.class, Map.class};
Constructor ctor = cls.getConstructor(argTypes);
return (Step) ctor.newInstance(new Object[] {resolver, attributes});
}
} catch (ClassNotFoundException cnf) {
String msg = Strings.get("step.unknown_tag", new Object[] {tag});
throw new InvalidScriptException(msg);
} catch (InvocationTargetException ite) {
Log.warn(ite);
throw new InvalidScriptException(ite.getTargetException().getMessage());
} catch (Exception exc) {
Log.warn(exc);
throw new InvalidScriptException(exc.getMessage());
}
}
static Method get_sigaction_method(String cls, String meth)
throws ClassNotFoundException, NoSuchMethodException {
return Class.forName(cls)
.getMethod(
meth,
new Class[] {Integer.TYPE, Class.forName("jtux.UProcess$siginfo_t"), Long.TYPE});
}
void enableLionFS() {
try {
String version = System.getProperty("os.version");
String[] tokens = version.split("\\.");
int major = Integer.parseInt(tokens[0]), minor = 0;
if (tokens.length > 1) minor = Integer.parseInt(tokens[1]);
if (major < 10 || (major == 10 && minor < 7))
throw new Exception("Operating system version is " + version);
Class fsuClass = Class.forName("com.apple.eawt.FullScreenUtilities");
Class argClasses[] = new Class[] {Window.class, Boolean.TYPE};
Method setWindowCanFullScreen = fsuClass.getMethod("setWindowCanFullScreen", argClasses);
setWindowCanFullScreen.invoke(fsuClass, this, true);
Class fsListenerClass = Class.forName("com.apple.eawt.FullScreenListener");
InvocationHandler fsHandler = new MyInvocationHandler(cc);
Object proxy =
Proxy.newProxyInstance(
fsListenerClass.getClassLoader(), new Class[] {fsListenerClass}, fsHandler);
argClasses = new Class[] {Window.class, fsListenerClass};
Method addFullScreenListenerTo = fsuClass.getMethod("addFullScreenListenerTo", argClasses);
addFullScreenListenerTo.invoke(fsuClass, this, proxy);
canDoLionFS = true;
} catch (Exception e) {
vlog.debug("Could not enable OS X 10.7+ full-screen mode:");
vlog.debug(" " + e.toString());
}
}
// setHandler creates a Proxy object from the passed OSXAdapter and adds it as an
// ApplicationListener
public static void setHandler(OSXAdapter adapter) {
try {
Class applicationClass = Class.forName("com.apple.eawt.Application");
if (macOSXApplication == null) {
macOSXApplication =
applicationClass.getConstructor((Class[]) null).newInstance((Object[]) null);
}
Class applicationListenerClass = Class.forName("com.apple.eawt.ApplicationListener");
Method addListenerMethod =
applicationClass.getDeclaredMethod(
"addApplicationListener", new Class[] {applicationListenerClass});
// Create a proxy object around this handler that can be reflectively added as an Apple
// ApplicationListener
Object osxAdapterProxy =
Proxy.newProxyInstance(
OSXAdapter.class.getClassLoader(), new Class[] {applicationListenerClass}, adapter);
addListenerMethod.invoke(macOSXApplication, new Object[] {osxAdapterProxy});
} catch (ClassNotFoundException cnfe) {
System.err.println(
"This version of Mac OS X does not support the Apple EAWT. ApplicationEvent handling has been disabled ("
+ cnfe
+ ")");
} catch (
Exception
ex) { // Likely a NoSuchMethodException or an IllegalAccessException loading/invoking
// eawt.Application methods
System.err.println("Mac OS X Adapter could not talk to EAWT:");
ex.printStackTrace();
}
}
private static Class<?> getClassObject(Object o) throws ClassNotFoundException {
if (o == null) {
System.out.println("null");
}
// 基本データ型の場合
if (o instanceof Boolean) {
return boolean.class;
} else if (o instanceof Integer) {
return int.class;
} else if (o instanceof Double) {
return double.class;
} else if (o instanceof Long) {
return long.class;
} else if (o instanceof Short) {
return short.class;
} else if (o instanceof Character) {
return char.class;
} else if (o instanceof Byte) {
return byte.class;
} else if (o instanceof Float) {
return float.class;
}
// 基本データ型以外の場合:forName()でクラスオブジェクトを取得
else {
System.out.println(Class.forName(strip(o.getClass().toString(), "class ")));
return Class.forName(strip(o.getClass().toString(), "class "));
}
}
/**
* Search a wiring method in the specified class.
*
* @param cl the class where to find the method
* @param methodName the method to be searched
* @return the requested method, if it fully conforms to the definition of the wiring methods.
*/
private static Method getMethod(Class cl, String methodName)
throws NoSuchMethodException, ClassNotFoundException {
// Search methods
Method[] methods = cl.getMethods();
ArrayList<Method> list = new ArrayList<Method>();
for (Method m : methods) {
if (m.getName().equals(methodName)) {
list.add(m);
}
}
if (list.size() == 0) {
throw new NoSuchMethodException(
"No method " + methodName + " in class " + cl.getSimpleName());
} else if (list.size() > 1) {
throw new NoSuchMethodException(
"Multiple methods called " + methodName + " in class " + cl.getSimpleName());
}
// Found a single method with the right name; check if
// it is a setter.
final Class graphClass = Class.forName("peersim.graph.Graph");
final Class randomClass = Class.forName("java.util.Random");
Method method = list.get(0);
Class[] pars = method.getParameterTypes();
if (pars.length < 1 || !pars[0].isAssignableFrom(graphClass))
throw new NoSuchMethodException(
method.getName()
+ " of class "
+ cl.getSimpleName()
+ " is not a valid graph wiring method,"
+ " it has to have peersim.graph.Graph as first argument type");
for (int i = 1; i < pars.length; ++i)
if (!(pars[i] == int.class
|| pars[i] == long.class
|| pars[i] == double.class
|| (i == pars.length - 1 && pars[i].isAssignableFrom(randomClass))))
throw new NoSuchMethodException(
method.getName()
+ " of class "
+ cl.getSimpleName()
+ " is not a valid graph wiring method");
if (method.toString().indexOf("static") < 0)
throw new NoSuchMethodException(
method.getName()
+ " of class "
+ cl.getSimpleName()
+ " is not a valid graph wiring method; it is not static");
return method;
}
int[] init(int... dimensions) {
int size = dimensions.length > 0 ? dimensions[0] : 0;
if (___subrecord___ == null) {
final String[] indexPrefixes = {
"", "s", "_", "Index", "Length", "Ref", "Header", "Info", "Table"
};
for (String indexPrefix : indexPrefixes) {
try {
___subrecord___ =
(Class<? extends Enum>)
Class.forName(getClass().getPackage().getName() + '.' + name() + indexPrefix);
try {
size = ___subrecord___.getField("___recordlen___").getInt(null);
} catch (Exception e) {
}
break;
} catch (ClassNotFoundException e) {
}
}
}
for (String vPrefixe1 :
new String[] {
"_", "", "$", "Value",
}) {
if (___valueclass___ != null) break;
String suffix = vPrefixe1;
for (String name1 :
new String[] {
name().toLowerCase(), name(),
}) {
if (___valueclass___ != null) break;
final String trailName = name1;
if (trailName.endsWith(suffix)) {
for (String aPackage1 :
new String[] {
"", getClass().getPackage().getName() + ".", "java.lang.", "java.util.",
})
if (___valueclass___ == null) break;
else
try {
___valueclass___ = Class.forName(aPackage1 + name().replace(suffix, ""));
} catch (ClassNotFoundException e) {
}
}
}
}
int seek = dimensions.length > 1 ? dimensions[1] : ___recordlen___;
___recordlen___ = Math.max(___recordlen___, seek + size);
return new int[] {size, seek};
}
/**
* Returns the class this method was called 'framesToSkip' frames up the caller hierarchy. JDK
* used to have {@link sun.reflect.Reflection#getCallerClass(int)} until jdk 1.8 build 87. So we
* have to resort to slow stack unwinding.
*
* <p>NOTE: <b>Extremely expensive! Please consider not using it. These aren't the droids you're
* looking for!</b>
*/
@SuppressWarnings("JavadocReference")
@Nullable
public static Class getCallerClass(int framesToSkip) {
int frames = framesToSkip;
StackTraceElement[] stackTrace = new Throwable().getStackTrace();
String className = null;
for (int i = 1; i <= frames; i++) {
if (i >= stackTrace.length) {
break;
}
StackTraceElement element = stackTrace[i];
className = element.getClassName();
if (className.equals("java.lang.reflect.Method")
|| className.equals("sun.reflect.NativeMethodAccessorImpl")
|| className.equals("sun.reflect.DelegatingMethodAccessorImpl")) {
frames++;
continue;
}
if (i == frames) {
break;
}
}
if (className == null) {
// some plugins incorrectly expect not-null class too far up the caller chain,
// so provide some not-null class for them
className = ReflectionUtil.class.getName();
}
try {
return Class.forName(className);
} catch (ClassNotFoundException ignored) {
}
ClassLoader pluginClassLoader = PLUGIN_CLASS_LOADER_DETECTOR.fun(className);
if (pluginClassLoader != null) {
try {
return Class.forName(className, false, pluginClassLoader);
} catch (ClassNotFoundException ignored) {
}
}
LOG.error(
"Could not load class '"
+ className
+ "' using classLoader "
+ ReflectionUtil.class.getClassLoader()
+ "."
+ (stackTrace[1].getClassName().equals("com.intellij.openapi.util.IconLoader")
? " Use getIcon(String, Class) instead."
: ""));
return null;
}
private static void netxsurgery() throws Exception {
/* Force off NetX codebase classloading. */
Class<?> nxc;
try {
nxc = Class.forName("net.sourceforge.jnlp.runtime.JNLPClassLoader");
} catch (ClassNotFoundException e1) {
try {
nxc = Class.forName("netx.jnlp.runtime.JNLPClassLoader");
} catch (ClassNotFoundException e2) {
throw (new Exception("No known NetX on classpath"));
}
}
ClassLoader cl = MainFrame.class.getClassLoader();
if (!nxc.isInstance(cl)) {
throw (new Exception("Not running from a NetX classloader"));
}
Field cblf, lf;
try {
cblf = nxc.getDeclaredField("codeBaseLoader");
lf = nxc.getDeclaredField("loaders");
} catch (NoSuchFieldException e) {
throw (new Exception("JNLPClassLoader does not conform to its known structure"));
}
cblf.setAccessible(true);
lf.setAccessible(true);
Set<Object> loaders = new HashSet<Object>();
Stack<Object> open = new Stack<Object>();
open.push(cl);
while (!open.empty()) {
Object cur = open.pop();
if (loaders.contains(cur)) continue;
loaders.add(cur);
Object curl;
try {
curl = lf.get(cur);
} catch (IllegalAccessException e) {
throw (new Exception("Reflection accessibility not available even though set"));
}
for (int i = 0; i < Array.getLength(curl); i++) {
Object other = Array.get(curl, i);
if (nxc.isInstance(other)) open.push(other);
}
}
for (Object cur : loaders) {
try {
cblf.set(cur, null);
} catch (IllegalAccessException e) {
throw (new Exception("Reflection accessibility not available even though set"));
}
}
}
private static void check(String what, MBeanNotificationInfo[] mbnis) {
System.out.print(what + ": checking notification info: ");
if (mbnis.length == 0) {
System.out.println("NONE (suspicious)");
suspicious.add(what);
return;
}
// Each MBeanNotificationInfo.getName() should be an existent
// Java class that is Notification or a subclass of it
for (int j = 0; j < mbnis.length; j++) {
String notifClassName = mbnis[j].getName();
Class notifClass;
try {
notifClass = Class.forName(notifClassName);
} catch (Exception e) {
System.out.print("FAILED(" + notifClassName + ": " + e + ") ");
failed.add(what);
continue;
}
if (!Notification.class.isAssignableFrom(notifClass)) {
System.out.print("FAILED(" + notifClassName + ": not a Notification) ");
failed.add(what);
continue;
}
System.out.print("OK(" + notifClassName + ") ");
}
System.out.println();
}
Document parseDocument(String filename) throws Exception {
FileReader reader = new FileReader(filename);
String firstLine = new BufferedReader(reader).readLine();
reader.close();
Document document = null;
if (firstLine.startsWith("<?xml")) {
System.err.println("XML detected; using default XML parser.");
} else {
try {
Class nekoParserClass = Class.forName("org.cyberneko.html.parsers.DOMParser");
Object parser = nekoParserClass.newInstance();
Method parse = nekoParserClass.getMethod("parse", new Class[] {String.class});
Method getDocument = nekoParserClass.getMethod("getDocument", new Class[0]);
parse.invoke(parser, filename);
document = (Document) getDocument.invoke(parser);
} catch (Exception e) {
System.err.println("NekoHTML HTML parser not found; HTML4 support disabled.");
}
}
if (document == null) {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
try { // http://www.w3.org/blog/systeam/2008/02/08/w3c_s_excessive_dtd_traffic
factory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
} catch (ParserConfigurationException e) {
System.err.println("Warning: Could not disable external DTD loading");
}
DocumentBuilder builder = factory.newDocumentBuilder();
document = builder.parse(filename);
}
return document;
}
private void callMethodForMultiPart(HttpServletRequest req, HttpServletResponse resp)
throws Exception {
String pinfo = req.getPathInfo();
int pos = pinfo.indexOf('.');
String cname = pinfo.substring(1, pos).replace('/', '.');
String mname = pinfo.substring(pos + 1);
MultiPartMap map = new MultiPartMap();
FileItemIterator ite = new FileUpload().getItemIterator(req);
while (ite.hasNext()) {
FileItemStream item = ite.next();
if (item.isFormField()) {
map.put(item.getFieldName(), IOUtil.streamToString(item.openStream(), "UTF-8"));
} else {
FileItem val =
new FileItem(
item.getFileName(), item.getContentType(), IOUtil.streamToBytes(item.openStream()));
map.put(item.getFieldName(), val);
}
}
Class clazz = Class.forName(cname);
Class[] types = new Class[] {MultiPartMap.class};
Method method = clazz.getMethod(mname, types);
if (method == null) {
throw new RuntimeException("Not found method " + mname + "(Map)");
}
Object result = method.invoke(null, map);
resp.setContentType(MIME_HTML + ";charset=utf-8");
resp.getWriter().write(result.toString());
}
public static void setEnv(Map<String, String> newenv) {
try {
Class<?> processEnvironmentClass = Class.forName("java.lang.ProcessEnvironment");
Field theEnvironmentField = processEnvironmentClass.getDeclaredField("theEnvironment");
theEnvironmentField.setAccessible(true);
Map<String, String> env = (Map<String, String>) theEnvironmentField.get(null);
env.putAll(newenv);
Field theCaseInsensitiveEnvironmentField =
processEnvironmentClass.getDeclaredField("theCaseInsensitiveEnvironment");
theCaseInsensitiveEnvironmentField.setAccessible(true);
Map<String, String> cienv =
(Map<String, String>) theCaseInsensitiveEnvironmentField.get(null);
cienv.putAll(newenv);
} catch (NoSuchFieldException e) {
try {
Class[] classes = Collections.class.getDeclaredClasses();
Map<String, String> env = System.getenv();
for (Class cl : classes) {
if ("java.util.Collections$UnmodifiableMap".equals(cl.getName())) {
Field field = cl.getDeclaredField("m");
field.setAccessible(true);
Object obj = field.get(env);
Map<String, String> map = (Map<String, String>) obj;
map.clear();
map.putAll(newenv);
}
}
} catch (Exception e2) {
e2.printStackTrace();
}
} catch (Exception e1) {
e1.printStackTrace();
}
}
/**
* Loads configuration. It verifies the constraints defined in {@link WireByMethod}.
*
* @param prefix the configuration prefix for this class
*/
public WireByMethod(String prefix) {
super(prefix);
// get the method
try {
final Class wire =
Configuration.getClass(
prefix + "." + PAR_CLASS, Class.forName("peersim.graph.GraphFactory"));
method =
WireByMethod.getMethod(wire, Configuration.getString(prefix + "." + PAR_METHOD, "wire"));
} catch (Exception e) {
throw new RuntimeException(e);
}
// set the constant args (those other than 0th)
Class[] argt = method.getParameterTypes();
args = new Object[argt.length];
for (int i = 1; i < args.length; ++i) {
if (argt[i] == int.class) args[i] = Configuration.getInt(prefix + "." + PAR_ARG + i);
else if (argt[i] == long.class) args[i] = Configuration.getLong(prefix + "." + PAR_ARG + i);
else if (argt[i] == double.class)
args[i] = Configuration.getDouble(prefix + "." + PAR_ARG + i);
else if (i == args.length - 1 && argt[i].isInstance(CommonState.r)) args[i] = CommonState.r;
else {
// we should neve get here
throw new RuntimeException(
"Unexpected error, please " + "report this problem to the peersim team");
}
}
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
isAdapter = in.readBoolean();
if (isAdapter) {
if (adapter_readAdapterObject == null) throw new ClassNotFoundException();
Object[] args = {this, in};
try {
javaObject = adapter_readAdapterObject.invoke(null, args);
} catch (Exception ex) {
throw new IOException();
}
} else {
javaObject = in.readObject();
}
String className = (String) in.readObject();
if (className != null) {
staticType = Class.forName(className);
} else {
staticType = null;
}
initMembers();
}
public static void main(String[] args) {
if (args.length < 1) {
print(usage);
System.exit(0);
}
int lines = 0;
try {
Class<?> c = Class.forName(args[0]);
Method[] methods = c.getMethods();
Constructor[] ctors = c.getConstructors();
if (args.length == 1) {
for (Method method : methods) print(p.matcher(method.toString()).replaceAll(""));
for (Constructor ctor : ctors) print(p.matcher(ctor.toString()).replaceAll(""));
lines = methods.length + ctors.length;
} else {
for (Method method : methods)
if (method.toString().indexOf(args[1]) != -1) {
print(p.matcher(method.toString()).replaceAll(""));
lines++;
}
for (Constructor ctor : ctors)
if (ctor.toString().indexOf(args[1]) != -1) {
print(p.matcher(ctor.toString()).replaceAll(""));
lines++;
}
}
} catch (ClassNotFoundException e) {
print("No such class: " + e);
}
}
/**
* Returns the correct implementation instance for the interface <code>type</code>. For convention
* the implentation is named <code>InterfaceName + Impl</code>.
*
* @param type The interface type
* @return The correct ModelProxy subclass (if exists), a ModelProxy instance otherwise
* @throws MalformedModelException is the interface or the implementation are not well formed
* (they don't respect the conventions).
* @throws ModelRuntimeException is any error occurs during the instantiation
*/
protected ModelProxy createInstance(Class type) {
Class backClass;
if (implementations.containsKey(type)) backClass = implementations.get(type);
else {
/* type never seen */
try {
Package pkg = type.getPackage();
String pkgN = pkg == null ? "" : pkg.getName();
backClass = Class.forName(pkgN + tableName(type) + CommonStatic.getImplementationSuffix());
} catch (Exception e) {
backClass = ModelProxy.class;
}
Validator.validateModel(type, backClass);
initFieldsTypes(type);
implementations.put(type, backClass);
}
ModelProxy impl = null;
try {
impl = (ModelProxy) backClass.newInstance();
} catch (Exception e) {
throw new ModelRuntimeException(e.getMessage());
}
return impl;
}
/** JNDI object factory so the proxy can be used as a resource. */
public Object getObjectInstance(
Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment) throws Exception {
Reference ref = (Reference) obj;
String api = null;
String url = null;
String user = null;
String password = null;
for (int i = 0; i < ref.size(); i++) {
RefAddr addr = ref.get(i);
String type = addr.getType();
String value = (String) addr.getContent();
if (type.equals("type")) api = value;
else if (type.equals("url")) url = value;
else if (type.equals("user")) setUser(value);
else if (type.equals("password")) setPassword(value);
}
if (url == null) throw new NamingException("`url' must be configured for HessianProxyFactory.");
// XXX: could use meta protocol to grab this
if (api == null)
throw new NamingException("`type' must be configured for HessianProxyFactory.");
ClassLoader loader = Thread.currentThread().getContextClassLoader();
Class apiClass = Class.forName(api, false, loader);
return create(apiClass, url);
}
public static void writeParam(String xNameFile) {
//
// write to file xpar all parameters.....
//
IOseq xFile;
xFile = new IOseq(xNameFile);
xFile.IOseqOpenW(false);
try {
Class c = Class.forName("jneat.Neat");
Field[] fieldlist = c.getDeclaredFields();
for (int i = 0; i < fieldlist.length; i++) {
Field f1 = fieldlist[i];
String x1 = f1.getName();
if (x1.startsWith("p_")) {
Field f2 = c.getField("d_" + Neat.normalizeName(x1));
Object s1 = f1.get(c);
Object s2 = f2.get(c);
// String riga = s1 + " " + s2;
String riga = x1 + " " + s1;
xFile.IOseqWrite(riga);
}
}
} catch (Throwable e) {
System.err.println(e);
}
xFile.IOseqCloseW();
}
public static void main(String[] args) {
// read class name from command line args or user input
String name;
if (args.length > 0) name = args[0];
else {
Scanner in = new Scanner(System.in);
System.out.println("Enter class name (e.g. java.util.Date): ");
name = in.next();
}
try {
// print class name and superclass name (if != Object)
Class cl = Class.forName(name);
Class supercl = cl.getSuperclass();
String modifiers = Modifier.toString(cl.getModifiers());
if (modifiers.length() > 0) System.out.print(modifiers + " ");
System.out.print("class " + name);
if (supercl != null && supercl != Object.class)
System.out.print(" extends " + supercl.getName());
System.out.print("\n{\n");
printConstructors(cl);
System.out.println();
printMethods(cl);
System.out.println();
printFields(cl);
System.out.println("}");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
System.exit(0);
}
/** Determine whether the current user has Windows administrator privileges. */
public static boolean isWinAdmin() {
if (!isWinPlatform()) return false;
// for (String group : new com.sun.security.auth.module.NTSystem().getGroupIDs()) {
// if (group.equals("S-1-5-32-544")) return true; // "S-1-5-32-544" is a well-known
// security identifier in Windows. If the current user has it then he/she/it is an
// administrator.
// }
// return false;
try {
Class<?> ntsys = Class.forName("com.sun.security.auth.module.NTSystem");
if (ntsys != null) {
Object groupObj =
SystemUtils.invoke(
ntsys.newInstance(), ntsys.getDeclaredMethod("getGroupIDs"), (Object[]) null);
if (groupObj instanceof String[]) {
for (String group : (String[]) groupObj) {
if (group.equals("S-1-5-32-544"))
return true; // "S-1-5-32-544" is a well-known security identifier in Windows. If the
// current user has it then he/she/it is an administrator.
}
}
}
} catch (ReflectiveOperationException e) {
System.err.println(e);
}
return false;
}
private /*synchronized*/ StructureType assignStructureType(String structType)
throws VisualizerLoadException {
if (debug) System.out.println("In assignStructureType with " + structType);
// Handle objects whose constructors require args separately
if ((structType.toUpperCase().compareTo("BAR") == 0)
|| (structType.toUpperCase().compareTo("SCAT") == 0))
return (new BarScat(structType.toUpperCase()));
else if ((structType.toUpperCase().compareTo("GRAPH") == 0)
|| (structType.toUpperCase().compareTo("NETWORK") == 0))
return (new Graph_Network(structType.toUpperCase()));
else { // Constructor for object does not require args
try {
return ((StructureType)
((Class.forName(insure_text_case_correct_for_legacy_scripts(structType)))
.newInstance()));
} catch (InstantiationException e) {
System.out.println(e);
throw (new VisualizerLoadException(structType + " is invalid structure type"));
} catch (IllegalAccessException e) {
System.out.println(e);
throw (new VisualizerLoadException(structType + " is invalid structure type"));
} catch (ClassNotFoundException e) {
System.out.println(e);
throw (new VisualizerLoadException(structType + " is invalid structure type"));
}
}
}
public static void main(String[] args) throws Exception {
Class clazz = Class.forName("com.mtl.spring.aop.helloworld.ArithmeticCalculatorLoggingProxy");
Object object = clazz.newInstance();
Method[] methods = clazz.getMethods();
StringBuffer sb = new StringBuffer();
sb.append("public class ")
.append(object.getClass().getCanonicalName())
.append("{\n")
.append("Object object ")
.append("\n");
Constructor[] constructors = clazz.getConstructors();
for (Constructor constructor : constructors) {
sb.append("\npublic ").append(constructor.getName()).append("(");
Class<?> p[] = constructor.getParameterTypes();
for (int j = 0; j < p.length; ++j) {
sb.append(p[j].getName() + " arg" + j);
if (j < p.length - 1) {
sb.delete(sb.length() - 1, sb.length());
}
}
sb.append(") {").append("\n\n");
sb.append("user.role.cotain(\"/admin/add\") {");
sb.append("\n System.currentTimeMillis();\n");
sb.append("this.object = ").append("arg0");
sb.append("}");
sb.append(" \nSystem.currentTimeMillis();\n");
sb.append("\n}");
}
sb.append("\n\n}");
System.out.println(sb);
for (Method method : methods) {
System.out.println(method.getName());
}
}
private void guessClassReference(TypedValues list, String name) {
try {
Class<?> type = Class.forName(fixPotentialArrayName(name));
list.add(new TypedValue(type.getClass(), type));
} catch (ClassNotFoundException y) {
_logger.fine(name + " looked like a class reference but is not");
}
}
static {
ParticleUtils.version = "";
try {
ParticleUtils.version = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
ParticleUtils.packetType = Class.forName(getPacketPlayOutParticles());
final Class<?> typeCraftPlayer = Class.forName(getCraftPlayerClasspath());
final Class<?> typeNMSPlayer = Class.forName(getNMSPlayerClasspath());
final Class<?> typePlayerConnection = Class.forName(getPlayerConnectionClasspath());
ParticleUtils.getHandle = typeCraftPlayer.getMethod("getHandle", (Class<?>[]) new Class[0]);
ParticleUtils.playerConnection = typeNMSPlayer.getField("playerConnection");
ParticleUtils.sendPacket =
typePlayerConnection.getMethod("sendPacket", Class.forName(getPacketClasspath()));
} catch (Exception e) {
System.out.println("Failed to setup reflection for PacketPlayOutWorldParticles");
e.printStackTrace();
}
}
/**
* This creates an empty <code>Document</code> object based on a specific parser implementation.
*
* @return <code>Document</code> - created DOM Document.
* @throws JDOMException when errors occur.
*/
public Document createDocument() throws JDOMException {
try {
return (Document) Class.forName("org.apache.xerces.dom.DocumentImpl").newInstance();
} catch (Exception e) {
throw new JDOMException(
e.getClass().getName() + ": " + e.getMessage() + " when creating document", e);
}
}
static void javac(String... args) throws Exception {
Class c = Class.forName("pl.wcislo.sbql4j.tools.javac.Main", true, cl);
int status =
(Integer)
c.getMethod("compile", new Class[] {String[].class})
.invoke(c.newInstance(), new Object[] {args});
if (status != 0) throw new Exception("javac failed: status=" + status);
}
public static boolean isMySubclass(Class other) {
try {
return Class.forName(SIP_PACKAGE + ".GenericObject").isAssignableFrom(other);
} catch (Exception ex) {
InternalErrorHandler.handleException(ex);
}
return false;
}
public static Class getClassFromName(String className) {
try {
return Class.forName(className);
} catch (Exception ex) {
InternalErrorHandler.handleException(ex);
return null;
}
}
/**
* register a class indicated by name
*
* @param kryo
* @param s name of a class - might not exist
* @param handled Set of classes already handles
*/
protected void doRegistration(@Nonnull Kryo kryo, @Nonnull String s) {
Class c;
try {
c = Class.forName(s);
doRegistration(kryo, c);
} catch (ClassNotFoundException e) {
return;
}
}
