private void popStack(String tagName) { Pair<Integer, String> node = _nodeStack.removeLast(); int preOrder = node.getFirst(); int postOrder = _postOrder++; // output node info out.println(preOrder + "\t" + postOrder + "\t" + tagName + "\t" + (node.getSecond() != null ? node.getSecond().trim() : "")); }
public static <X, Y> Pair<X, Y> newPair(X x, Y y) { return new Pair<X, Y>(x, y); }
public static RelationSetter newMapSetter(String keyNodeName, String valueNodeName, Field mapField) { Pair<Class< ? >, Class< ? >> mapElementType = ReflectionUtil .getGenericMapElementClasses(mapField); return new MapFieldSetter(mapElementType.getFirst(), keyNodeName, mapElementType .getSecond(), valueNodeName, mapField); }
private void pushStack() { _startOrderStack.addLast(new Pair<Integer, String>(_startOrder, EMPTY_STRING)); _startOrder += STARTORDER_INCREMENT; _currentDepth++; }
@Override public void text(XmlPullParser parser) throws XMLException { Pair<Integer, String> currentNode = _startOrderStack.removeLast(); String text = parser.getText(); _startOrderStack.addLast(new Pair<Integer, String>(currentNode.getFirst(), currentNode .getSecond() == null ? text : currentNode.getSecond() + text)); }
private void popStack(XmlPullParser parser) { int endOrder = _startOrder + MINIMUM_INTERAVAL; Pair<Integer, String> currentNode = _startOrderStack.removeLast(); // output node data _writer.write(new LWIndex(currentNode.getFirst(), endOrder, _currentDepth), parser .getName(), currentNode.getSecond()); _startOrder = endOrder + STARTORDER_INCREMENT; _currentDepth--; }
private void pushStack() { _nodeStack.add(new Pair<Integer, String>(_preOrder++, EMPTY_STR)); }
.getGenericMapElementClasses(eachField); Class< ? > keyType = mapElementType.getFirst(); Class< ? > valueType = mapElementType.getSecond(); keyValueName = new Pair<String, String>(keyType.getSimpleName(), valueType.getSimpleName()); else if (keyValueName.getFirst().equals("") && keyValueName.getSecond().equals("")) { keyValueName.getFirst(), keyValueName.getSecond(), eachField)); relName = new Pair<String, String>( getCanonicalParameterName(argTypes[0].getSimpleName()), getCanonicalParameterName(argTypes[1].getSimpleName())); relName.getFirst(), relName.getSecond(), eachMethod)); break; relationSetterContainer.add(RelationSetter.newRelationSetter(relName.getFirst(), relName.getSecond(), eachMethod));
@SuppressWarnings("unchecked") public static void setMapEntry(Object bean, Field field, Object key, Object value) throws XerialException { ReflectionUtil.initializeCollectionField(bean, field); Object mapObj = ReflectionUtil.getFieldValue(bean, field); if (mapObj == null) throw new XerialException(XerialErrorCode.INVALID_STATE, "cannot set (key, value) to null Map field: " + bean); Pair<Class< ? >, Class< ? >> mapElementType = ReflectionUtil .getGenericMapElementClasses(field); Class< ? > keyType = mapElementType.getFirst(); Class< ? > valueType = mapElementType.getSecond(); Map map = Map.class.cast(mapObj); map.put(TypeConverter.convertType(keyType, key), TypeConverter .convertType(valueType, value)); }
static Pair<String, String> pickRelationName(String pairedName) { Matcher m = null; m = pairedNamePattern.matcher(pairedName); if (!m.matches()) return null; else return new Pair<String, String>(getCanonicalParameterName(m.group(1)), getCanonicalParameterName(m.group(2))); }
public static Pair<Type, Type> getGenericMapElementTypes(Field field) { if (!TypeInfo.isMap(field.getType())) throw new XerialError(XerialErrorCode.INVALID_INPUT, "not a map type: " + field); Type fieldType = field.getGenericType(); if (ParameterizedType.class.isInstance(fieldType)) { ParameterizedType pt = ParameterizedType.class.cast(fieldType); Type[] keyValueType = pt.getActualTypeArguments(); // TODO look up parent classes? if (keyValueType.length != 2) throw new XerialError(XerialErrorCode.INVALID_STATE, "not a Map<Key, Value> type: " + field); return new Pair<Type, Type>(keyValueType[0], keyValueType[1]); } return new Pair<Type, Type>(Object.class, Object.class); }
public static Pair<Class< ? >, Class< ? >> getGenericMapTypesOfMethodArgument(Method method, int argIndex) { ParameterizedType genericSetterArgumentType = getParentParameterizedType( method.getGenericParameterTypes()[argIndex], Map.class); if (genericSetterArgumentType != null) { Type[] actualTypeList = genericSetterArgumentType.getActualTypeArguments(); if (actualTypeList.length >= 2) { Class< ? > keyType = resolveRawType(actualTypeList[0]); Class< ? > valueType = resolveRawType(actualTypeList[1]); return new Pair<Class< ? >, Class< ? >>(keyType, valueType); } } return null; }