public CircuitElementView instantiateElement(
UUID elementUUID,
float positionX,
float positionY,
CircuitElementManager elementManager,
WireManager wireManager)
throws InvocationTargetException, IllegalAccessException, InstantiationException,
NoSuchMethodException {
Class<? extends CircuitElementView> viewType = ElementTypeUUID.VIEW_MAP.get(elementUUID);
if (viewType == null) throw new IllegalArgumentException("Missing element view UUID");
Class<? extends CircuitElement> elementType = ElementTypeUUID.ELEMENT_MAP.get(elementUUID);
if (elementType == null) throw new IllegalArgumentException("Missing element type UUID");
Constructor<? extends CircuitElementView> viewConstructor;
viewConstructor =
viewType.getConstructor(
Context.class, CircuitElement.class, float.class, float.class, WireManager.class);
Constructor<? extends CircuitElement> elementConstructor;
elementConstructor = elementType.getConstructor(CircuitElementManager.class);
CircuitElement element = elementConstructor.newInstance(elementManager);
return viewConstructor.newInstance(context, element, 0, 0, wireManager);
}
private static RetryPolicy instantiateRetryPolicy(
String policyClassName, Object[] args, String raw) throws Exception {
Class<?> policyClass = Class.forName(policyClassName);
for (Constructor<?> con : policyClass.getConstructors()) {
Class<?>[] parameterClasses = con.getParameterTypes();
if (args.length == parameterClasses.length) {
boolean allInts = true;
for (Class<?> pc : parameterClasses) {
if (!pc.equals(int.class)) {
allInts = false;
break;
}
}
if (!allInts) {
break;
}
log.debug("About to instantiate class {} with {} arguments", con.toString(), args.length);
return (RetryPolicy) con.newInstance(args);
}
}
throw new Exception(
"Failed to identify a class matching the Astyanax Retry Policy config string \""
+ raw
+ "\"");
}
protected static DeviceImpl importFromBEncodedMapStatic(DeviceManagerImpl manager, Map map)
throws IOException {
String impl = ImportExportUtils.importString(map, "_impl");
if (impl.startsWith(".")) {
impl = MY_PACKAGE + impl;
}
try {
Class<DeviceImpl> cla = (Class<DeviceImpl>) Class.forName(impl);
Constructor<DeviceImpl> cons = cla.getDeclaredConstructor(DeviceManagerImpl.class, Map.class);
cons.setAccessible(true);
return (cons.newInstance(manager, map));
} catch (Throwable e) {
Debug.out("Can't construct device for " + impl, e);
throw (new IOException("Construction failed: " + Debug.getNestedExceptionMessage(e)));
}
}
public static Object[] createConstructorArguments(
Constructor<?> c, Message m, boolean perRequest, Map<Class<?>, Object> contextValues) {
Class<?>[] params = c.getParameterTypes();
Annotation[][] anns = c.getParameterAnnotations();
Type[] genericTypes = c.getGenericParameterTypes();
@SuppressWarnings("unchecked")
MultivaluedMap<String, String> templateValues =
m == null ? null : (MultivaluedMap<String, String>) m.get(URITemplate.TEMPLATE_PARAMETERS);
Object[] values = new Object[params.length];
for (int i = 0; i < params.length; i++) {
if (AnnotationUtils.getAnnotation(anns[i], Context.class) != null) {
Object contextValue = contextValues != null ? contextValues.get(params[i]) : null;
if (contextValue == null) {
if (perRequest) {
values[i] = JAXRSUtils.createContextValue(m, genericTypes[i], params[i]);
} else {
values[i] = InjectionUtils.createThreadLocalProxy(params[i]);
}
} else {
values[i] = contextValue;
}
} else {
// this branch won't execute for singletons given that the found constructor
// is guaranteed to have only Context parameters, if any, for singletons
Parameter p = ResourceUtils.getParameter(i, anns[i], params[i]);
values[i] =
JAXRSUtils.createHttpParameterValue(
p, params[i], genericTypes[i], anns[i], m, templateValues, null);
}
}
return values;
}
@SuppressWarnings("unchecked")
private <T> T _get(Class<T> type, Set<Class<?>> seenTypes) {
if (!seenTypes.add(type)) {
throw new IllegalStateException("Cycle in dependencies for " + type);
}
Object singleton = singletons.get(type);
if (singleton != null) {
return (T) singleton;
}
try {
Constructor<T> constructor = getConstructor(type);
Class<?>[] parameterTypes = constructor.getParameterTypes();
Object[] parameters = new Object[parameterTypes.length];
for (int i = 0; i < parameterTypes.length; i++) {
parameters[i] = _get(parameterTypes[i], seenTypes);
}
T instance = postProcess(constructor.newInstance(parameters));
singletons.put(type, instance);
return instance;
} catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
throw new IllegalStateException("Unable to create instance of " + type);
}
}
/**
* Creates and returns a new Tickertape instance, or throws a TickerLinguaException if the passed
* parameters are not valid.
*
* @param id A unique id (not validated).
* @param intervalHours The interval as hours.
* @param enabled If this ticker is to be instantiated or not.
* @param starttime A string indicating the start time. Not yet validated.
* @param description A description of this tickertape.
* @param projects A non-empty list of HackystatProject instances.
* @param services A possibly empty list of notification services. (One might use email).
* @param tickerClass The ticker class instance.
* @param tickerProperties A possibly empty Properties instance.
* @throws TickerLinguaException If there is not at least one project and notification service.
*/
public Tickertape(
String id,
double intervalHours,
boolean enabled,
String starttime,
String description,
List<HackystatProject> projects,
List<NotificationService> services,
Class<? extends Ticker> tickerClass,
Properties tickerProperties)
throws TickerLinguaException {
this.id = id;
this.intervalHours = intervalHours;
this.enabled = enabled;
this.starttime = starttime;
this.description = description;
this.projects = projects;
if (this.projects.isEmpty()) {
throw new TickerLinguaException("At least one project must be defined.");
}
this.services = services;
try {
Constructor<? extends Ticker> ctor = tickerClass.getConstructor();
this.ticker = ctor.newInstance();
} catch (Exception e) {
throw new RuntimeException("Ticker could not be instantiated. Shouldn't ever happen!", e);
}
// Create the properties map.
for (Property property : tickerProperties.getProperty()) {
properties.put(property.getKey(), property.getValue());
}
}
/** 获取指定路径的apk的资源 */
@SuppressWarnings({"rawtypes", "unchecked"})
public static Resources getAPKResources(String apkPath) throws Exception {
Context context = UIUtils.getContext();
if (null == context) {
return null;
}
String PathAssetManager = "android.content.res.AssetManager";
Class assetMagCls = Class.forName(PathAssetManager);
Constructor assetMagCt = assetMagCls.getConstructor((Class[]) null);
Object assetMag = assetMagCt.newInstance((Object[]) null);
Class[] typeArgs = new Class[1];
typeArgs[0] = String.class;
Method assetMagAddAssetPathMtd = assetMagCls.getDeclaredMethod("addAssetPath", typeArgs);
Object[] valueArgs = new Object[1];
valueArgs[0] = apkPath;
assetMagAddAssetPathMtd.invoke(assetMag, valueArgs);
Resources res = context.getResources();
typeArgs = new Class[3];
typeArgs[0] = assetMag.getClass();
typeArgs[1] = res.getDisplayMetrics().getClass();
typeArgs[2] = res.getConfiguration().getClass();
Constructor resCt = Resources.class.getConstructor(typeArgs);
valueArgs = new Object[3];
valueArgs[0] = assetMag;
valueArgs[1] = res.getDisplayMetrics();
valueArgs[2] = res.getConfiguration();
res = (Resources) resCt.newInstance(valueArgs);
return res;
}
public static void register(Class<? extends Event> pore) {
checkNotNull(pore, "pore");
Class<? extends org.spongepowered.api.event.Event> sponge = null;
for (Constructor<?> constructor : pore.getConstructors()) {
Class<?>[] parameters = constructor.getParameterTypes();
if (parameters.length == 1) {
Class<?> parameter = parameters[0];
if (org.spongepowered.api.event.Event.class.isAssignableFrom(parameter)) {
sponge = parameter.asSubclass(org.spongepowered.api.event.Event.class);
}
}
}
checkArgument(sponge != null, "No event constructor found in %s", pore);
Class<?> superClass = pore.getSuperclass();
checkState(
!Modifier.isAbstract(superClass.getModifiers())
&& superClass.getName().startsWith("org.bukkit.event"),
"Not a Bukkit handle event %s",
superClass);
Class<? extends Event> handle = superClass.asSubclass(Event.class);
HandlerList list = SimplePluginManager.getEventListeners(handle);
list.addAdapter(create(pore, sponge));
}
@SuppressWarnings("unused")
private static Object _invoke(
MethodHandler methodHandler,
Class<? extends ClusterInvokeAcceptor> clusterInvokeAcceptorClass,
Map<String, Serializable> context)
throws Exception {
if (clusterInvokeAcceptorClass != null) {
Constructor<? extends ClusterInvokeAcceptor> constructor =
clusterInvokeAcceptorClass.getDeclaredConstructor();
if (!constructor.isAccessible()) {
constructor.setAccessible(true);
}
ClusterInvokeAcceptor clusterInvokeAcceptor = constructor.newInstance();
if (!clusterInvokeAcceptor.accept(context)) {
return null;
}
}
_populateThreadLocalsFromContext(context);
return methodHandler.invoke();
}
@NotNull
public <T extends ATNState> T newState(@NotNull Class<T> nodeType, GrammarAST node) {
Exception cause;
try {
Constructor<T> ctor = nodeType.getConstructor();
T s = ctor.newInstance();
if (currentRule == null) s.setRuleIndex(-1);
else s.setRuleIndex(currentRule.index);
atn.addState(s);
return s;
} catch (InstantiationException ex) {
cause = ex;
} catch (IllegalAccessException ex) {
cause = ex;
} catch (IllegalArgumentException ex) {
cause = ex;
} catch (InvocationTargetException ex) {
cause = ex;
} catch (NoSuchMethodException ex) {
cause = ex;
} catch (SecurityException ex) {
cause = ex;
}
String message =
String.format(
"Could not create %s of type %s.", ATNState.class.getName(), nodeType.getName());
throw new UnsupportedOperationException(message, cause);
}
/**
* Constructs an instance of a property editor using the current property editor class.
*
* <p>If the property editor class has a public constructor that takes an Object argument then it
* will be invoked using the bean parameter as the argument. Otherwise, the default constructor
* will be invoked.
*
* @param bean the source object
* @return a property editor instance or null if a property editor has not been defined or cannot
* be created
* @since 1.5
*/
public PropertyEditor createPropertyEditor(Object bean) {
Object editor = null;
Class cls = getPropertyEditorClass();
if (cls != null) {
Constructor ctor = null;
if (bean != null) {
try {
ctor = cls.getConstructor(new Class[] {Object.class});
} catch (Exception ex) {
// Fall through
}
}
try {
if (ctor == null) {
editor = cls.newInstance();
} else {
editor = ctor.newInstance(new Object[] {bean});
}
} catch (Exception ex) {
// A serious error has occured.
// Proably due to an invalid property editor.
throw new RuntimeException("PropertyEditor not instantiated", ex);
}
}
return (PropertyEditor) editor;
}
private MetaClass createWithCustomLookup(Class theClass, MetaClassRegistry registry) {
try {
final Class customMetaClass =
Class.forName("groovy.runtime.metaclass." + theClass.getName() + "MetaClass");
if (DelegatingMetaClass.class.isAssignableFrom(customMetaClass)) {
final Constructor customMetaClassConstructor =
customMetaClass.getConstructor(MetaClass.class);
MetaClass normalMetaClass = createNormalMetaClass(theClass, registry);
return (MetaClass) customMetaClassConstructor.newInstance(normalMetaClass);
} else {
final Constructor customMetaClassConstructor =
customMetaClass.getConstructor(MetaClassRegistry.class, Class.class);
return (MetaClass) customMetaClassConstructor.newInstance(registry, theClass);
}
} catch (final ClassNotFoundException e) {
return createNormalMetaClass(theClass, registry);
} catch (final Exception e) {
throw new GroovyRuntimeException(
"Could not instantiate custom Metaclass for class: "
+ theClass.getName()
+ ". Reason: "
+ e,
e);
}
}
private LineParser createDocDataLineReader(String line) {
String[] header;
String headIndicator = WriteLineDocTask.FIELDS_HEADER_INDICATOR + WriteLineDocTask.SEP;
if (line.startsWith(headIndicator)) {
header =
line.substring(headIndicator.length()).split(Character.toString(WriteLineDocTask.SEP));
skipHeaderLine = true; // mark to skip the header line when input file is reopened
} else {
header = WriteLineDocTask.DEFAULT_FIELDS;
}
// if a specific DocDataLineReader was configured, must respect it
String docDataLineReaderClassName = getConfig().get("line.parser", null);
if (docDataLineReaderClassName != null) {
try {
final Class<? extends LineParser> clazz =
Class.forName(docDataLineReaderClassName).asSubclass(LineParser.class);
Constructor<? extends LineParser> cnstr = clazz.getConstructor(String[].class);
return cnstr.newInstance((Object) header);
} catch (Exception e) {
throw new RuntimeException("Failed to instantiate " + docDataLineReaderClassName, e);
}
}
// if this the simple case,
if (Arrays.deepEquals(header, WriteLineDocTask.DEFAULT_FIELDS)) {
return new SimpleLineParser(header);
}
return new HeaderLineParser(header);
}
// Remove any previous entry in the given map with the given name
// and add an entry in the given map with the given name as the key
// and the given taglet as the value.
private static void _register(Map tagletMap, Taglet taglet) {
final String tagName = taglet.getName();
if (tagletMap.containsKey(tagName)) {
tagletMap.remove(tagName);
}
String javaSpecificationVersion = System.getProperty("java.specification.version");
if (javaSpecificationVersion != null && javaSpecificationVersion.equals("1.4")) {
tagletMap.put(taglet.getName(), taglet);
} else {
String legacyTagletClassName = "com.sun.tools.doclets.internal.toolkit.taglets.LegacyTaglet";
try {
// Use reflection so that this code will compile under jdk1.4.
Class legacyTagletClass = Class.forName(legacyTagletClassName);
Constructor legacyTagletConstructor =
legacyTagletClass.getConstructor(new Class[] {Taglet.class});
Object legacyTagletObject = legacyTagletConstructor.newInstance(new Object[] {taglet});
tagletMap.put(tagName, legacyTagletObject);
} catch (Throwable throwable) {
throwable.printStackTrace();
throw new RuntimeException(
"Problem with the '" + legacyTagletClassName + "' class: ", throwable);
}
}
}
/**
* Convert {@code Object} value to a value of the specified class type.
*
* @param value {@code Object} value to convert.
* @param type conversion type.
* @param <T> converted value type.
* @return value converted to the specified class type.
*/
public static <T> T convertValue(Object value, Class<T> type) {
if (!type.isInstance(value)) {
// TODO: Move string value readers from server to common and utilize them here
final Constructor constructor =
AccessController.doPrivileged(ReflectionHelper.getStringConstructorPA(type));
if (constructor != null) {
try {
return type.cast(constructor.newInstance(value));
} catch (Exception e) {
// calling the constructor wasn't successful - ignore and try valueOf()
}
}
final Method valueOf =
AccessController.doPrivileged(ReflectionHelper.getValueOfStringMethodPA(type));
if (valueOf != null) {
try {
return type.cast(valueOf.invoke(null, value));
} catch (Exception e) {
// calling valueOf wasn't successful
}
}
// at this point we don't know what to return -> return null
if (LOGGER.isLoggable(Level.WARNING)) {
LOGGER.warning(
LocalizationMessages.PROPERTIES_HELPER_GET_VALUE_NO_TRANSFORM(
String.valueOf(value), value.getClass().getName(), type.getName()));
}
return null;
}
return type.cast(value);
}
protected boolean initInstance(
NyARIntSize size, Class<? extends INyARRgbPixelReader> pixelReaderClass, boolean isAlloc) {
int bufferType = getBufferType(pixelReaderClass);
// 0:24bit, 1:32bit, 2:16bit
int bufferSize = bufferType >> 16 & 0x3;
bufferSize = bufferSize == 0 ? 3 : (bufferSize == 1 ? 4 : 2);
// 1:byte[], 2:int[][], 3:short[], 4:int[], ...
Class<?> type;
if ((bufferType & T_BYTE1D) != 0) {
type = byte[].class;
this.buffer = isAlloc ? new byte[size.w * size.h * bufferSize] : null;
} else if ((bufferType & T_INT1D) != 0) {
type = int[].class;
this.buffer = isAlloc ? new int[size.w * size.h] : null;
} else {
return false;
}
this.isAttachedBuffer = isAlloc;
// Instantiate pixel reader.
try {
Constructor<? extends INyARRgbPixelReader> constructor =
pixelReaderClass.getConstructor(type, NyARIntSize.class);
this.reader = constructor.newInstance(this.buffer, size);
} catch (Exception e) {
return false;
}
return true;
}
public static void main(String[] args) throws Exception {
System.out.println("Well, you think your EnumSingleton is really a singleton");
System.out.println(
"The id of the INSTANCE object is " + System.identityHashCode(EnumSingleton.INSTANCE));
System.out.println("I will create another instance using reflection");
Constructor<EnumSingleton> privateConstructor =
EnumSingleton.class.getDeclaredConstructor(String.class, int.class);
privateConstructor.setAccessible(true);
try {
privateConstructor.newInstance();
} catch (IllegalArgumentException e) {
System.out.println(
"D'oh! An exception prevented me from creating a new instance: " + e.getMessage());
}
System.out.println("Hmm, I will try one more option - Serialisation");
EnumSingleton clone = SerializationUtils.clone(EnumSingleton.INSTANCE);
System.out.println(
"D'oh! Even serialization did not work. id = " + System.identityHashCode(clone));
System.out.println("I give up");
}
/** For internal use only. */
private static Object makeDerivedWrapper(Element elt, String baseTypeName) {
synchronized (DOMUtils.getDOMLock(elt)) {
QName typeName = XArchUtils.getXSIType(elt);
if (typeName == null) {
return null;
} else {
if (!DOMUtils.hasXSIType(
elt, "http://www.ics.uci.edu/pub/arch/xArch/changesets.xsd", baseTypeName)) {
try {
String packageTitle = XArchUtils.getPackageTitle(typeName.getNamespaceURI());
String packageName = XArchUtils.getPackageName(packageTitle);
String implName = XArchUtils.getImplName(packageName, typeName.getName());
Class c = Class.forName(implName);
java.lang.reflect.Constructor con = c.getConstructor(new Class[] {Element.class});
Object o = con.newInstance(new Object[] {elt});
return o;
} catch (Exception e) {
// Lots of bad things could happen, but this
// is OK, because this is best-effort anyway.
}
}
return null;
}
}
}
@SuppressWarnings("unchecked")
private Work openEditor(String editorClassName, WorkDefinition workDefinition) {
IJavaProject javaProject = getProject();
if (javaProject != null) {
try {
ClassLoader oldLoader = Thread.currentThread().getContextClassLoader();
ClassLoader newLoader = ProjectClassLoader.getProjectClassLoader(javaProject);
try {
Thread.currentThread().setContextClassLoader(newLoader);
Class<WorkEditor> editorClass = (Class<WorkEditor>) newLoader.loadClass(editorClassName);
Constructor<WorkEditor> constructor = editorClass.getConstructor(Shell.class);
WorkEditor editor = constructor.newInstance(getViewer().getControl().getShell());
editor.setWorkDefinition(workDefinition);
WorkItemNode workItemNode = getWorkItemWrapper().getWorkItemNode();
editor.setWork(workItemNode.getWork());
boolean result = editor.show();
return result ? editor.getWork() : null;
} finally {
Thread.currentThread().setContextClassLoader(oldLoader);
}
} catch (Exception e) {
DroolsEclipsePlugin.log(e);
}
}
return null;
}
@Override
public void serviceInit(Configuration conf) throws Exception {
Constructor<?> cons;
try {
if (conf instanceof TajoConf) {
this.conf = (TajoConf) conf;
} else {
throw new TajoInternalError("conf must be a TajoConf instance");
}
Class<?> storeClass = this.conf.getClass(CatalogConstants.STORE_CLASS, DerbyStore.class);
LOG.info("Catalog Store Class: " + storeClass.getCanonicalName());
cons = storeClass.getConstructor(new Class[] {Configuration.class});
this.store = (CatalogStore) cons.newInstance(this.conf);
initBuiltinFunctions(builtingFuncs);
} catch (Throwable t) {
LOG.error("CatalogServer initialization failed", t);
throw new TajoInternalError(t);
}
super.serviceInit(conf);
}
public Object exec(List arguments) throws TemplateModelException {
int size = arguments.size();
if (size < 1) {
throw new TemplateModelException("Invalid number of arguments for new(class, ...) method");
}
Class<?> klass;
try {
String className = (String) arguments.get(0);
klass = Class.forName(className);
if (size == 1) {
return klass.newInstance();
}
} catch (ReflectiveOperationException e) {
throw new TemplateModelException("Failed to isntantiate the object", e);
}
arguments.remove(0);
Object[] ar = arguments.toArray();
size--;
Constructor<?>[] ctors = klass.getConstructors();
for (Constructor<?> ctor : ctors) {
Class<?>[] params = ctor.getParameterTypes(); // this is cloning params
if (params.length == size) { // try this one
try {
return ctor.newInstance(ar);
} catch (ReflectiveOperationException e) {
// continue
}
}
}
throw new TemplateModelException("No suitable constructor found");
}
private BrowserLauncher createBrowserLauncher(
Class c, String browserStartCommand, String sessionId, SeleneseQueue queue) {
try {
BrowserLauncher browserLauncher;
if (null == browserStartCommand) {
Constructor ctor = c.getConstructor(new Class[] {int.class, String.class});
Object[] args = new Object[] {new Integer(server.getPort()), sessionId};
browserLauncher = (BrowserLauncher) ctor.newInstance(args);
} else {
Constructor ctor = c.getConstructor(new Class[] {int.class, String.class, String.class});
Object[] args =
new Object[] {
new Integer(SeleniumServer.getPortDriversShouldContact()),
sessionId,
browserStartCommand
};
browserLauncher = (BrowserLauncher) ctor.newInstance(args);
}
if (browserLauncher instanceof SeleneseQueueAware) {
((SeleneseQueueAware) browserLauncher).setSeleneseQueue(queue);
}
return browserLauncher;
} catch (InvocationTargetException e) {
throw new RuntimeException(
"failed to contruct launcher for "
+ browserStartCommand
+ "for"
+ e.getTargetException());
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 创建Dao对象
*
* @param clazz Dao类型
* @param sourceType 数据源类型
* @param dbType 数据库类型
* @return
* @throws Exception
*/
private Object createDao(Class<?> clazz, SourceType sourceType, DbType dbType) throws Exception {
Constructor<?> constructor =
(Constructor<?>) clazz.getConstructor(SourceType.class, DbType.class);
Object obj = constructor.newInstance(sourceType, dbType);
daoContainer.put(clazz, obj);
return obj;
}
public static void create() throws Exception {
ObjectType type = ObjectType.get(getControllerClass());
notFoundIfNull(type);
Constructor<?> constructor = type.entityClass.getDeclaredConstructor();
constructor.setAccessible(true);
Model object = (Model) constructor.newInstance();
Binder.bindBean(params.getRootParamNode(), "object", object);
validation.valid(object);
if (validation.hasErrors()) {
renderArgs.put("error", play.i18n.Messages.get("crud.hasErrors"));
try {
render(request.controller.replace(".", "/") + "/blank.html", type, object);
} catch (TemplateNotFoundException e) {
render("CRUD/blank.html", type, object);
}
}
object._save();
flash.success(play.i18n.Messages.get("crud.created", type.modelName));
if (params.get("_save") != null) {
redirect(request.controller + ".list");
}
if (params.get("_saveAndAddAnother") != null) {
redirect(request.controller + ".blank");
}
redirect(request.controller + ".show", object._key());
}
public static Constructor<?> findResourceConstructor(Class<?> resourceClass, boolean perRequest) {
List<Constructor<?>> cs = new LinkedList<Constructor<?>>();
for (Constructor<?> c : resourceClass.getConstructors()) {
Class<?>[] params = c.getParameterTypes();
Annotation[][] anns = c.getParameterAnnotations();
boolean match = true;
for (int i = 0; i < params.length; i++) {
if (!perRequest) {
if (AnnotationUtils.getAnnotation(anns[i], Context.class) == null) {
match = false;
break;
}
} else if (!AnnotationUtils.isValidParamAnnotations(anns[i])) {
match = false;
break;
}
}
if (match) {
cs.add(c);
}
}
Collections.sort(
cs,
new Comparator<Constructor<?>>() {
public int compare(Constructor<?> c1, Constructor<?> c2) {
int p1 = c1.getParameterTypes().length;
int p2 = c2.getParameterTypes().length;
return p1 > p2 ? -1 : p1 < p2 ? 1 : 0;
}
});
return cs.size() == 0 ? null : cs.get(0);
}
public static JTFCommand generateCommandObject(String rawCommand) throws Exception {
if (rawCommand == null) {
throw new JTFException("rawCommand should not be null");
}
String[] tokens = rawCommand.split("\\s+");
// JTFCommand command = (JTFCommand)
// Class.forName("com.sandisk.zsjtf.command." +
// tokens[0]).newInstance();
// command.setArgs(parse(tokens));
Class<?> clazz = Class.forName("com.sandisk.zsjtf.command." + tokens[0]);
// Properties initargs = parse(tokens);
Constructor<?> constructor = clazz.getConstructor(String.class);
JTFCommand command = (JTFCommand) constructor.newInstance(rawCommand);
// if(command.getClass().equals(ZSOpenContainer.class)){
// ContainerProperty containerProps = ContainerProperty
// .getDefaultProperty();
//
// ZSOpenContainer zsOpenContainer = (ZSOpenContainer)command;
//
// zsOpenContainer.setContainerProperty(containerProps);
// return zsOpenContainer;
// }
//
return command;
}
private void postNext() throws HibernateException, SQLException {
this.hasNext = rs.next();
if (!hasNext) {
log.debug("exhausted results");
close();
} else {
log.debug("retrieving next results");
if (single) {
nextResult = types[0].nullSafeGet(rs, names[0], sess, null);
} else {
Object[] nextResults = new Object[types.length];
for (int i = 0; i < types.length; i++) {
nextResults[i] = types[i].nullSafeGet(rs, names[i], sess, null);
}
nextResult = nextResults;
}
if (holderConstructor != null) {
try {
if (nextResult == null || !nextResult.getClass().isArray()) {
nextResult = holderConstructor.newInstance(new Object[] {nextResult});
} else {
nextResult = holderConstructor.newInstance((Object[]) nextResult);
}
} catch (Exception e) {
throw new QueryException(
"Could not instantiate: " + holderConstructor.getDeclaringClass(), e);
}
}
}
}
@Test
public void chanson() throws Throwable {
checkConstructor(chanson, String.class, String.class, temps);
collector.checkThat(constructor.newInstance("", "", null), instanceOf(chanson));
collector.checkThat(constructor.newInstance("a", "a", null), instanceOf(chanson));
}
protected WebDriver createInstanceOf(String className) {
try {
DesiredCapabilities capabilities = createCommonCapabilities();
capabilities.setJavascriptEnabled(true);
capabilities.setCapability(TAKES_SCREENSHOT, true);
capabilities.setCapability(ACCEPT_SSL_CERTS, true);
capabilities.setCapability(SUPPORTS_ALERTS, true);
if (isPhantomjs()) {
capabilities.setCapability(
"phantomjs.cli.args", // PhantomJSDriverService.PHANTOMJS_CLI_ARGS ==
// "phantomjs.cli.args"
new String[] {"--web-security=no", "--ignore-ssl-errors=yes"});
}
Class<?> clazz = Class.forName(className);
if (WebDriverProvider.class.isAssignableFrom(clazz)) {
return ((WebDriverProvider) clazz.newInstance()).createDriver(capabilities);
} else {
Constructor<?> constructor = Class.forName(className).getConstructor(Capabilities.class);
return (WebDriver) constructor.newInstance(capabilities);
}
} catch (InvocationTargetException e) {
throw runtime(e.getTargetException());
} catch (Exception invalidClassName) {
throw new IllegalArgumentException(invalidClassName);
}
}
@Override
public int compare(Constructor<?> o1, Constructor<?> o2) {
int p1 = o1.getParameterTypes().length;
int p2 = o2.getParameterTypes().length;
return (p1 < p2) ? 1 : ((p1 == p2) ? 0 : -1);
}