Java HierarchicalStreamReader.hasMoreChildren方法代码示例

import com.thoughtworks.xstream.io.HierarchicalStreamReader; //导入方法依赖的package包/类
public void recurseUnmarshal(Object object, HierarchicalStreamReader reader, UnmarshallingContext context,
	String path, XMLDataMappings mappings)
{
	Collection<AbstractMapping> col = getMapping(mappings.getMappings(), path);
	for( AbstractMapping nodeMap : col )
	{
		nodeMap.unmarshal(reader, context, object);
		if( nodeMap instanceof ElementMapping )
		{
			return;
		}
	}

	for( ; reader.hasMoreChildren(); reader.moveUp() )
	{
		reader.moveDown();
		String thispath = path + SLASH + processNodeName(mappings, reader.getNodeName());
		recurseUnmarshal(object, reader, context, thispath, mappings);
	}

}
 

import com.thoughtworks.xstream.io.HierarchicalStreamReader; //导入方法依赖的package包/类
@SuppressWarnings("nls")
@Override
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context)
{
	MetadataFormat format = new MetadataFormat();
	for( ; reader.hasMoreChildren(); reader.moveUp() )
	{
		reader.moveDown();
		String name = reader.getNodeName();
		String value = reader.getValue();
		if( name.equals("oai:metadataPrefix") || name.equals("metadataPrefix") )
		{
			format.setMetadataPrefix(value);
		}
		else if( name.equals("oai:schema") || name.equals("schema") )
		{
			format.setSchema(value);
		}
		else if( name.equals("oai:metadataNamespace") || name.equals("metadataNamespace") )
		{
			format.setMetadataNamespace(value);
		}
	}

	return format;
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamReader; //导入方法依赖的package包/类
/**
 * The unmarshal method reads through a Definition to parse the ID and the
 * Name of a Definition. The ID and name of a definition are set and the
 * type of the Definition is set using the suffix of the ID/ Name.
 */
@Override
public Object unmarshal(final HierarchicalStreamReader reader, final UnmarshallingContext context) {
	final Definition definition = new Definition();
	String id = null, name = null;
	while (reader.hasMoreChildren()) {
		reader.moveDown();
		final String nodeName = reader.getNodeName();
		String value = reader.getValue();
		value = value == null ? "" : value;
		if (nodeName.equalsIgnoreCase("ID")) {
			id = reader.getValue();
		} else if (nodeName.equalsIgnoreCase("NAME")) {
			name = reader.getValue();
		}
		definition.setId(id != null && !id.isEmpty() ? id : name);
		reader.moveUp();
	}

	definition.setType(DefinitionType.getDefinitionType(definition.getId()));
	return definition;
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamReader; //导入方法依赖的package包/类
protected Comparator<?> unmarshalComparator(final HierarchicalStreamReader reader,
        final UnmarshallingContext context, final TreeMap<?, ?> result) {
    final Comparator<?> comparator;
    if (reader.hasMoreChildren()) {
        reader.moveDown();
        if (reader.getNodeName().equals("comparator")) {
            final Class<?> comparatorClass = HierarchicalStreams.readClassType(reader, mapper());
            comparator = (Comparator<?>)context.convertAnother(result, comparatorClass);
        } else if (reader.getNodeName().equals("no-comparator")) { // pre 1.4 format
            comparator = null;
        } else {
            // we are already within the first entry
            return NULL_MARKER;
        }
        reader.moveUp();
    } else {
        comparator = null;
    }
    return comparator;
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamReader; //导入方法依赖的package包/类
@Override
public Object unmarshal(final HierarchicalStreamReader reader, final UnmarshallingContext context) {
    String methodName = null;
    String declaringClassName = null;

    while ((methodName == null || declaringClassName == null) && reader.hasMoreChildren()) {
        reader.moveDown();

        if (reader.getNodeName().equals("name")) {
            methodName = reader.getValue();
        } else if (reader.getNodeName().equals("clazz")) {
            declaringClassName = reader.getValue();
        }
        reader.moveUp();
    }

    final Class<?> declaringClass = (Class<?>)javaClassConverter.fromString(declaringClassName);
    try {
        return declaringClass.getDeclaredField(mapper.realMember(declaringClass, methodName));
    } catch (final NoSuchFieldException e) {
        throw new ConversionException(e);
    }
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamReader; //导入方法依赖的package包/类
@Override
public Object unmarshal(final HierarchicalStreamReader reader, final UnmarshallingContext context) {
    final List<Object> list = new ArrayList<Object>();
    while (reader.hasMoreChildren()) {
        reader.moveDown();
        final Object item;
        final String className = HierarchicalStreams.readClassAttribute(reader, mapper);
        final Class<?> itemType = className == null ? arrayType.getComponentType() : mapper.realClass(className);
        if (Mapper.Null.class.equals(itemType)) {
            item = null;
        } else {
            item = context.convertAnother(null, itemType);
        }
        list.add(item);
        reader.moveUp();
    }
    final Object array = Array.newInstance(arrayType.getComponentType(), list.size());
    for (int i = 0; i < list.size(); ++i) {
        Array.set(array, i, list.get(i));
    }
    return array;
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamReader; //导入方法依赖的package包/类
private void unmarshallElement(HierarchicalStreamReader reader, Branch branch) {
	Element element = branch.addElement(reader.getNodeName());
	for (int i=0; i<reader.getAttributeCount(); i++) {
		String attributeName = reader.getAttributeName(i);
		String attributeValue = reader.getAttribute(i);
		element.addAttribute(attributeName, attributeValue);
	}
	if (StringUtils.isNotBlank(reader.getValue()))
		element.setText(reader.getValue().trim());
	while (reader.hasMoreChildren()) {
		reader.moveDown();
		unmarshallElement(reader, element);
		reader.moveUp();
	}
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamReader; //导入方法依赖的package包/类
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
    Map<String, String> map = new HashMap<>();
    while(reader.hasMoreChildren()) {
        reader.moveDown();

        String key = reader.getNodeName(); // nodeName aka element's name
        String value = reader.getValue();
        map.put(key, value);

        reader.moveUp();
    }

    return map;
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamReader; //导入方法依赖的package包/类
private Element parseSubTree2(HierarchicalStreamReader reader, Document doc)
{
	String qname = reader.getNodeName();
	Element parent = doc.createElement(qname);

	Iterator i = reader.getAttributeNames();
	while( i.hasNext() )
	{
		String aname = i.next().toString();
		String value = reader.getAttribute(aname);
		parent.setAttribute(aname, value);
	}

	String text = reader.getValue();
	if( text.trim().length() != 0 )
	{
		Text textEl = doc.createTextNode(text);
		parent.appendChild(textEl);
	}

	for( ; reader.hasMoreChildren(); reader.moveUp() )
	{
		reader.moveDown();
		Element child = parseSubTree2(reader, doc);
		parent.appendChild(child);
	}

	return parent;
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamReader; //导入方法依赖的package包/类
/**
 * Method is used unmarshal XML of any type of component which contains a
 * List<String> where the string elements would appear within <ID> tags.
 * E.g. the List<String> of inputRoutes and outputRoutes in
 * CommunicationPoint.
 *
 * @return a List<String> of all IDs.
 */
@Override
public Object unmarshal(final HierarchicalStreamReader reader, final UnmarshallingContext context) {
	final List<String> IdList = new ArrayList<String>();
	while (reader.hasMoreChildren()) {
		reader.moveDown();
		final String nodeName = reader.getNodeName();
		final String value = reader.getValue();
		if (nodeName.equalsIgnoreCase("ID")) {
			IdList.add(value);
		}
		reader.moveUp();
	}
	return IdList;
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamReader; //导入方法依赖的package包/类
@Override
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context)
{
	Set set = new Set();
	for( ; reader.hasMoreChildren(); reader.moveUp() )
	{
		reader.moveDown();
		String name = reader.getNodeName();
		String value = reader.getValue();
		if( name.equals("setSpec") )
		{
			set.setSpec(value);
		}
		else if( name.equals("setName") )
		{
			set.setName(value);
		}
		else if( name.equals("setDescription") )
		{
			reader.moveDown();
			Object object = new OAIDOMConverter().unmarshal(reader, context);
			set.setDescription(object);
			reader.moveUp();
		}
	}

	return set;
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamReader; //导入方法依赖的package包/类
@Override
public Object unmarshal(final HierarchicalStreamReader reader, final UnmarshallingContext context) {
    try {
        final boolean isMethodNotConstructor = context.getRequiredType().equals(Method.class);

        reader.moveDown();
        final String declaringClassName = reader.getValue();
        final Class<?> declaringClass = (Class<?>)javaClassConverter.fromString(declaringClassName);
        reader.moveUp();

        String methodName = null;
        if (isMethodNotConstructor) {
            reader.moveDown();
            methodName = reader.getValue();
            reader.moveUp();
        }

        reader.moveDown();
        final List<Class<?>> parameterTypeList = new ArrayList<Class<?>>();
        while (reader.hasMoreChildren()) {
            reader.moveDown();
            final String parameterTypeName = reader.getValue();
            parameterTypeList.add((Class<?>)javaClassConverter.fromString(parameterTypeName));
            reader.moveUp();
        }
        final Class<?>[] parameterTypes = parameterTypeList.toArray(new Class[parameterTypeList.size()]);
        reader.moveUp();

        if (isMethodNotConstructor) {
            return declaringClass.getDeclaredMethod(methodName, parameterTypes);
        } else {
            return declaringClass.getDeclaredConstructor(parameterTypes);
        }
    } catch (final NoSuchMethodException e) {
        throw new ConversionException(e);
    }
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamReader; //导入方法依赖的package包/类
@Override
public Object unmarshal(final HierarchicalStreamReader reader, final UnmarshallingContext context) {
    final String data = reader.getValue(); // needs to be called before hasMoreChildren.
    if (!reader.hasMoreChildren()) {
        return fromString(data);
    } else {
        // backwards compatibility ... try to unmarshal byte arrays that haven't been encoded
        return unmarshalIndividualByteElements(reader, context);
    }
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamReader; //导入方法依赖的package包/类
private Element parseSubTree2(HierarchicalStreamReader reader, Document doc)
{
	String qname = reader.getNodeName();
	Element parent = doc.createElement(qname);

	// Iterator i = reader.getAttributeNames();
	int count = reader.getAttributeCount();
	for( int i = 0; i < count; i++ )
	{
		String aname = reader.getAttributeName(i);
		String value = reader.getAttribute(i);
		parent.setAttribute(aname, value);
	}

	String text = reader.getValue();
	if( text.trim().length() != 0 )
	{
		Text textEl = doc.createTextNode(text);
		parent.appendChild(textEl);
	}

	for( ; reader.hasMoreChildren(); reader.moveUp() )
	{
		reader.moveDown();
		Element child = parseSubTree2(reader, doc);
		parent.appendChild(child);
	}

	return parent;
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamReader; //导入方法依赖的package包/类
@Override
public Object unmarshal(final HierarchicalStreamReader reader, final UnmarshallingContext context) {
    final Map<String, Integer> elements = new HashMap<String, Integer>();
    while (reader.hasMoreChildren()) {
        reader.moveDown();
        elements.put(reader.getNodeName(), Integer.valueOf(reader.getValue()));
        reader.moveUp();
    }
    return new Color(elements.get("red").intValue(), elements.get("green").intValue(), elements
        .get("blue")
        .intValue(), elements.get("alpha").intValue());
}