private static STClass[] sodaTestCases() { STClass[] commonCases = commonTestCases(); STClass[] collectionCases = collectionTestCases(); STClass[] allCases = new STClass[commonCases.length + collectionCases.length]; System.arraycopy(commonCases, 0, allCases, 0, commonCases.length); System.arraycopy(collectionCases, 0, allCases, commonCases.length, collectionCases.length); return allCases; }
<T> T[] concat(T[] a, T[] b) { if ((b == null) || (b.length == 0)) { return a; } T[] r = (T[]) java.lang.reflect.Array.newInstance( a.getClass().getComponentType(), a.length + b.length); System.arraycopy(a, 0, r, 0, a.length); System.arraycopy(b, 0, r, a.length, b.length); return r; }
private JAXBContext newJAXBContext(final Class<?>... pClasses) throws JAXBException { Class<?>[] classList; final Class<?> clazz = getDeclaringClass(); final XmlSeeAlso seeAlso = clazz.getAnnotation(XmlSeeAlso.class); if ((seeAlso != null) && (seeAlso.value().length > 0)) { final Class<?>[] seeAlsoClasses = seeAlso.value(); classList = new Class<?>[seeAlsoClasses.length + pClasses.length]; System.arraycopy(seeAlsoClasses, 0, classList, 0, seeAlsoClasses.length); System.arraycopy(pClasses, 0, classList, seeAlsoClasses.length, pClasses.length); } else { classList = pClasses; } return JAXBContext.newInstance(classList); }
/** * @generate serialEvent.xml * @webref serial:events * @usage web_application * @param event the port where new data is available */ public void serialEvent(SerialPortEvent event) { if (event.getEventType() == SerialPortEvent.RXCHAR) { int toRead; try { while (0 < (toRead = port.getInputBufferBytesCount())) { // this method can be called from the context of another thread synchronized (buffer) { // read one byte at a time if the sketch is using serialEvent if (serialEventMethod != null) { toRead = 1; } // enlarge buffer if necessary if (buffer.length < inBuffer + toRead) { byte temp[] = new byte[buffer.length << 1]; System.arraycopy(buffer, 0, temp, 0, inBuffer); buffer = temp; } // read an array of bytes and copy it into our buffer byte[] read = port.readBytes(toRead); System.arraycopy(read, 0, buffer, inBuffer, read.length); inBuffer += read.length; } if (serialEventMethod != null) { if ((0 < bufferUntilSize && bufferUntilSize <= inBuffer - readOffset) || (0 == bufferUntilSize && bufferUntilByte == buffer[inBuffer - 1])) { try { // serialEvent() is invoked in the context of the current (serial) thread // which means that serialization and atomic variables need to be used to // guarantee reliable operation (and better not draw() etc..) // serialAvailable() does not provide any real benefits over using // available() and read() inside draw - but this function has no // thread-safety issues since it's being invoked during pre in the context // of the Processing applet serialEventMethod.invoke(parent, this); } catch (Exception e) { System.err.println("Error, disabling serialEvent() for " + port.getPortName()); System.err.println(e.getLocalizedMessage()); serialEventMethod = null; } } } invokeSerialAvailable = true; } } catch (SerialPortException e) { throw new RuntimeException( "Error reading from serial port " + e.getPortName() + ": " + e.getExceptionType()); } } }
/** * Returns the clone of <code>o_</code>. It calls <code>o_.clone()</code>, if possible, and either * raises an exception or returns null if fails. * * @param raiseException_ set to true if one wishes to get exception instead of receiving null * when this method fails to call <code>o_.clone()</code>. */ public static Object clone(Object o_, boolean raiseException_) { if (o_ == null) return null; if (o_ instanceof String) return o_; try { if (o_ instanceof drcl.ObjectCloneable) return ((drcl.ObjectCloneable) o_).clone(); if (o_.getClass().isArray()) { int length_ = Array.getLength(o_); Class componentType_ = o_.getClass().getComponentType(); Object that_ = Array.newInstance(componentType_, length_); if (componentType_.isPrimitive()) System.arraycopy(o_, 0, that_, 0, length_); else { for (int i = 0; i < length_; i++) Array.set(that_, i, clone(Array.get(o_, i), raiseException_)); } return that_; } Method m_ = o_.getClass().getMethod("clone", null); return m_.invoke(o_, null); } catch (Exception e_) { if (raiseException_) { Thread t_ = Thread.currentThread(); t_.getThreadGroup().uncaughtException(t_, e_); } return null; } }
private static void handleTileEntityPacket(Packet230ModLoader packet230modloader) { if (packet230modloader.dataInt == null || packet230modloader.dataInt.length < 5) { log("Bad TileEntityPacket received."); } else { int i = packet230modloader.dataInt[0]; int j = packet230modloader.dataInt[1]; int k = packet230modloader.dataInt[2]; int l = packet230modloader.dataInt[3]; int i1 = packet230modloader.dataInt[4]; int ai[] = new int[packet230modloader.dataInt.length - 5]; System.arraycopy(packet230modloader.dataInt, 5, ai, 0, packet230modloader.dataInt.length - 5); float af[] = packet230modloader.dataFloat; String as[] = packet230modloader.dataString; for (int j1 = 0; j1 < ModLoader.getLoadedMods().size(); j1++) { BaseMod basemod = (BaseMod) ModLoader.getLoadedMods().get(j1); if (!(basemod instanceof BaseModMp)) { continue; } BaseModMp basemodmp = (BaseModMp) basemod; if (basemodmp.getId() != i) { continue; } basemodmp.handleTileEntityPacket(j, k, l, i1, ai, af, as); break; } } }
/** * @generate Serial_readBytesUntil.xml * @webref serial:serial * @usage web_application * @param inByte character designated to mark the end of the data */ public byte[] readBytesUntil(int inByte) { if (inBuffer == readOffset) { return null; } synchronized (buffer) { // look for needle in buffer int found = -1; for (int i = readOffset; i < inBuffer; i++) { if (buffer[i] == (byte) inByte) { found = i; break; } } if (found == -1) { return null; } int toCopy = found - readOffset + 1; byte[] dest = new byte[toCopy]; System.arraycopy(buffer, readOffset, dest, 0, toCopy); readOffset += toCopy; if (inBuffer == readOffset) { inBuffer = 0; readOffset = 0; } return dest; } }
/** * attempt to invoke a Method with the given Object arguments, performing static method * auto-detection and automatic array compression */ public static Object invokeMethod(Method m, Object[] o) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException { Object obj; Object[] args; Class[] c = m.getParameterTypes(); int num = (o == null) ? 0 : o.length; int len = -1; int a = -1; if (c != null) { len = c.length; for (int i = 0; i < len; i++) { if (c[i].isArray()) a = i; } } if (Modifier.isStatic(m.getModifiers())) { // static method obj = null; if (num > 0) { if (a < 0) { args = new Object[num]; System.arraycopy(o, 0, args, 0, num); } else { // compress some of the arguments into array form args = new Object[len]; if (a > 0) System.arraycopy(o, 0, args, 0, a); Object array = Array.newInstance(c[a].getComponentType(), num - len + 1); System.arraycopy(o, a, array, 0, num - len + 1); args[a] = array; if (a < len - 1) System.arraycopy(o, num - len + a + 1, args, a + 1, len - a - 1); } } else args = null; } else { // object method if (num > 0) obj = o[0]; else { // invalid object method return null; } if (num > 1) { if (a < 0) { args = new Object[num - 1]; System.arraycopy(o, 1, args, 0, num - 1); } else { // compress some of the arguments into array form args = new Object[len]; if (a > 0) System.arraycopy(o, 1, args, 0, a); Object array = Array.newInstance(c[a].getComponentType(), num - len); System.arraycopy(o, a + 1, array, 0, num - len); args[a + 1] = array; if (a < len - 1) System.arraycopy(o, num - len + a + 1, args, a + 1, len - a - 1); } } else args = null; } return m.invoke(obj, args); }
/** * Returns the generic type information of an attribute. * * @param field the field representation of the attribute. * @return an array of types that are used to parameterize the attribute. */ public static Class<?>[] getGenericTypes(Field field) { Type genericFieldType = field.getGenericType(); if (!(genericFieldType instanceof ParameterizedType)) return null; // type is not generic ParameterizedType pType = (ParameterizedType) genericFieldType; Type[] args = pType.getActualTypeArguments(); Class<?>[] types = new Class[args.length]; System.arraycopy(args, 0, types, 0, args.length); return types; }
public int write(byte[] buffer, int offset, int length, boolean transform) { RawPacket pkt = rawPacketArray[0]; if (pkt == null) pkt = new RawPacket(); rawPacketArray[0] = pkt; byte[] pktBuf = pkt.getBuffer(); if (pktBuf == null || pktBuf.length < length) { pktBuf = new byte[length]; pkt.setBuffer(pktBuf); } System.arraycopy(buffer, offset, pktBuf, 0, length); pkt.setOffset(0); pkt.setLength(length); if (transform) { PacketTransformer packetTransformer = isControlStream ? rtcpPacketTransformer : rtpPacketTransformer; if (packetTransformer != null) rawPacketArray = packetTransformer.reverseTransform(rawPacketArray); } SourceTransferHandler transferHandler; PushSourceStream pushSourceStream; try { if (isControlStream) { transferHandler = controlTransferHandler; pushSourceStream = getControlInputStream(); } else { transferHandler = dataTransferHandler; pushSourceStream = getDataInputStream(); } } catch (IOException ioe) { throw new UndeclaredThrowableException(ioe); } for (int i = 0; i < rawPacketArray.length; i++) { RawPacket packet = rawPacketArray[i]; // keep the first element for reuse if (i != 0) rawPacketArray[i] = null; if (packet != null) { if (isControlStream) pendingControlPacket = packet; else pendingDataPacket = packet; if (transferHandler != null) { transferHandler.transferData(pushSourceStream); } } } return length; }
protected static Object[] extractMockArguments(Object[] args) { int i = 7; if (args.length > i) { Object[] mockArgs = new Object[args.length - i]; System.arraycopy(args, i, mockArgs, 0, mockArgs.length); return mockArgs; } return EMPTY_ARGS; }
/** * @generate Serial_readBytes.xml * @webref serial:serial * @usage web_application */ public byte[] readBytes() { if (inBuffer == readOffset) { return null; } synchronized (buffer) { byte[] ret = new byte[inBuffer - readOffset]; System.arraycopy(buffer, readOffset, ret, 0, ret.length); inBuffer = 0; readOffset = 0; return ret; } }
/** * Add a listener * * @param listener * @param highPriority true if the listener should be put on the front of the list, false if it * should be added to the end. * @return true if the listener was added, false if it was already present */ protected final boolean addListener(Object listener, boolean highPriority) { // bail if the listener is already added for (int i = 0; i < fListeners.length; i++) { if (fListeners[i] == listener) return false; } // make a new listener array, one element larger than the old one // and add the new listener to the end Object[] newArray = new Object[fListeners.length + 1]; if (highPriority) { // add to front of list System.arraycopy(fListeners, 0, newArray, 1, fListeners.length); newArray[0] = listener; } else { // add to end of list System.arraycopy(fListeners, 0, newArray, 0, fListeners.length); newArray[fListeners.length] = listener; } // make it the active array fListeners = newArray; return true; }
public static <T> T mixin(T target, Class<?>... interfaces) { if (target == null) return null; // When request is final Class<?> targetClass = target.getClass(); if (Arrays.stream(interfaces).allMatch(i -> i.isAssignableFrom(targetClass))) { return target; } Class[] classes; int addedIndex; if (Proxy.isProxyClass(targetClass)) { MixinProxyHandler<T> handler = ((MixinProxyHandler<T>) Proxy.getInvocationHandler(target)); target = handler.getOriginal(); Class[] originalInterfaces = handler.getProxyInterfaces(); classes = new Class[originalInterfaces.length + interfaces.length]; System.arraycopy(originalInterfaces, 0, classes, 0, originalInterfaces.length); addedIndex = originalInterfaces.length; } else { Class[] targetInterfaces = getAllInterfaces(targetClass); classes = new Class[targetInterfaces.length + interfaces.length]; System.arraycopy(targetInterfaces, 0, classes, 0, targetInterfaces.length); addedIndex = targetInterfaces.length; } Arrays.asList(interfaces) .forEach( i -> Arrays.asList(i.getMethods()) .stream() .filter(Method::isDefault) .forEach(MixinUtils::getMethodHandle)); System.arraycopy(interfaces, 0, classes, addedIndex, interfaces.length); ClassLoader cl = Thread.currentThread().getContextClassLoader(); return (T) Proxy.newProxyInstance(cl, classes, new MixinProxyHandler(target, classes)); }
public PGroupElementArray toElementArray(PGroupElementArray... arrays) { int total = 0; for (int i = 0; i < arrays.length; i++) { total += arrays[i].size(); } PGroupElement[] res = new PGroupElement[total]; int offset = 0; for (int i = 0; i < arrays.length; i++) { int len = arrays[i].size(); System.arraycopy(arrays[i].elements(), 0, res, offset, len); offset += len; } return new BPGroupElementArray(this, res); }
/** * Unsupported command line interface. * * @param args The command line parameters. */ public static void main(String[] args) throws Exception { if (args.length > 0 && args[0].equals("-Xjdb")) { String[] newargs = new String[args.length + 2]; Class<?> c = Class.forName("com.redhat.ceylon.langtools.tools.example.debug.tty.TTY"); Method method = c.getDeclaredMethod("main", new Class<?>[] {args.getClass()}); method.setAccessible(true); System.arraycopy(args, 1, newargs, 3, args.length - 1); newargs[0] = "-connect"; newargs[1] = "com.redhat.ceylon.langtools.jdi.CommandLineLaunch:options=-esa -ea:com.redhat.ceylon.langtools.tools..."; newargs[2] = "com.redhat.ceylon.langtools.tools.javac.Main"; method.invoke(null, new Object[] {newargs}); } else { System.exit(compile(args)); } }
public R invoke(Object[] arguments) throws MethodInvokeFailedException { int expectedNumArgs = method.getParameterTypes().length; R result; if ((arguments.length != expectedNumArgs && !method.isVarArgs()) || (arguments.length < expectedNumArgs && (arguments.length == expectedNumArgs - 1 && !method.isVarArgs()))) { throw new MethodInvokeFailedException( String.format( "Incorrect number of arguments for method specified invoking %1$s (expected %2$s; received: %3$s).", method.getName(), expectedNumArgs, arguments.length)); } Object[] args = null; try { if (method.isVarArgs()) { args = new Object[method.getParameterTypes().length]; // Copy over fixed arguments for (int i = 0; i < args.length - 1; i++) { args[i] = arguments[i]; } // Prepare variable argument for last position of arguments array Class type = method.getParameterTypes()[method.getParameterTypes().length - 1].getComponentType(); Object[] varArgs = (Object[]) java.lang.reflect.Array.newInstance(type, (arguments.length - expectedNumArgs) + 1); System.arraycopy(arguments, args.length - 1, varArgs, 0, varArgs.length); args[args.length - 1] = varArgs; result = (R) method.invoke(target, args); } else { // args = validateTypes(arguments, method.getParameterTypes()); args = arguments; result = (R) method.invoke(target, args); } } catch (Exception e) { throw new MethodInvokeFailedException( String.format( "Exception thrown invoking %1$s with arguments %2$s.", method.getName(), java.util.Arrays.deepToString(args)), e); } return result; }
/** * * * <h3>Advanced</h3> * * Grab whatever is in the serial buffer, and stuff it into a byte buffer passed in by the user. * This is more memory/time efficient than readBytes() returning a byte[] array. * * <p>Returns an int for how many bytes were read. If more bytes are available than can fit into * the byte array, only those that will fit are read. */ public int readBytes(byte[] dest) { if (inBuffer == readOffset) { return 0; } synchronized (buffer) { int toCopy = inBuffer - readOffset; if (dest.length < toCopy) { toCopy = dest.length; } System.arraycopy(buffer, readOffset, dest, 0, toCopy); readOffset += toCopy; if (inBuffer == readOffset) { inBuffer = 0; readOffset = 0; } return toCopy; } }
static Object js_createAdpter(Context cx, Scriptable scope, Object[] args) { int N = args.length; if (N == 0) { throw ScriptRuntime.typeError0("msg.adapter.zero.args"); } Class superClass = null; Class[] intfs = new Class[N - 1]; int interfaceCount = 0; for (int i = 0; i != N - 1; ++i) { Object arg = args[i]; if (!(arg instanceof NativeJavaClass)) { throw ScriptRuntime.typeError2( "msg.not.java.class.arg", String.valueOf(i), ScriptRuntime.toString(arg)); } Class c = ((NativeJavaClass) arg).getClassObject(); if (!c.isInterface()) { if (superClass != null) { throw ScriptRuntime.typeError2("msg.only.one.super", superClass.getName(), c.getName()); } superClass = c; } else { intfs[interfaceCount++] = c; } } if (superClass == null) superClass = ScriptRuntime.ObjectClass; Class[] interfaces = new Class[interfaceCount]; System.arraycopy(intfs, 0, interfaces, 0, interfaceCount); Scriptable obj = ScriptRuntime.toObject(cx, scope, args[N - 1]); Class adapterClass = getAdapterClass(scope, superClass, interfaces, obj); Class[] ctorParms = {ScriptRuntime.ContextFactoryClass, ScriptRuntime.ScriptableClass}; Object[] ctorArgs = {cx.getFactory(), obj}; try { Object adapter = adapterClass.getConstructor(ctorParms).newInstance(ctorArgs); return getAdapterSelf(adapterClass, adapter); } catch (Exception ex) { throw Context.throwAsScriptRuntimeEx(ex); } }
@Override public int read(byte[] buffer, int offset, int length) throws IOException { RawPacket pendingPacket; if (isControlStream) { pendingPacket = pendingControlPacket; } else { pendingPacket = pendingDataPacket; } int bytesToRead = 0; byte[] pendingPacketBuffer = pendingPacket.getBuffer(); if (pendingPacketBuffer != null) { int pendingPacketLength = pendingPacket.getLength(); bytesToRead = length > pendingPacketLength ? pendingPacketLength : length; System.arraycopy( pendingPacketBuffer, pendingPacket.getOffset(), buffer, offset, bytesToRead); } return bytesToRead; }
/** * * * <h3>Advanced</h3> * * Return a byte array of anything that's in the serial buffer up to the specified maximum number * of bytes. Not particularly memory/speed efficient, because it creates a byte array on each * read, but it's easier to use than readBytes(byte b[]) (see below). * * @param max the maximum number of bytes to read */ public byte[] readBytes(int max) { if (inBuffer == readOffset) { return null; } synchronized (buffer) { int length = inBuffer - readOffset; if (length > max) length = max; byte[] ret = new byte[length]; System.arraycopy(buffer, readOffset, ret, 0, length); readOffset += length; if (inBuffer == readOffset) { inBuffer = 0; readOffset = 0; } return ret; } }
/** * Creates a new AgentMBeanServerConnectionFactory * * @param builder The AgentMBeanServerConnectionFactory builder */ protected AgentMBeanServerConnectionFactory(Builder builder) { this.channel = builder.channel; this.remoteAddress = builder.remoteAddress == null ? this.channel.getRemoteAddress() : builder.remoteAddress; this.timeout = builder.timeout; this.listener = builder.listener; this.domain = builder.domain; if ("DefaultDomain".equals(domain)) { domainInfoData = new byte[] {0}; } else { byte[] domainBytes = domain.getBytes(); domainInfoData = new byte[domainBytes.length + 1]; domainInfoData[0] = (byte) domainBytes.length; System.arraycopy(domainBytes, 0, domainInfoData, 1, domainBytes.length); } if (channel.getPipeline().get(getClass().getSimpleName()) == null) { this.channel.getPipeline().addFirst(getClass().getSimpleName(), responseHandler); // LoggingHandler logg = new LoggingHandler(InternalLogLevel.ERROR, true); // this.channel.getPipeline().addFirst("logger", logg); } }
/** * Invoke the user defined static method in the nested "Duck" class so that the user can define * convenience methods on the config beans. */ Object invokeDuckMethod(Method method, Object proxy, Object[] args) throws Exception { Method duckMethod = model.getDuckMethod(method); Object[] duckArgs; if (args == null) { duckArgs = new Object[] {proxy}; } else { duckArgs = new Object[args.length + 1]; duckArgs[0] = proxy; System.arraycopy(args, 0, duckArgs, 1, args.length); } try { return duckMethod.invoke(null, duckArgs); } catch (InvocationTargetException e) { Throwable t = e.getTargetException(); if (t instanceof Exception) throw (Exception) t; if (t instanceof Error) throw (Error) t; throw e; } }
public static void main(String[] args) { if (args.length < 3) { System.out.println( "Usage: java CleanupConstants <OS className> <class source> <src path1> <src path2>"); return; } try { CleanupConstants gen = new CleanupConstants(); String clazzName = args[0]; String classSource = args[1]; String[] sourcePath = new String[args.length - 2]; System.arraycopy(args, 2, sourcePath, 0, sourcePath.length); Class<?> clazz = Class.forName(clazzName); gen.setSourcePath(sourcePath); gen.setClassSourcePath(classSource); gen.generate(new ReflectClass(clazz)); } catch (Exception e) { System.out.println("Problem"); e.printStackTrace(System.out); } }
/** * * * <h3>Advanced</h3> * * If dest[] is not big enough, then -1 is returned, and an error message is printed on the * console. If nothing is in the buffer, zero is returned. If 'interesting' byte is not in the * buffer, then 0 is returned. * * @param dest passed in byte array to be altered */ public int readBytesUntil(int inByte, byte[] dest) { if (inBuffer == readOffset) { return 0; } synchronized (buffer) { // look for needle in buffer int found = -1; for (int i = readOffset; i < inBuffer; i++) { if (buffer[i] == (byte) inByte) { found = i; break; } } if (found == -1) { return 0; } // check if bytes to copy fit in dest int toCopy = found - readOffset + 1; if (dest.length < toCopy) { System.err.println( "The buffer passed to readBytesUntil() is to small " + "to contain " + toCopy + " bytes up to and including " + "char " + (byte) inByte); return -1; } System.arraycopy(buffer, readOffset, dest, 0, toCopy); readOffset += toCopy; if (inBuffer == readOffset) { inBuffer = 0; readOffset = 0; } return toCopy; } }
/** * Deserializes an array of arguments from a byte array * * @param bytes The byte array containing the serialized arguments * @return an object array */ public static Object[] getInput(byte[] bytes) { if (bytes.length == 0 || (bytes.length == 1 && bytes[0] == 0)) return new Object[0]; ByteArrayInputStream bais = new ByteArrayInputStream(bytes); ObjectInputStream ois = null; GZIPInputStream gzis = null; Object[] args = null; try { gzis = new GZIPInputStream(bais); ois = new ObjectInputStream(gzis); Object obj = ois.readObject(); if (obj.getClass().isArray()) { args = new Object[Array.getLength(obj)]; System.arraycopy(obj, 0, args, 0, args.length); } else { args = new Object[] {obj}; } return args; } catch (Exception ex) { throw new RuntimeException("Failed to decode MBeanServerConnection Invocation arguments", ex); } finally { try { bais.close(); } catch (Exception ex) { /* No Op */ } if (ois != null) try { ois.close(); } catch (Exception ex) { /* No Op */ } if (gzis != null) try { gzis.close(); } catch (Exception ex) { /* No Op */ } } }
public static int[] createInterceptors( InjectManager manager, ArrayList<Interceptor> beans, int[] indexList, InterceptionType type, Annotation... bindings) { List<Interceptor<?>> interceptors; if (bindings != null && bindings.length > 0) { interceptors = manager.resolveInterceptors(type, bindings); } else interceptors = new ArrayList<Interceptor<?>>(); int offset = 0; if (indexList == null) { indexList = new int[interceptors.size()]; } else { offset = indexList.length; int[] newIndexList = new int[indexList.length + interceptors.size()]; System.arraycopy(indexList, 0, newIndexList, 0, indexList.length); indexList = newIndexList; } for (int i = 0; i < interceptors.size(); i++) { Interceptor<?> interceptor = interceptors.get(i); int index = beans.indexOf(interceptor); if (index >= 0) indexList[offset + i] = index; else { indexList[offset + i] = beans.size(); beans.add(interceptor); } } return indexList; }
/** * Analyze class fields and fill in "voSetterMethods","voGetterMethods","indexes",reverseIndexes" * attributes. * * @param prefix e.g. "attrx.attry." * @param parentMethods getter methods of parent v.o. * @param classType class to analyze */ private void analyzeClassFields(String prefix, Method[] parentMethods, Class classType) { try { if (prefix.split("\\.").length > ClientSettings.MAX_NR_OF_LOOPS_IN_ANALYZE_VO) return; // retrieve all getter and setter methods defined in the specified value object... String attributeName = null; Method[] methods = classType.getMethods(); String aName = null; for (int i = 0; i < methods.length; i++) { attributeName = methods[i].getName(); if (attributeName.startsWith("get") && methods[i].getParameterTypes().length == 0 && ValueObject.class.isAssignableFrom(methods[i].getReturnType())) { aName = getAttributeName(attributeName, classType); Method[] newparentMethods = new Method[parentMethods.length + 1]; System.arraycopy(parentMethods, 0, newparentMethods, 0, parentMethods.length); newparentMethods[parentMethods.length] = methods[i]; analyzeClassFields(prefix + aName + ".", newparentMethods, methods[i].getReturnType()); } if (attributeName.startsWith("get") && methods[i].getParameterTypes().length == 0 && (methods[i].getReturnType().equals(String.class) || methods[i].getReturnType().equals(Long.class) || methods[i].getReturnType().equals(Long.TYPE) || methods[i].getReturnType().equals(Float.class) || methods[i].getReturnType().equals(Float.TYPE) || methods[i].getReturnType().equals(Short.class) || methods[i].getReturnType().equals(Short.TYPE) || methods[i].getReturnType().equals(Double.class) || methods[i].getReturnType().equals(Double.TYPE) || methods[i].getReturnType().equals(BigDecimal.class) || methods[i].getReturnType().equals(java.util.Date.class) || methods[i].getReturnType().equals(java.sql.Date.class) || methods[i].getReturnType().equals(java.sql.Timestamp.class) || methods[i].getReturnType().equals(Integer.class) || methods[i].getReturnType().equals(Integer.TYPE) || methods[i].getReturnType().equals(Character.class) || methods[i].getReturnType().equals(Boolean.class) || methods[i].getReturnType().equals(boolean.class) || methods[i].getReturnType().equals(ImageIcon.class) || methods[i].getReturnType().equals(Icon.class) || methods[i].getReturnType().equals(byte[].class) || methods[i].getReturnType().equals(Object.class) || ValueObject.class.isAssignableFrom(methods[i].getReturnType()))) { attributeName = getAttributeName(attributeName, classType); // try { // if // (classType.getMethod("set"+attributeName.substring(0,1).toUpperCase()+attributeName.substring(1),new Class[]{methods[i].getReturnType()})!=null) Method[] newparentMethods = new Method[parentMethods.length + 1]; System.arraycopy(parentMethods, 0, newparentMethods, 0, parentMethods.length); newparentMethods[parentMethods.length] = methods[i]; voGetterMethods.put(prefix + attributeName, newparentMethods); // } catch (NoSuchMethodException ex) { // } } else if (attributeName.startsWith("is") && methods[i].getParameterTypes().length == 0 && (methods[i].getReturnType().equals(Boolean.class) || methods[i].getReturnType().equals(boolean.class))) { attributeName = getAttributeName(attributeName, classType); Method[] newparentMethods = new Method[parentMethods.length + 1]; System.arraycopy(parentMethods, 0, newparentMethods, 0, parentMethods.length); newparentMethods[parentMethods.length] = methods[i]; voGetterMethods.put(prefix + attributeName, newparentMethods); } else if (attributeName.startsWith("set") && methods[i].getParameterTypes().length == 1) { attributeName = getAttributeName(attributeName, classType); try { if (classType.getMethod( "get" + attributeName.substring(0, 1).toUpperCase() + attributeName.substring(1), new Class[0]) != null) { Method[] newparentMethods = new Method[parentMethods.length + 1]; System.arraycopy(parentMethods, 0, newparentMethods, 0, parentMethods.length); newparentMethods[parentMethods.length] = methods[i]; voSetterMethods.put(prefix + attributeName, newparentMethods); } } catch (NoSuchMethodException ex) { try { if (classType.getMethod( "is" + attributeName.substring(0, 1).toUpperCase() + attributeName.substring(1), new Class[0]) != null) { Method[] newparentMethods = new Method[parentMethods.length + 1]; System.arraycopy(parentMethods, 0, newparentMethods, 0, parentMethods.length); newparentMethods[parentMethods.length] = methods[i]; voSetterMethods.put(prefix + attributeName, newparentMethods); } } catch (NoSuchMethodException exx) { } } } } // fill in indexes with the colProperties indexes first; after them, it will be added the // other indexes (of attributes not mapped with grid column...) HashSet alreadyAdded = new HashSet(); int i = 0; for (i = 0; i < colProperties.length; i++) { indexes.put(new Integer(i), colProperties[i].getColumnName()); reverseIndexes.put(colProperties[i].getColumnName(), new Integer(i)); alreadyAdded.add(colProperties[i].getColumnName()); } Enumeration en = voGetterMethods.keys(); while (en.hasMoreElements()) { attributeName = en.nextElement().toString(); if (!alreadyAdded.contains(attributeName)) { indexes.put(new Integer(i), attributeName); reverseIndexes.put(attributeName, new Integer(i)); i++; } } } catch (Exception ex) { ex.printStackTrace(); } }
/** * On a Type Variable (typeVar extends C_0 & I_1 & I_2 & etc), will return an array containing * I_1 and I_2. * * @return other bounds for this type, these bounds can only be only interfaces as the JLS says, * empty array if no other bound declared. */ public Type[] interfaceBounds() { Type[] interfaceBounds = new Type[typeVariable.getBounds().length - 1]; System.arraycopy( typeVariable.getBounds(), 1, interfaceBounds, 0, typeVariable.getBounds().length - 1); return interfaceBounds; }
static Object js_createAdapter(Context cx, Scriptable scope, Object[] args) { int N = args.length; if (N == 0) { throw ScriptRuntime.typeError0("msg.adapter.zero.args"); } // Expected arguments: // Any number of NativeJavaClass objects representing the super-class // and/or interfaces to implement, followed by one NativeObject providing // the implementation, followed by any number of arguments to pass on // to the (super-class) constructor. int classCount; for (classCount = 0; classCount < N - 1; classCount++) { Object arg = args[classCount]; // We explicitly test for NativeObject here since checking for // instanceof ScriptableObject or !(instanceof NativeJavaClass) // would fail for a Java class that isn't found in the class path // as NativeJavaPackage extends ScriptableObject. if (arg instanceof NativeObject) { break; } if (!(arg instanceof NativeJavaClass)) { throw ScriptRuntime.typeError2( "msg.not.java.class.arg", String.valueOf(classCount), ScriptRuntime.toString(arg)); } } Class<?> superClass = null; Class<?>[] intfs = new Class[classCount]; int interfaceCount = 0; for (int i = 0; i < classCount; ++i) { Class<?> c = ((NativeJavaClass) args[i]).getClassObject(); if (!c.isInterface()) { if (superClass != null) { throw ScriptRuntime.typeError2("msg.only.one.super", superClass.getName(), c.getName()); } superClass = c; } else { intfs[interfaceCount++] = c; } } if (superClass == null) { superClass = ScriptRuntime.ObjectClass; } Class<?>[] interfaces = new Class[interfaceCount]; System.arraycopy(intfs, 0, interfaces, 0, interfaceCount); // next argument is implementation, must be scriptable Scriptable obj = ScriptableObject.ensureScriptable(args[classCount]); Class<?> adapterClass = getAdapterClass(scope, superClass, interfaces, obj); Object adapter; int argsCount = N - classCount - 1; try { if (argsCount > 0) { // Arguments contain parameters for super-class constructor. // We use the generic Java method lookup logic to find and // invoke the right constructor. Object[] ctorArgs = new Object[argsCount + 2]; ctorArgs[0] = obj; ctorArgs[1] = cx.getFactory(); System.arraycopy(args, classCount + 1, ctorArgs, 2, argsCount); // TODO: cache class wrapper? NativeJavaClass classWrapper = new NativeJavaClass(scope, adapterClass, true); NativeJavaMethod ctors = classWrapper.members.ctors; int index = ctors.findCachedFunction(cx, ctorArgs); if (index < 0) { String sig = NativeJavaMethod.scriptSignature(args); throw Context.reportRuntimeError2("msg.no.java.ctor", adapterClass.getName(), sig); } // Found the constructor, so try invoking it. adapter = NativeJavaClass.constructInternal(ctorArgs, ctors.methods[index]); } else { Class<?>[] ctorParms = {ScriptRuntime.ScriptableClass, ScriptRuntime.ContextFactoryClass}; Object[] ctorArgs = {obj, cx.getFactory()}; adapter = adapterClass.getConstructor(ctorParms).newInstance(ctorArgs); } Object self = getAdapterSelf(adapterClass, adapter); // Return unwrapped JavaAdapter if it implements Scriptable if (self instanceof Wrapper) { Object unwrapped = ((Wrapper) self).unwrap(); if (unwrapped instanceof Scriptable) { if (unwrapped instanceof ScriptableObject) { ScriptRuntime.setObjectProtoAndParent((ScriptableObject) unwrapped, scope); } return unwrapped; } } return self; } catch (Exception ex) { throw Context.throwAsScriptRuntimeEx(ex); } }