public Object readFromStream() { reader.moveDown(); Class type = HierarchicalStreams.readClassType(reader, mapper); Object streamItem = context.convertAnother(remoteConfig, type); reader.moveUp(); return streamItem; }
/** * Unmarshal all the elements to their field values if the fields have the {@link Auto} annotation * defined. * * @param reader - The reader where the elements can be read. * @param o - The object for which the value of fields need to be populated. */ private static void autoUnmarshalEligible(HierarchicalStreamReader reader, Object o) { try { String nodeName = reader.getNodeName(); Class c = o.getClass(); Field f = null; try { f = c.getDeclaredField(nodeName); } catch (NoSuchFieldException e) { UNMARSHALL_ERROR_COUNTER.increment(); } if (f == null) { return; } Annotation annotation = f.getAnnotation(Auto.class); if (annotation == null) { return; } f.setAccessible(true); String value = reader.getValue(); Class returnClass = f.getType(); if (value != null) { if (!String.class.equals(returnClass)) { Method method = returnClass.getDeclaredMethod("valueOf", java.lang.String.class); Object valueObject = method.invoke(returnClass, value); f.set(o, valueObject); } else { f.set(o, value); } } } catch (Throwable th) { logger.error("Error in unmarshalling the object:", th); } }
private Class determineType( HierarchicalStreamReader reader, boolean validField, Object result, String fieldName, Class definedInCls) { String classAttribute = reader.getAttribute(mapper.aliasForAttribute("class")); Class fieldType = reflectionProvider.getFieldType(result, fieldName, definedInCls); if (classAttribute != null) { Class specifiedType = mapper.realClass(classAttribute); if (fieldType.isAssignableFrom(specifiedType)) // make sure that the specified type in XML is compatible with the field type. // this allows the code to evolve in more flexible way. return specifiedType; } if (!validField) { Class itemType = mapper.getItemTypeForItemFieldName(result.getClass(), fieldName); if (itemType != null) { return itemType; } else { return mapper.realClass(reader.getNodeName()); } } else { return mapper.defaultImplementationOf(fieldType); } }
public Object unmarshal(Exchange exchange, InputStream stream) throws Exception { HierarchicalStreamReader reader = createHierarchicalStreamReader(exchange, stream); try { return getXStream(exchange.getContext()).unmarshal(reader); } finally { reader.close(); } }
/** * Utility method for reading an item of a collection. It was created because the {@code readItem} * method from the parent class does not move the reader ({@code * HierarchicalStreamReader#moveDown()} and{@code HierarchicalStreamReader#moveUp()}) */ @SuppressWarnings("unchecked") protected <T> T readChildItem( HierarchicalStreamReader reader, UnmarshallingContext context, Object current) { reader.moveDown(); T o = (T) readItem(reader, context, current); reader.moveUp(); return o; }
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) { String nullAttribute = reader.getAttribute("null"); if (nullAttribute != null && nullAttribute.equals("true")) { return new Character('\0'); } else { return new Character(reader.getValue().charAt(0)); } }
private Map<String, String> readNode(HierarchicalStreamReader reader) { Map<String, String> values = new HashMap<String, String>(); while (reader.hasMoreChildren()) { reader.moveDown(); values.put(reader.getNodeName(), reader.getValue()); reader.moveUp(); } return values; }
@Override public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) { if (reader.getNodeName().equals(Constants.TAG_TRUE)) return new TrueXML(); else if (reader.getNodeName().equals(Constants.TAG_FALSE)) return new FalseXML(); else { System.out.println("Boolean Unmarshal unexpectd result"); return null; } }
@Override public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) { Map<String, String> map = new HashMap<String, String>(); while (reader.hasMoreChildren()) { reader.moveDown(); map.put(reader.getNodeName(), reader.getValue()); reader.moveUp(); } return map; }
@SuppressWarnings("unchecked") public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) { List list = new ArrayList(); while (reader.hasMoreChildren()) { reader.moveDown(); list.add(context.convertAnother(list, type)); reader.moveUp(); } return list; }
@Override public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) { List<String> names = new ArrayList<String>(); while (reader.hasMoreChildren()) { reader.moveDown(); names.add(reader.getAttribute(Constants.ATTRIBUTE_PLAYER_NAME)); reader.moveUp(); } return new PlayersXML(names); }
@Override public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) { List<Tile> tiles = new ArrayList<Tile>(); while (reader.hasMoreChildren()) { reader.moveDown(); TileXML tileXML = (TileXML) context.convertAnother(null, TileXML.class); tiles.add(tileXML.getTile()); reader.moveUp(); } return new RerackXML(tiles); }
private List<Tile> parsePlayerHand( HierarchicalStreamReader reader, UnmarshallingContext context) { List<Tile> tiles = new ArrayList<Tile>(); while (reader.hasMoreChildren()) { reader.moveDown(); TileXML tileXML = (TileXML) context.convertAnother(null, TileXML.class); tiles.add(tileXML.getTile()); reader.moveUp(); } return tiles; }
@Override protected void unmarshalEntry( HierarchicalStreamReader reader, UnmarshallingContext context, Map map) { String key = reader.getNodeName(); if (key.equals(getEntryNodeName())) key = reader.getAttribute("key"); if (key == null) { super.unmarshalEntry(reader, context, map); } else { unmarshalStringKey(reader, context, map, key); } }
protected void populateMap( final HierarchicalStreamReader reader, final UnmarshallingContext context, final Map<?, ?> map, final Map<?, ?> target) { while (reader.hasMoreChildren()) { reader.moveDown(); putCurrentEntryIntoMap(reader, context, map, target); reader.moveUp(); } }
@Override public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) { String name = reader.getAttribute(Constants.ATTRIBUTE_RESULT_NAME); List<Placement> placements = new ArrayList<Placement>(); while (reader.hasMoreChildren()) { reader.moveDown(); PlacementXML placementXML = (PlacementXML) context.convertAnother(null, PlacementXML.class); placements.add(placementXML.getPlacement()); reader.moveUp(); } return new ResultXML(name, placements); }
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) { Murmurs murmurs = new Murmurs(); while (reader.hasMoreChildren()) { reader.moveDown(); Murmur project = (Murmur) context.convertAnother(murmurs, Murmur.class); murmurs.add(project); reader.moveUp(); } return murmurs; }
public Object unmarshal(HierarchicalStreamReader reader, final UnmarshallingContext context) { if (reader.hasMoreChildren()) { /* old format where <range> elements are nested like <range> <start>1337</start> <end>1479</end> </range> */ return new RangeSet((List<Range>) (collectionConv.unmarshal(reader, context))); } else { return RangeSet.fromString(reader.getValue(), true); } }
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) { Object obj = context.currentObject(); if (obj == null) { try { obj = context.getRequiredType().newInstance(); } catch (Exception e) { throw new ObjectAccessException( "Cannot construct " + context.getRequiredType().getName(), e); } } Iterator attNames = reader.getAttributeNames(); while (attNames.hasNext()) { String attName = (String) attNames.next(); if (attName.equals(textName)) { continue; } try { Field field = obj.getClass().getDeclaredField(mapper.realMember(obj.getClass(), attName)); if (!field.isAccessible()) { field.setAccessible(true); } String v = reader.getAttribute(attName); if (null == v || "".equals(v)) { continue; } Class fieldType = field.getType(); Constructor strnum = fieldType.getDeclaredConstructor(String.class); field.set(obj, strnum.newInstance(v)); } catch (Exception e) { e.printStackTrace(); throw new ObjectAccessException("Cannot construct " + obj.getClass(), e); } } String value = reader.getValue(); if (null != value && !"".equals(value)) { try { Field field = obj.getClass().getDeclaredField(mapper.realMember(obj.getClass(), textName)); if (!field.isAccessible()) { field.setAccessible(true); } field.set(obj, value); } catch (Exception e) { e.printStackTrace(); throw new ObjectAccessException("Cannot construct " + obj.getClass(), e); } } return obj; }
@Override public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext uc) { String code = reader.getAttribute(CURRENCY_CODE_ATTRIBUTE_NAME); Currency currency = new Currency(code); String exchangeRateString = reader.getAttribute(CURRENCY_EXCHANGE_RATE_ATTRIBUTE_NAME); // seems to return null if attribute isn't present, improvement // of docs requested as // https://github.com/x-stream/xstream/issues/47 if (exchangeRateString != null) { double exchangeRate = Double.valueOf(exchangeRateString); currency.setExchangeRate(exchangeRate); } return currency; }
@Override public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) { if (Constants.TAG_NULL_TILE.equals(reader.getNodeName())) { Tile tile = new NullTile(); return tile; } else { String c0 = reader.getAttribute(Constants.ATTRIBUTE_TILE_C0); String c1 = reader.getAttribute(Constants.ATTRIBUTE_TILE_C1); Tile tile = new Tile(Color.valueOf(c0), Color.valueOf(c1)); return new TileXML(tile); } }
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) { NotePad frame = new NotePad(); reader.moveDown(); String fieldText = (String) context.convertAnother(frame, String.class); frame.textField.setText(Marshaler.newLinesToJava(fieldText)); reader.moveUp(); reader.moveDown(); String areaText = (String) context.convertAnother(frame, String.class); frame.textArea.setText(Marshaler.newLinesToJava(areaText)); reader.moveUp(); return frame; }
@Override public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) { // TODO Auto-generated method stub GregorianCalendar calendar = new GregorianCalendar(); calendar.setTime(new Date(Long.parseLong(reader.getValue()))); return calendar; }
@Override public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) { String players = reader.getAttribute(Constants.ATTRIBUTE_BOARD_PLAYERS); int numberOfPlayers = new Integer(players).intValue(); List<Placement> currentPlacements = new ArrayList<Placement>(); while (reader.hasMoreChildren()) { reader.moveDown(); PlacementXML placementXML = (PlacementXML) context.convertAnother(null, PlacementXML.class); currentPlacements.add(placementXML.getPlacement()); reader.moveUp(); } return new BoardXML(numberOfPlayers, currentPlacements); }
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) { Resposta3098LoteMensagem enq = new Resposta3098LoteMensagem(); Resposta3098OcorrenciaMensagem resp = new Resposta3098OcorrenciaMensagem(); Resposta3098EnquadramentoMensagem enqMensagem = new Resposta3098EnquadramentoMensagem(); enqMensagem.setCodigoEnquadramento(new Long(reader.getValue())); List<Resposta3098EnquadramentoMensagem> listEnqMensagem = new ArrayList<Resposta3098EnquadramentoMensagem>(); listEnqMensagem.add(enqMensagem); resp.setEnquadramentos(listEnqMensagem); List<Resposta3098OcorrenciaMensagem> listResp = new ArrayList<Resposta3098OcorrenciaMensagem>(); listResp.add(resp); enq.setOcorrencias(listResp); reader.moveUp(); return enq; }
protected void putCurrentEntryIntoMap( final HierarchicalStreamReader reader, final UnmarshallingContext context, final Map<?, ?> map, final Map<?, ?> target) { reader.moveDown(); final Object key = readItem(reader, context, map); reader.moveUp(); reader.moveDown(); final Object value = readItem(reader, context, map); reader.moveUp(); @SuppressWarnings("unchecked") final Map<Object, Object> targetMap = (Map<Object, Object>) target; targetMap.put(key, value); }
private Class determineType(HierarchicalStreamReader reader, Object result, String fieldName) { String classAttribute = reader.getAttribute(classAttributeIdentifier); if (classAttribute != null) { return classMapper.realClass(classAttribute); } else { return classMapper.defaultImplementationOf(beanProvider.getPropertyType(result, fieldName)); } }
protected void unmarshallAttributes( Object current, HierarchicalStreamReader reader, UnmarshallingContext context) { while (reader.hasMoreChildren()) { Attribute attribute = readChildItem(reader, context, current); addAttribute(current, attribute); } }
/* * (non-Javadoc) * * @see * com.thoughtworks.xstream.converters.Converter#unmarshal(com.thoughtworks * .xstream.io.HierarchicalStreamReader, * com.thoughtworks.xstream.converters.UnmarshallingContext) */ @Override public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) { Application app = new Application(); while (reader.hasMoreChildren()) { reader.moveDown(); String nodeName = reader.getNodeName(); if (ELEM_NAME.equals(nodeName)) { app.setName(reader.getValue()); } else if (NODE_INSTANCE.equals(nodeName)) { app.addInstance((InstanceInfo) context.convertAnother(app, InstanceInfo.class)); } reader.moveUp(); } return app; }
private Map<String, String> unmarshalMap( HierarchicalStreamReader reader, UnmarshallingContext context) { Map<String, String> map = Collections.emptyMap(); while (reader.hasMoreChildren()) { if (map == Collections.EMPTY_MAP) { map = new HashMap<String, String>(); } reader.moveDown(); String key = reader.getNodeName(); String value = reader.getValue(); reader.moveUp(); map.put(StringCache.intern(key), value); } return map; }