for (int i = 0; i < ma.allgetters.length; ++i) { SAXAccessMethod sam = ma.allgetters[i]; if (!sam.canGet() || !sam.canSet()) continue; if (exceptions != null && ArrayUtil.contains(exceptions, sam.tagname)) if (sam.isexactsetter) { Enumeration childenum = EnumerationConverter.getEnumeration(sam .getChildObject(source)); while (childenum.hasMoreElements()) { Object child = childenum.nextElement(); Object clonechild = cloneBean(child, null, false); sam.setChildObject(target, clonechild); Object child = sam.getChildObject(source); if (child != null) { Object clonechild = cloneBean(child, null, false); sam.setChildObject(target, clonechild);
private void appendDeclaredFields(CharWrap cw, Class clazz) { MethodAnalyser methodAnalyser = mappingcontext.getAnalyser(clazz); // Append all "legitimate" public read/write fields declared in this class // to the parseSpec. for (int i = 0; i < methodAnalyser.allgetters.length; ++i) { SAXAccessMethod method = methodAnalyser.allgetters[i]; if (method.canGet() && method.canSet() && mappingcontext.generalLeafParser.isLeafType(method.getAccessedType()) && method.getDeclaringClass() == methodAnalyser.targetclass && !method.tagname.equals("anchorField")) { cw.append("," + method.tagname); } } }
public ConcreteChildIterator(UIComponent parent, SAXalizerMappingContext mappingcontext) { MethodAnalyser ma = mappingcontext.getAnalyser(parent.getClass()); for (int i = 0; i < ma.allgetters.length; ++ i) { SAXAccessMethod sam = ma.allgetters[i]; if (sam.tagname.equals("parent")) continue; if (UIComponent.class.isAssignableFrom(sam.getDeclaredType())) { Object child = sam.getChildObject(parent); if (child != null) { children.put(sam.tagname, child); } } else if (sam.getDeclaredType() == Object.class) { Object child = sam.getChildObject(parent); if (child instanceof UIComponent) { children.put(sam.tagname, child); } } } }
/** * Takes a path ending with a greedy expression (probably .*) and appends the * "leaves" (fields) based on passed in arguments */ private void appendLeaves(Class rootclass, String pathroot, String attrprefix, StringList attnames, StringList paths) { String[] components = PathUtil.splitPath(pathroot); Class moveclass = rootclass; for (int i = 0; i < components.length; ++i) { MethodAnalyser ma = mappingcontext.getAnalyser(moveclass); String component = components[i]; AccessMethod method = ma.getAccessMethod(component); if (method == null || !(method.canGet() && method.canSet())) { throw new IllegalArgumentException( "Unable to find writeable property for path component " + component + " at " + moveclass); } moveclass = method.getAccessedType(); } MethodAnalyser ma = mappingcontext.getAnalyser(moveclass); for (int i = 0; i < ma.allgetters.length; ++i) { SAXAccessMethod method = ma.allgetters[i]; if (method.canGet() && method.canSet() && mappingcontext.generalLeafParser.isLeafType(method.getAccessedType())) { paths.add(PathUtil.composePathEncoded(pathroot, method.tagname)); attnames.add(attrprefix + method.tagname); } } }
checkEnumerable(accessclazz); if (!checkEnumerable(accessclazz) && m.clazz != null && !m.clazz.isAssignableFrom(accessclazz)) { throw new AssertionException("Actual return type of get method \"" setmethod = findSetMethod(parentclazz, m.setmethodname); if (setmethod == null) { throw new UniversalRuntimeException( setmethod = findSetMethod(parentclazz, m.setmethodname); Class setaccessclazz = setmethod.getParameterTypes()[0]; boolean setismultiple = EnumerationConverter.isDenumerable(setaccessclazz); if (!canGet()) { throw new UniversalRuntimeException( "No GET scheme supplied for mapped default tag");
Object newchild = leafparser.parse(setattrmethod.clazz, attrvalue); setattrmethod.setChildObject(obj, newchild); // invoke iiiiiit! if (takesextras) expended[i] = true; .getChildObject(obj)); defaultmap.put(attrname, newchild);
if (am != null && am.canGet() && !am.isenumonly && (am.ismultiple || !leafparser.isLeafType(am.clazz)) && !am.isexactsetter) { oldobj = am.getChildObject(beingparsed.object); if (oldobj != null) { if (am != null && am.ismappable) { newcontext.mapkey = attrlist.getValue(Constants.KEY_ATTRIBUTE_NAME); newcontext.objectpeer = am.getChildObject(beingparsed.object);
if (parentsetter != null && parentsetter.isDenumerable() && parentsetter.accessclazz != parentsetter.clazz) { isdenumerable = true; parentsetter.setChildObject(beingparsed.object, oldinstance);
writeObject(sam.getPropertyName()); writer.writeRaw(": "); writeObject(sam.getChildObject(towrite));
private void renderAttrs(Object torender, SAMIterator getattrenum) { for (; getattrenum.valid(); getattrenum.next()) { SAXAccessMethod getattr = getattrenum.get(); Object attrvalue = getattr.getChildObject(torender); Logger.println("Attr " + getattr.tagname + ": returned object " + attrvalue, Logger.DEBUG_SUBATOMIC); if (attrvalue != null) { appendAttr(getattr.tagname, attrvalue); } } // now find and write any extra attributes if (torender instanceof SAXalizableExtraAttrs) { Map extraattrs = ((SAXalizableExtraAttrs) torender).getAttributes(); if (extraattrs != null) { Iterator attrs = extraattrs.keySet().iterator(); while (attrs.hasNext()) { String attributename = (String) attrs.next(); String attributevalue = (String) extraattrs.get(attributename); appendAttr(attributename, attributevalue); } } } }
private void stepAlong() { while (++currentindex < methods.length) { if (methods[currentindex].canGet()) break; //if (methodtype == SAXAccessMethodSpec.SET_METHOD && methods[currentindex].setmethod != null) break; } } public boolean valid() {
bodymethod.setChildObject(beingparsed.object, newchild);
public SAXAccessMethodHash(SAMSList samslist, Class parentclass) { methods = new SAXAccessMethod[samslist.size()]; for (int i = 0; i < samslist.size(); ++i) { this.methods[i] = new SAXAccessMethod(samslist.SAMSAt(i), parentclass); } } /** An iterator for all gettable methods */
child = topgetmethod.getChildObject(top.object);
attrmethods = new SAXAccessMethodHash(attrMethods, objclass); if (bodymethodspec != null) { bodymethod = new SAXAccessMethod(bodymethodspec, objclass);
for (int i = 0; i < ma.allgetters.length; ++i) { SAXAccessMethod sam = ma.allgetters[i]; if (!sam.canGet() || !sam.canSet()) continue; if (sam.tagname.equals("parent")) { Object child = sam.getChildObject(toclone); Object clonechild = null; sam.setChildObject(cloned, clonechild);
public static void rewriteEntityIDs(Object target, SAXalizerMappingContext smc, EntityIDRewriter idprocessor) { MethodAnalyser ma = smc.getAnalyser(target.getClass()); for (int i = 0; i < ma.allgetters.length; ++i) { SAXAccessMethod getter = ma.allgetters[i]; if (EntityID.class.isAssignableFrom(getter.getDeclaredType())) { EntityID entityid = (EntityID) getter.getChildObject(target); idprocessor.postCommit(entityid); } } } }