private Object ApplyGetters(Object target, String getters) { if (getters == null || getters.Equals("")) { return(target); } int firstDot = getters.IndexOf('.'); if (firstDot == -1) { firstDot = getters.Length(); } String first = getters.Substring(0, firstDot); String rest = getters.Substring(System.Math.Min(firstDot + 1, getters.Length())); try { Method getter = null; if (target != null) { getter = Statement.GetMethod(target.GetType(), "get" + NameGenerator.Capitalize(first), new Class[] {}); if (getter == null) { getter = Statement.GetMethod(target.GetType(), "is" + NameGenerator.Capitalize(first), new Class[] {}); } if (getter == null) { getter = Statement.GetMethod(target.GetType(), first, new Class[] {}); } } if (getter == null) { throw new RuntimeException("No method called: " + first + " defined on " + target); } Object newTarget = MethodUtil.invoke(getter, target, new Object[] {}); return(ApplyGetters(newTarget, rest)); } catch (Exception e) { throw new RuntimeException("Failed to call method: " + first + " on " + target, e); } }
/// <summary> /// This default implementation of the <code>instantiate</code> method returns /// an expression containing the predefined method name "new" which denotes a /// call to a constructor with the arguments as specified in /// the <code>DefaultPersistenceDelegate</code>'s constructor. /// </summary> /// <param name="oldInstance"> The instance to be instantiated. </param> /// <param name="out"> The code output stream. </param> /// <returns> An expression whose value is <code>oldInstance</code>. /// </returns> /// <exception cref="NullPointerException"> if {@code out} is {@code null} /// and this value is used in the method /// </exception> /// <seealso cref= #DefaultPersistenceDelegate(String[]) </seealso> protected internal override Expression Instantiate(Object oldInstance, Encoder @out) { int nArgs = Constructor.Length; Class type = oldInstance.GetType(); Object[] constructorArgs = new Object[nArgs]; for (int i = 0; i < nArgs; i++) { try { Method method = FindMethod(type, this.Constructor[i]); constructorArgs[i] = MethodUtil.invoke(method, oldInstance, new Object[0]); } catch (Exception e) { @out.ExceptionListener.ExceptionThrown(e); } } return(new Expression(oldInstance, oldInstance.GetType(), "new", constructorArgs)); }
private Object InvokeInternal(Object proxy, Method method, Object[] arguments) { String methodName = method.Name; if (method.DeclaringClass == typeof(Object)) { // Handle the Object public methods. if (methodName.Equals("hashCode")) { return(new Integer(System.identityHashCode(proxy))); } else if (methodName.Equals("equals")) { return(proxy == arguments[0] ? true : false); } else if (methodName.Equals("toString")) { //JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method: return(proxy.GetType().FullName + '@' + proxy.HashCode().ToString("x")); } } if (ListenerMethodName_Renamed == null || ListenerMethodName_Renamed.Equals(methodName)) { Class[] argTypes = null; Object[] newArgs = null; if (EventPropertyName_Renamed == null) // Nullary method. { newArgs = new Object[] {}; argTypes = new Class[] {}; } else { Object input = ApplyGetters(arguments[0], EventPropertyName); newArgs = new Object[] { input }; argTypes = new Class[] { input == null ? null : input.GetType() }; } try { int lastDot = Action_Renamed.LastIndexOf('.'); if (lastDot != -1) { Target_Renamed = ApplyGetters(Target_Renamed, Action_Renamed.Substring(0, lastDot)); Action_Renamed = Action_Renamed.Substring(lastDot + 1); } Method targetMethod = Statement.GetMethod(Target_Renamed.GetType(), Action_Renamed, argTypes); if (targetMethod == null) { targetMethod = Statement.GetMethod(Target_Renamed.GetType(), "set" + NameGenerator.Capitalize(Action_Renamed), argTypes); } if (targetMethod == null) { String argTypeString = (argTypes.Length == 0) ? " with no arguments" : " with argument " + argTypes[0]; throw new RuntimeException("No method called " + Action_Renamed + " on " + Target_Renamed.GetType() + argTypeString); } return(MethodUtil.invoke(targetMethod, Target_Renamed, newArgs)); } catch (IllegalAccessException ex) { throw new RuntimeException(ex); } catch (InvocationTargetException ex) { Throwable th = ex.TargetException; throw (th is RuntimeException) ? (RuntimeException)th : new RuntimeException(th); } } return(null); }
// Write out the properties of this instance. private void InitBean(Class type, Object oldInstance, Object newInstance, Encoder @out) { foreach (Field field in type.Fields) { if (!ReflectUtil.isPackageAccessible(field.DeclaringClass)) { continue; } int mod = field.Modifiers; if (Modifier.IsFinal(mod) || Modifier.IsStatic(mod) || Modifier.IsTransient(mod)) { continue; } try { Expression oldGetExp = new Expression(field, "get", new Object[] { oldInstance }); Expression newGetExp = new Expression(field, "get", new Object[] { newInstance }); Object oldValue = oldGetExp.Value; Object newValue = newGetExp.Value; @out.WriteExpression(oldGetExp); if (!Objects.Equals(newValue, @out.Get(oldValue))) { @out.WriteStatement(new Statement(field, "set", new Object[] { oldInstance, oldValue })); } } catch (Exception exception) { @out.ExceptionListener.ExceptionThrown(exception); } } BeanInfo info; try { info = Introspector.GetBeanInfo(type); } catch (IntrospectionException) { return; } // Properties foreach (PropertyDescriptor d in info.PropertyDescriptors) { if (d.IsTransient()) { continue; } try { DoProperty(type, d, oldInstance, newInstance, @out); } catch (Exception e) { @out.ExceptionListener.ExceptionThrown(e); } } // Listeners /* * Pending(milne). There is a general problem with the archival of * listeners which is unresolved as of 1.4. Many of the methods * which install one object inside another (typically "add" methods * or setters) automatically install a listener on the "child" object * so that its "parent" may respond to changes that are made to it. * For example the JTable:setModel() method automatically adds a * TableModelListener (the JTable itself in this case) to the supplied * table model. * * We do not need to explicitly add these listeners to the model in an * archive as they will be added automatically by, in the above case, * the JTable's "setModel" method. In some cases, we must specifically * avoid trying to do this since the listener may be an inner class * that cannot be instantiated using public API. * * No general mechanism currently * exists for differentiating between these kind of listeners and * those which were added explicitly by the user. A mechanism must * be created to provide a general means to differentiate these * special cases so as to provide reliable persistence of listeners * for the general case. */ if (!type.IsSubclassOf(typeof(java.awt.Component))) { return; // Just handle the listeners of Components for now. } foreach (EventSetDescriptor d in info.EventSetDescriptors) { if (d.IsTransient()) { continue; } Class listenerType = d.ListenerType; // The ComponentListener is added automatically, when // Contatiner:add is called on the parent. if (listenerType == typeof([email protected])) { continue; } // JMenuItems have a change listener added to them in // their "add" methods to enable accessibility support - // see the add method in JMenuItem for details. We cannot // instantiate this instance as it is a private inner class // and do not need to do this anyway since it will be created // and installed by the "add" method. Special case this for now, // ignoring all change listeners on JMenuItems. if (listenerType == typeof([email protected]) && type == typeof(javax.swing.JMenuItem)) { continue; } EventListener[] oldL = new EventListener[0]; EventListener[] newL = new EventListener[0]; try { Method m = d.GetListenerMethod; oldL = (EventListener[])MethodUtil.invoke(m, oldInstance, new Object[] {}); newL = (EventListener[])MethodUtil.invoke(m, newInstance, new Object[] {}); } catch (Exception) { try { Method m = type.GetMethod("getListeners", new Class[] { typeof(Class) }); oldL = (EventListener[])MethodUtil.invoke(m, oldInstance, new Object[] { listenerType }); newL = (EventListener[])MethodUtil.invoke(m, newInstance, new Object[] { listenerType }); } catch (Exception) { return; } } // Asssume the listeners are in the same order and that there are no gaps. // Eventually, this may need to do true differencing. String addListenerMethodName = d.AddListenerMethod.Name; for (int i = newL.Length; i < oldL.Length; i++) { // System.out.println("Adding listener: " + addListenerMethodName + oldL[i]); InvokeStatement(oldInstance, addListenerMethodName, new Object[] { oldL[i] }, @out); } String removeListenerMethodName = d.RemoveListenerMethod.Name; for (int i = oldL.Length; i < newL.Length; i++) { InvokeStatement(oldInstance, removeListenerMethodName, new Object[] { newL[i] }, @out); } } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private Object invokeInternal() throws Exception private Object InvokeInternal() { Object target = Target; String methodName = MethodName; if (target == null || methodName == null) { throw new NullPointerException((target == null ? "target" : "methodName") + " should not be null"); } Object[] arguments = Arguments; if (arguments == null) { arguments = EmptyArray; } // Class.forName() won't load classes outside // of core from a class inside core. Special // case this method. if (target == typeof(Class) && methodName.Equals("forName")) { return(ClassFinder.resolveClass((String)arguments[0], this.Loader)); } Class[] argClasses = new Class[arguments.Length]; for (int i = 0; i < arguments.Length; i++) { argClasses[i] = (arguments[i] == null) ? null : arguments[i].GetType(); } AccessibleObject m = null; if (target is Class) { /* * For class methods, simluate the effect of a meta class * by taking the union of the static methods of the * actual class, with the instance methods of "Class.class" * and the overloaded "newInstance" methods defined by the * constructors. * This way "System.class", for example, will perform both * the static method getProperties() and the instance method * getSuperclass() defined in "Class.class". */ if (methodName.Equals("new")) { methodName = "newInstance"; } // Provide a short form for array instantiation by faking an nary-constructor. if (methodName.Equals("newInstance") && ((Class)target).Array) { Object result = Array.newInstance(((Class)target).ComponentType, arguments.Length); for (int i = 0; i < arguments.Length; i++) { Array.set(result, i, arguments[i]); } return(result); } if (methodName.Equals("newInstance") && arguments.Length != 0) { // The Character class, as of 1.4, does not have a constructor // which takes a String. All of the other "wrapper" classes // for Java's primitive types have a String constructor so we // fake such a constructor here so that this special case can be // ignored elsewhere. if (target == typeof(Character) && arguments.Length == 1 && argClasses[0] == typeof(String)) { return(new Character(((String)arguments[0]).CharAt(0))); } try { m = ConstructorFinder.findConstructor((Class)target, argClasses); } catch (NoSuchMethodException) { m = null; } } if (m == null && target != typeof(Class)) { m = GetMethod((Class)target, methodName, argClasses); } if (m == null) { m = GetMethod(typeof(Class), methodName, argClasses); } } else { /* * This special casing of arrays is not necessary, but makes files * involving arrays much shorter and simplifies the archiving infrastrcure. * The Array.set() method introduces an unusual idea - that of a static method * changing the state of an instance. Normally statements with side * effects on objects are instance methods of the objects themselves * and we reinstate this rule (perhaps temporarily) by special-casing arrays. */ if (target.GetType().IsArray&& (methodName.Equals("set") || methodName.Equals("get"))) { int index = ((Integer)arguments[0]).IntValue(); if (methodName.Equals("get")) { return(Array.get(target, index)); } else { Array.set(target, index, arguments[1]); return(null); } } m = GetMethod(target.GetType(), methodName, argClasses); } if (m != null) { try { if (m is Method) { return(MethodUtil.invoke((Method)m, target, arguments)); } else { return(((Constructor)m).newInstance(arguments)); } } catch (IllegalAccessException iae) { throw new Exception("Statement cannot invoke: " + methodName + " on " + target.GetType(), iae); } catch (InvocationTargetException ite) { Throwable te = ite.TargetException; if (te is Exception) { throw (Exception)te; } else { throw ite; } } } throw new NoSuchMethodException(ToString()); }