@SuppressWarnings("unchecked")
@Override
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
List<Measure<?, Quantity>> measures = new LimpetList<>();
Unit<Quantity> unit = null;
Object item = null;
if (reader.hasMoreChildren()) {
reader.moveDown();
item = readItem(reader, context, measures);
if (item instanceof Unit) {
unit = (Unit<Quantity>) item;
}
reader.moveUp();
}
if (unit == null) {
@SuppressWarnings("rawtypes")
Collection collection = (Collection) createCollection(context.getRequiredType());
if (item != null) {
collection.add(item);
}
populateCollection(reader, context, collection);
return collection;
}
while (reader.hasMoreChildren()) {
reader.moveDown();
item = readItem(reader, context, measures);
Double dbl = new Double(item.toString());
Measure<Double, Quantity> value = Measure.valueOf(dbl, unit);
measures.add(value);
reader.moveUp();
}
return measures;
}
@Override
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
reader.moveDown();
TurnXML turn = (TurnXML) context.convertAnother(null, TurnXML.class);
reader.moveUp();
reader.moveDown();
List<IAdminResponse> responses = new ArrayList<IAdminResponse>();
while (reader.hasMoreChildren()) {
reader.moveDown();
String tag = reader.getNodeName();
/*AdminResponse is:
-- Tile of false
-- Boolean
-- Tiles */
IAdminResponse response = null;
if (tag.equals(Constants.TAG_TILE))
response = (TileXML) context.convertAnother(null, TileXML.class);
else if (tag.equals(Constants.TAG_FALSE))
response = (FalseXML) context.convertAnother(null, FalseXML.class);
else if (tag.equals(Constants.TAG_TRUE))
response = (TrueXML) context.convertAnother(null, TrueXML.class);
else if (tag.equals(Constants.TAG_RERACK))
response = (RerackXML) context.convertAnother(null, RerackXML.class);
responses.add(response);
reader.moveUp();
}
reader.moveUp();
reader.moveDown();
List<ITurnAction> actions = new ArrayList<ITurnAction>();
while (reader.hasMoreChildren()) {
reader.moveDown();
String tag = reader.getNodeName();
ITurnAction action = null;
if (tag.equals(Constants.TAG_PLACEMENT))
action = (PlacementXML) context.convertAnother(null, PlacementXML.class);
else if (tag.equals(Constants.TAG_RERACKABLE))
action = (RerackableXML) context.convertAnother(null, RerackableXML.class);
else if (tag.equals(Constants.TAG_RERACK))
action = (RerackXML) context.convertAnother(null, RerackXML.class);
actions.add(action);
reader.moveUp();
}
reader.moveUp();
TurnTestXML pojo = new TurnTestXML(turn, actions, responses);
return pojo;
}
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) {
Birthday birthday = new Birthday();
String gender = reader.getAttribute("gender");
if (gender != null) {
if (gender.length() > 0) {
if (gender.startsWith("f")) {
birthday.setGenderFemale();
} else if (gender.startsWith("m")) {
birthday.setGenderMale();
} else {
throw new ConversionException("Invalid gender value: " + gender);
}
} else {
throw new ConversionException("Empty string is invalid gender value");
}
}
while (reader.hasMoreChildren()) {
reader.moveDown();
if ("person".equals(reader.getNodeName())) {
Person person = (Person) context.convertAnother(birthday, Person.class);
birthday.setPerson(person);
} else if ("birth".equals(reader.getNodeName())) {
Calendar date = (Calendar) context.convertAnother(birthday, Calendar.class);
birthday.setDate(date);
}
reader.moveUp();
}
return birthday;
}
public Object readFromStream() {
reader.moveDown();
Class type = HierarchicalStreams.readClassType(reader, mapper);
Object streamItem = context.convertAnother(remoteConfig, type);
reader.moveUp();
return streamItem;
}
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
final Enhancer enhancer = new Enhancer();
reader.moveDown();
enhancer.setSuperclass((Class) context.convertAnother(null, Class.class));
reader.moveUp();
reader.moveDown();
List interfaces = new ArrayList();
while (reader.hasMoreChildren()) {
reader.moveDown();
interfaces.add(context.convertAnother(null, mapper.realClass(reader.getNodeName())));
reader.moveUp();
}
enhancer.setInterfaces((Class[]) interfaces.toArray(new Class[interfaces.size()]));
reader.moveUp();
reader.moveDown();
boolean useFactory = Boolean.valueOf(reader.getValue()).booleanValue();
enhancer.setUseFactory(useFactory);
reader.moveUp();
List callbacksToEnhance = new ArrayList();
List callbacks = new ArrayList();
Map callbackIndexMap = null;
reader.moveDown();
if ("callbacks".equals(reader.getNodeName())) {
reader.moveDown();
callbackIndexMap = (Map) context.convertAnother(null, HashMap.class);
reader.moveUp();
while (reader.hasMoreChildren()) {
reader.moveDown();
readCallback(reader, context, callbacksToEnhance, callbacks);
reader.moveUp();
}
} else {
readCallback(reader, context, callbacksToEnhance, callbacks);
}
enhancer.setCallbacks(
(Callback[]) callbacksToEnhance.toArray(new Callback[callbacksToEnhance.size()]));
if (callbackIndexMap != null) {
enhancer.setCallbackFilter(new ReverseEngineeredCallbackFilter(callbackIndexMap));
}
reader.moveUp();
Object result = null;
while (reader.hasMoreChildren()) {
reader.moveDown();
if (reader.getNodeName().equals("serialVersionUID")) {
enhancer.setSerialVersionUID(Long.valueOf(reader.getValue()));
} else if (reader.getNodeName().equals("instance")) {
result = create(enhancer, callbacks, useFactory);
super.doUnmarshalConditionally(result, reader, context);
}
reader.moveUp();
}
if (result == null) {
result = create(enhancer, callbacks, useFactory);
}
return serializationMethodInvoker.callReadResolve(result);
}
/**
* 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;
}
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 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;
}
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
String node = reader.getNodeName();
reader.moveDown();
GithubSecurityRealm realm = new GithubSecurityRealm();
node = reader.getNodeName();
String value = reader.getValue();
setValue(realm, node, value);
reader.moveUp();
reader.moveDown();
node = reader.getNodeName();
value = reader.getValue();
setValue(realm, node, value);
reader.moveUp();
if (reader.hasMoreChildren()) {
reader.moveDown();
node = reader.getNodeName();
value = reader.getValue();
setValue(realm, node, value);
reader.moveUp();
}
if (realm.getGithubUri() == null) {
realm.setGithubUri(DEFAULT_URI);
}
return realm;
}
@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) {
Map<String, String> map = new HashMap<String, String>();
while (reader.hasMoreChildren()) {
reader.moveDown();
map.put(reader.getNodeName(), reader.getValue());
reader.moveUp();
}
return map;
}
@Override
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
reader.moveDown();
BoardXML boardXML = (BoardXML) context.convertAnother(null, BoardXML.class);
reader.moveUp();
reader.moveDown();
Score score = (Score) context.convertAnother(null, Score.class);
reader.moveUp();
List<Tile> playerHand = parsePlayerHand(reader, context);
TurnXML obj =
new TurnXML(
boardXML.getNumberOfPlayers(), boardXML.getCurrentPlacements(), playerHand, score);
return obj;
}
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) {
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
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;
}
@Override
public Object unmarshal(
final HierarchicalStreamReader reader, final UnmarshallingContext context) {
TurnTest turnTest = new TurnTest();
reader.moveDown();
XMLTurn turn = (XMLTurn) context.convertAnother(turnTest, XMLTurn.class);
turnTest.setTurn(turn);
reader.moveUp();
reader.moveDown();
AdministratorResponses ac =
(AdministratorResponses) context.convertAnother(turnTest, AdministratorResponses.class);
turnTest.setAdministrator(ac);
reader.moveUp();
reader.moveDown();
PlayerActions pa = (PlayerActions) context.convertAnother(turnTest, PlayerActions.class);
turnTest.setActions(pa);
reader.moveUp();
return turnTest;
}
/*
* (non-Javadoc)
*
* @see
* com.thoughtworks.xstream.converters.Converter#unmarshal(com.thoughtworks
* .xstream.io.HierarchicalStreamReader,
* com.thoughtworks.xstream.converters.UnmarshallingContext)
*/
@Override
@SuppressWarnings("unchecked")
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
InstanceInfo.Builder builder = InstanceInfo.Builder.newBuilder();
while (reader.hasMoreChildren()) {
reader.moveDown();
String nodeName = reader.getNodeName();
if (ELEM_HOST.equals(nodeName)) {
builder.setHostName(reader.getValue());
} else if (ELEM_INSTANCE_ID.equals(nodeName)) {
builder.setInstanceId(reader.getValue());
} else if (ELEM_APP.equals(nodeName)) {
builder.setAppName(reader.getValue());
} else if (ELEM_IP.equals(nodeName)) {
builder.setIPAddr(reader.getValue());
} else if (ELEM_SID.equals(nodeName)) {
builder.setSID(reader.getValue());
} else if (ELEM_IDENTIFYING_ATTR.equals(nodeName)) {
// nothing;
} else if (ELEM_STATUS.equals(nodeName)) {
builder.setStatus(InstanceStatus.toEnum(reader.getValue()));
} else if (ELEM_OVERRIDDEN_STATUS.equals(nodeName)) {
builder.setOverriddenStatus(InstanceStatus.toEnum(reader.getValue()));
} else if (ELEM_PORT.equals(nodeName)) {
builder.setPort(Integer.valueOf(reader.getValue()).intValue());
// Defaults to true
builder.enablePort(PortType.UNSECURE, !"false".equals(reader.getAttribute(ATTR_ENABLED)));
} else if (ELEM_SECURE_PORT.equals(nodeName)) {
builder.setSecurePort(Integer.valueOf(reader.getValue()).intValue());
// Defaults to false
builder.enablePort(PortType.SECURE, "true".equals(reader.getAttribute(ATTR_ENABLED)));
} else if (ELEM_COUNTRY_ID.equals(nodeName)) {
builder.setCountryId(Integer.valueOf(reader.getValue()).intValue());
} else if (NODE_DATACENTER.equals(nodeName)) {
builder.setDataCenterInfo(
(DataCenterInfo) context.convertAnother(builder, DataCenterInfo.class));
} else if (NODE_LEASE.equals(nodeName)) {
builder.setLeaseInfo((LeaseInfo) context.convertAnother(builder, LeaseInfo.class));
} else if (NODE_METADATA.equals(nodeName)) {
builder.setMetadata((Map<String, String>) context.convertAnother(builder, Map.class));
} else {
autoUnmarshalEligible(reader, builder.getRawInstance());
}
reader.moveUp();
}
return builder.build();
}
@Override
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
Wfs20FeatureCollection featureCollection = new Wfs20FeatureCollection();
while (reader.hasMoreChildren()) {
reader.moveDown();
String nodeName = reader.getNodeName();
// Its important to note that the reader appears to drop the
// namespace.
if (FEATURE_MEMBER.equals(nodeName)) {
reader.moveDown();
String subNodeName = reader.getNodeName();
// If the member contains a sub feature collection, step in and get members
if (subNodeName.equals(FEATURE_COLLECTION)) {
while (reader.hasMoreChildren()) {
reader.moveDown();
String subNodeName2 = reader.getNodeName();
if (FEATURE_MEMBER.equals(subNodeName2)) {
reader.moveDown();
// lookup the converter for this featuretype
featureCollection =
addMetacardToFeatureCollection(featureCollection, context, reader);
reader.moveUp();
}
reader.moveUp();
}
} else {
// lookup the converter for this featuretype
featureCollection = addMetacardToFeatureCollection(featureCollection, context, reader);
}
reader.moveUp();
}
reader.moveUp();
}
return featureCollection;
}
/**
* @see
* com.thoughtworks.xstream.converters.Converter#unmarshal(com.thoughtworks.xstream.io.HierarchicalStreamReader,
* com.thoughtworks.xstream.converters.UnmarshallingContext)
*/
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
Quota quota = new Quota();
reader.moveDown();
String nodeName = reader.getNodeName();
Assert.isTrue("value".equals(nodeName));
String nodevalue = reader.getValue();
double value = Double.parseDouble(nodevalue);
reader.moveUp();
reader.moveDown();
nodeName = reader.getNodeName();
Assert.isTrue("units".equals(nodeName));
nodevalue = reader.getValue();
StorageUnit unit = StorageUnit.valueOf(nodevalue);
reader.moveUp();
quota.setValue(value, unit);
return quota;
}
@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);
}
@Override
public FIXMLRoot unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
FIXMLRoot root = new FIXMLRoot();
root.setVersion(reader.getAttribute("v"));
root.setReleaseDate(reader.getAttribute("r"));
root.setSchemaDate(reader.getAttribute("s"));
if (reader.hasMoreChildren()) {
reader.moveDown();
root.setMessage((Message) context.convertAnother(root, Message.class));
reader.moveUp();
}
return root;
}
public void copy(HierarchicalStreamReader source, HierarchicalStreamWriter destination) {
destination.startNode(source.getNodeName());
int attributeCount = source.getAttributeCount();
for (int i = 0; i < attributeCount; i++) {
destination.addAttribute(source.getAttributeName(i), source.getAttribute(i));
}
String value = source.getValue();
if (value != null && value.length() > 0) {
destination.setValue(value);
}
while (source.hasMoreChildren()) {
source.moveDown();
copy(source, destination);
source.moveUp();
}
destination.endNode();
}
/*
* (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;
}
/*
* (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) {
Applications apps = new Applications();
while (reader.hasMoreChildren()) {
reader.moveDown();
String nodeName = reader.getNodeName();
if (NODE_APP.equals(nodeName)) {
apps.addApplication((Application) context.convertAnother(apps, Application.class));
} else if (VERSIONS_DELTA.equals(nodeName)) {
apps.setVersion(Long.valueOf(reader.getValue()));
} else if (APPS_HASHCODE.equals(nodeName)) {
apps.setAppsHashCode(reader.getValue());
}
reader.moveUp();
}
return apps;
}
protected void unmarshalStringKey(
HierarchicalStreamReader reader, UnmarshallingContext context, Map map, String key) {
String type = reader.getAttribute("type");
Object value;
if (type == null && reader.hasMoreChildren()) {
reader.moveDown();
value = readItem(reader, context, map);
reader.moveUp();
} else {
Class typeC = type != null ? mapper().realClass(type) : String.class;
try {
value = TypeCoercions.coerce(reader.getValue(), typeC);
} catch (Exception e) {
log.warn("FAILED to coerce " + reader.getValue() + " to " + typeC + ": " + e);
throw Exceptions.propagate(e);
}
}
map.put(key, value);
}
