/*
* (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 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;
}
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);
}
}
@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;
}
@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 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 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));
}
}
@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
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);
}
}
@Override
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
String c0 = reader.getAttribute(Constants.ATTRIBUTE_PLACEMENT_C0);
String d0 = reader.getAttribute(Constants.ATTRIBUTE_PLACEMENT_D0);
String a0 = reader.getAttribute(Constants.ATTRIBUTE_PLACEMENT_A0);
String c1 = reader.getAttribute(Constants.ATTRIBUTE_PLACEMENT_C1);
String d1 = reader.getAttribute(Constants.ATTRIBUTE_PLACEMENT_D1);
String a1 = reader.getAttribute(Constants.ATTRIBUTE_PLACEMENT_A1);
Placement placement =
new Placement(
Color.valueOf(c0),
Integer.valueOf(d0),
Integer.valueOf(a0),
Color.valueOf(c1),
Integer.valueOf(d1),
Integer.valueOf(a1));
return new PlacementXML(placement);
}
@Override
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
String c0 = reader.getAttribute("orange");
String d0 = reader.getAttribute("red");
String a0 = reader.getAttribute("green");
String c1 = reader.getAttribute("yellow");
String d1 = reader.getAttribute("purple");
String a1 = reader.getAttribute("blue");
Score score = new Score();
score.setValue(Color.ORANGE, Integer.valueOf(c0));
score.setValue(Color.RED, Integer.valueOf(d0));
score.setValue(Color.GREEN, Integer.valueOf(a0));
score.setValue(Color.YELLOW, Integer.valueOf(c1));
score.setValue(Color.PURPLE, Integer.valueOf(d1));
score.setValue(Color.BLUE, Integer.valueOf(a1));
return score;
}
protected Object instantiateNewInstance(
HierarchicalStreamReader reader, UnmarshallingContext context) {
String readResolveValue = reader.getAttribute(mapper.aliasForAttribute("resolves-to"));
Object currentObject = context.currentObject();
if (currentObject != null) {
return currentObject;
} else if (readResolveValue != null) {
return reflectionProvider.newInstance(mapper.realClass(readResolveValue));
} else {
return reflectionProvider.newInstance(context.getRequiredType());
}
}
@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) {
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 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);
}
}
@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 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();
}
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);
}
@Override
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
String numberOfPlayersStr = reader.getAttribute(Constants.ATTRIBUTE_ACCEPT_PLAYER);
int numberOfPlayers;
try {
numberOfPlayers = Integer.parseInt(numberOfPlayersStr);
} catch (NumberFormatException e) {
return null;
}
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 AcceptXML(numberOfPlayers, tiles);
}
public Object unmarshal(HierarchicalStreamReader reader, final UnmarshallingContext context) {
final WorkItemHandlerModelImpl wih = new WorkItemHandlerModelImpl();
wih.setType(reader.getAttribute("type"));
/* TODO make qualifiers working properly before readd them to the xml
String qualifierType = reader.getAttribute("qualifier");
if (qualifierType != null) {
wih.newQualifierModel(qualifierType);
}
readNodes( reader, new AbstractXStreamConverter.NodeReader() {
public void onNode(HierarchicalStreamReader reader,
String name,
String value) {
if ( "qualifier".equals( name ) ) {
QualifierModelImpl qualifier = readObject(reader, context, QualifierModelImpl.class);
wih.setQualifierModel(qualifier);
}
}
} );
*/
return wih;
}
@SuppressWarnings("unchecked")
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
List interfaces = new ArrayList();
InvocationHandler handler = null;
while (reader.hasMoreChildren()) {
reader.moveDown();
String elementName = reader.getNodeName();
if (elementName.equals("interface")) {
interfaces.add(mapper.realClass(reader.getValue()));
} else if (elementName.equals("handler")) {
Class handlerType = mapper.realClass(reader.getAttribute("class"));
handler = (InvocationHandler) context.convertAnother(null, handlerType);
}
reader.moveUp();
}
if (handler == null) {
throw new ConversionException("No InvocationHandler specified for dynamic proxy");
}
Class[] interfacesAsArray = new Class[interfaces.size()];
interfaces.toArray(interfacesAsArray);
return Proxy.newProxyInstance(classLoader, interfacesAsArray, handler);
}
public Object unmarshal(HierarchicalStreamReader reader, final UnmarshallingContext context) {
final KieSessionModelImpl kSession = new KieSessionModelImpl();
kSession.name = reader.getAttribute("name");
kSession.setDefault("true".equals(reader.getAttribute("default")));
String kSessionType = reader.getAttribute("type");
kSession.setType(
kSessionType != null
? KieSessionType.valueOf(kSessionType.toUpperCase())
: KieSessionType.STATEFUL);
String clockType = reader.getAttribute("clockType");
if (clockType != null) {
kSession.setClockType(ClockTypeOption.get(clockType));
}
String beliefSystem = reader.getAttribute("beliefSystem");
if (beliefSystem != null) {
kSession.setBeliefSystem(BeliefSystemTypeOption.get(beliefSystem));
}
String scope = reader.getAttribute("scope");
if (scope != null) {
kSession.setScope(scope);
}
readNodes(
reader,
new AbstractXStreamConverter.NodeReader() {
public void onNode(HierarchicalStreamReader reader, String name, String value) {
if ("listeners".equals(name)) {
while (reader.hasMoreChildren()) {
reader.moveDown();
String nodeName = reader.getNodeName();
ListenerModelImpl listener = readObject(reader, context, ListenerModelImpl.class);
listener.setKSession(kSession);
listener.setKind(ListenerModel.Kind.fromString(nodeName));
kSession.addListenerModel(listener);
reader.moveUp();
}
} else if ("workItemHandlers".equals(name)) {
List<WorkItemHandlerModelImpl> wihs =
readObjectList(reader, context, WorkItemHandlerModelImpl.class);
for (WorkItemHandlerModelImpl wih : wihs) {
wih.setKSession(kSession);
kSession.addWorkItemHandelerModel(wih);
}
} else if ("consoleLogger".equals(name)) {
String consoleLogger = reader.getAttribute("name");
kSession.setConsoleLogger(consoleLogger == null ? "" : consoleLogger);
} else if ("fileLogger".equals(name)) {
FileLoggerModelImpl fileLoggerModel =
new FileLoggerModelImpl(reader.getAttribute("file"));
try {
fileLoggerModel.setInterval(Integer.parseInt(reader.getAttribute("interval")));
} catch (Exception e) {
}
try {
fileLoggerModel.setThreaded(
Boolean.parseBoolean(reader.getAttribute("threaded")));
} catch (Exception e) {
}
kSession.fileLogger = fileLoggerModel;
}
}
});
return kSession;
}
/* (non-Javadoc)
* @see com.thoughtworks.xstream.converters.Converter#unmarshal(com.thoughtworks.xstream.io.HierarchicalStreamReader, com.thoughtworks.xstream.converters.UnmarshallingContext)
*/
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
URI uri = URI.create(reader.getAttribute("uri"));
return XExtensionManager.instance().getByUri(uri);
}
// ----------------------------------------------------------
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
// Object current = context.currentObject();
Object result = getInstance(context);
// Object result = null;
if (top == true && key != null && cache != null) {
// This is simply to prevent infinite recursion when you get an
// object out of the store that references this object. This stored
// object will be overwritten when everything is finished.
cache.put(key, new StoredObject(key, "ALIAS", result, Snapshot.getLocal(), Long.MAX_VALUE));
top = false;
}
Map<String, Object> fields = null;
UUID id = null;
if (reader.getAttribute(XMLConstants.FIELDSET_ATTRIBUTE) != null) {
String objId = reader.getAttribute(XMLConstants.ID_ATTRIBUTE);
id = UUID.fromString(objId);
@SuppressWarnings("unchecked")
Map<String, Object> realFields =
(Map<String, Object>) mapConverter.unmarshal(reader, context);
fields = realFields;
} else {
result = super.unmarshal(reader, context);
if (result instanceof TreeMap && !TreeMap.class.isAssignableFrom(context.getRequiredType())) {
@SuppressWarnings("unchecked")
Map<String, Object> realFields = (Map<String, Object>) result;
fields = realFields;
}
}
if (fields != null) {
try {
Method initFieldsMethod = result.getClass().getMethod("initializeFields", (Class<?>) null);
initFieldsMethod.invoke(result, (Object[]) null);
} catch (Exception e) {
// its ok if this doesnt exist
}
// result = reflectionProvider.newInstance( context.getRequiredType() );
restoreObjectFromFieldMap(result, fields); /*
* && pjProvider
* != null
*/
// {
// try
// {
// Method initFieldsMethod = result.getClass()
// .getMethod( "initializeFields", (Class<?>)null );
// initFieldsMethod.invoke( result, (Object[])null );
// }
// catch ( Exception e )
// {
// try
// {
// Constructor<?> defaultConst = result.getClass()
// .getConstructor();
// Object newResult = defaultConst.newInstance();
// restoreObjectFromFieldMap( newResult, fields );
// result = newResult;
//
// }
// catch ( SecurityException e1 )
// {
// System.err.println( "You made your default constructor for "
// + result.getClass().getName()
// + " private. If you would like it to be used"
// + " by the persistence library please make it public" );
// }
// catch ( NoSuchMethodException e2 )
// {
// System.err.println( "The shared object \""
// + result.getClass().getName()
// + "\" you have loaded did not "
// + "contain all of the fields present in your original object. "
// + "We were also unable to find a method with the signature
// \"public "
// + "void initializeFields()\" or the "
// + "default constructor \"public "
// + result.getClass().getName()
// + "()\". If you have made assumptions "
// + "about the state of certain fields in your "
// + result.getClass().getName()
// + " Object please provide one of these methods to initialize the
// fields "
// + "not present in the datastore." );
// }
// catch ( Exception e3 )
// {
// System.err.println( "An exception occured when initializing your
// object with the default constructor." );
// }
//
// }
// }
if (result != null) {
Snapshot.getLocal().resolveObject(id, result, fields);
}
}
return result;
}
private Plot createPlot(HierarchicalStreamReader reader) {
Plot plot = null;
if (reader.getNodeName().equals("barPlot")) {
BarPlot barPlot = new BarPlot();
barPlot.getGrid().setVisible(false);
String flavor = reader.getAttribute("flavor");
if (flavor != null) {
try {
barPlot.setFlavor(Enum.valueOf(BarPlotFlavor.class, flavor.toUpperCase()));
} catch (Exception ex) {
// Do nothing, we'll stay with the default.
}
}
plot = barPlot;
} else if (reader.getNodeName().equals("linePlot")) {
LinePlot linePlot = new LinePlot();
linePlot.getGrid().setVisible(false);
String flavor = reader.getAttribute("flavor");
if (flavor != null) {
try {
linePlot.setFlavor(Enum.valueOf(LinePlotFlavor.class, flavor.toUpperCase()));
} catch (Exception ex) {
// Do nothing, we'll stay with the default.
}
}
plot = linePlot;
} else if (reader.getNodeName().equals("areaPlot")) {
AreaPlot areaPlot = new AreaPlot();
areaPlot.getGrid().setVisible(false);
plot = areaPlot;
} else if (reader.getNodeName().equals("scatterPlot")) {
ScatterPlot scatterPlot = new ScatterPlot();
scatterPlot.getGrid().setVisible(false);
plot = scatterPlot;
} else if (reader.getNodeName().equals("piePlot")) {
PiePlot piePlot = new PiePlot();
piePlot.getLabels().setVisible(false);
piePlot.setAnimate(Boolean.parseBoolean(reader.getAttribute("animate")));
try {
piePlot.setStartAngle(Integer.parseInt(reader.getAttribute("startAngle")));
} catch (Exception ex) {
// Do nothing.We won't set the start angle
}
plot = piePlot;
} else if (reader.getNodeName().equals("dialPlot")) {
DialPlot dialPlot = new DialPlot();
dialPlot.setAnimate(Boolean.parseBoolean(reader.getAttribute("animate")));
plot = dialPlot;
}
String orientation = reader.getAttribute("orientation");
if (orientation != null) {
try {
plot.setOrientation(Enum.valueOf(Orientation.class, orientation.toUpperCase()));
} catch (Exception ex) {
// Do nothing, we'll stay with the default.
}
}
String cssStyle = reader.getAttribute("style");
if (cssStyle != null) {
plot.getStyle().setStyleString(cssStyle);
}
while (reader.hasMoreChildren()) {
reader.moveDown();
if (reader.getNodeName().equals("palette")) {
CssStyle paintStyle = new CssStyle();
Palette palette = new Palette();
while (reader.hasMoreChildren()) {
reader.moveDown();
if (reader.getNodeName().equals("paint")) {
cssStyle = reader.getAttribute("style");
if (cssStyle != null) {
paintStyle.setStyleString(cssStyle);
Integer color = paintStyle.getColor();
if (color != null) {
palette.add(color);
}
}
}
reader.moveUp();
}
if (palette.size() > 0) {
plot.setPalette(palette);
}
}
if ((reader.getNodeName().equals("verticalAxis")
|| reader.getNodeName().equals("horizontalAxis"))
&& (plot instanceof TwoAxisPlot)) {
TwoAxisPlot twoAxisPlot = (TwoAxisPlot) plot;
Axis axis =
(reader.getNodeName().equals("verticalAxis")
? twoAxisPlot.getVerticalAxis()
: twoAxisPlot.getHorizontalAxis());
String axisLabelOrientation = reader.getAttribute("labelOrientation");
try {
axis.setLabelOrientation(
Enum.valueOf(LabelOrientation.class, axisLabelOrientation.toUpperCase()));
} catch (Exception ex) {
// Do nothing, we'll stay with the default.
}
if (axis instanceof NumericAxis) {
NumericAxis numericAxis = (NumericAxis) axis;
String minValueStr = reader.getAttribute("minValue");
if (minValueStr != null) {
try {
numericAxis.setMinValue(Integer.parseInt(minValueStr));
} catch (NumberFormatException ex) {
try {
numericAxis.setMinValue(Double.parseDouble(minValueStr));
} catch (NumberFormatException ex2) {
// Do nothing. No min value will be assigned.
}
}
}
String maxValueStr = reader.getAttribute("maxValue");
if (maxValueStr != null) {
if (maxValueStr != null) {
try {
numericAxis.setMaxValue(Integer.parseInt(maxValueStr));
} catch (NumberFormatException ex) {
try {
numericAxis.setMaxValue(Double.parseDouble(maxValueStr));
} catch (NumberFormatException ex2) {
// Do nothing. No min value will be assigned.
}
}
}
}
}
cssStyle = reader.getAttribute("style");
if (cssStyle != null) {
axis.getStyle().setStyleString(cssStyle);
}
while (reader.hasMoreChildren()) {
reader.moveDown();
String legend = reader.getValue();
if (legend != null) {
axis.getLegend().setText(legend);
}
cssStyle = reader.getAttribute("style");
if (cssStyle != null) {
axis.getLegend().getStyle().setStyleString(cssStyle);
}
reader.moveUp();
}
}
if (reader.getNodeName().equals("grid") && (plot instanceof TwoAxisPlot)) {
TwoAxisPlot twoAxisPlot = (TwoAxisPlot) plot;
Grid grid = twoAxisPlot.getGrid();
grid.setVisible(true);
while (reader.hasMoreChildren()) {
reader.moveDown();
if (reader.getNodeName().equals("verticalLines")) {
cssStyle = reader.getAttribute("style");
if (cssStyle != null) {
grid.getVerticalLineStyle().setStyleString(cssStyle);
}
} else if (reader.getNodeName().equals("horizontalLines")) {
cssStyle = reader.getAttribute("style");
if (cssStyle != null) {
grid.getHorizontalLineStyle().setStyleString(cssStyle);
}
}
reader.moveUp();
}
}
if (reader.getNodeName().equals("scale") && (plot instanceof DialPlot)) {
while (reader.hasMoreChildren()) {
CssStyle rangeStyle = new CssStyle();
Integer color = null;
Double rangeMin = null;
Double rangeMax = null;
reader.moveDown();
if (reader.getNodeName().equals("range")) {
cssStyle = reader.getAttribute("style");
if (cssStyle != null) {
rangeStyle.setStyleString(cssStyle);
color = rangeStyle.getColor();
}
String str = reader.getAttribute("min");
if (str != null) {
rangeMin = new Double(str);
}
str = reader.getAttribute("max");
if (str != null) {
rangeMax = new Double(str);
}
((DialPlot) plot).getScale().addRange(new DialRange(rangeMin, rangeMax, color));
}
reader.moveUp();
}
}
if (reader.getNodeName().equals("labels") && (plot instanceof PiePlot)) {
PiePlot piePlot = (PiePlot) plot;
piePlot.getLabels().setVisible(true);
cssStyle = reader.getAttribute("style");
if (cssStyle != null) {
piePlot.getLabels().getStyle().setStyleString(cssStyle);
}
}
if (reader.getNodeName().equals("annotation") && (plot instanceof DialPlot)) {
DialPlot dialPlot = (DialPlot) plot;
String annotation = reader.getValue();
if (annotation != null) {
dialPlot.getAnnotation().setText(annotation);
}
cssStyle = reader.getAttribute("style");
if (cssStyle != null) {
dialPlot.getAnnotation().getStyle().setStyleString(cssStyle);
}
}
reader.moveUp();
}
return plot;
}
@Override
protected void readAdditional(
DrawComponent dc, HierarchicalStreamReader reader, UnmarshallingContext context) {
LineDrawComponent ldc = (LineDrawComponent) dc;
ldc.setConnect(Boolean.parseBoolean(reader.getAttribute(CONNECT)));
}
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
ChartModel chartModel = new ChartModel();
chartModel.setChartEngineId(reader.getAttribute("chartEngine"));
String attribute = reader.getAttribute("theme");
if (attribute != null) {
try {
chartModel.setTheme(Enum.valueOf(ChartTheme.class, attribute.toUpperCase()));
} catch (Exception e) {
// Do nothing
}
}
String cssStyle = reader.getAttribute("style");
if (cssStyle != null) {
chartModel.getStyle().setStyleString(cssStyle);
}
while (reader.hasMoreChildren()) {
reader.moveDown();
if (reader.getNodeName().equals("title")) {
String title = reader.getValue();
if (title != null) {
chartModel.getTitle().setText(title);
}
cssStyle = reader.getAttribute("style");
if (cssStyle != null) {
chartModel.getTitle().getStyle().setStyleString(cssStyle);
}
attribute = reader.getAttribute("location");
if (attribute != null) {
try {
chartModel
.getTitle()
.setLocation(Enum.valueOf(TitleLocation.class, attribute.toUpperCase()));
} catch (Exception e) {
// Do nothing
}
}
} else if (reader.getNodeName().equals("subtitle")) {
String subtitle = reader.getValue();
if ((subtitle != null) && (subtitle.trim().length() > 0)) {
StyledText styledText = new StyledText(subtitle);
cssStyle = reader.getAttribute("style");
if (cssStyle != null) {
styledText.getStyle().setStyleString(cssStyle);
}
chartModel.getSubtitles().add(styledText);
}
} else if (reader.getNodeName().equals("legend")) {
chartModel.getLegend().setVisible(true);
cssStyle = reader.getAttribute("style");
if (cssStyle != null) {
chartModel.getLegend().getStyle().setStyleString(cssStyle);
}
} else if (reader.getNodeName().equals("barPlot")
|| reader.getNodeName().equals("linePlot")
|| reader.getNodeName().equals("areaPlot")
|| reader.getNodeName().equals("piePlot")
|| reader.getNodeName().equals("dialPlot")
|| reader.getNodeName().equals("scatterPlot")) {
chartModel.setPlot(createPlot(reader));
}
reader.moveUp();
}
return chartModel;
}
public Object doUnmarshal(
final Object result,
final HierarchicalStreamReader reader,
final UnmarshallingContext context) {
final SeenFields seenFields = new SeenFields();
Iterator it = reader.getAttributeNames();
// Remember outermost Saveable encountered, for reporting below
if (result instanceof Saveable && context.get("Saveable") == null)
context.put("Saveable", result);
// Process attributes before recursing into child elements.
while (it.hasNext()) {
String attrAlias = (String) it.next();
String attrName = mapper.attributeForAlias(attrAlias);
Class classDefiningField = determineWhichClassDefinesField(reader);
boolean fieldExistsInClass = fieldDefinedInClass(result, attrName);
if (fieldExistsInClass) {
Field field = reflectionProvider.getField(result.getClass(), attrName);
SingleValueConverter converter =
mapper.getConverterFromAttribute(field.getDeclaringClass(), attrName, field.getType());
Class type = field.getType();
if (converter == null) {
converter = mapper.getConverterFromItemType(type);
}
if (converter != null) {
Object value = converter.fromString(reader.getAttribute(attrAlias));
if (type.isPrimitive()) {
type = Primitives.box(type);
}
if (value != null && !type.isAssignableFrom(value.getClass())) {
throw new ConversionException(
"Cannot convert type " + value.getClass().getName() + " to type " + type.getName());
}
reflectionProvider.writeField(result, attrName, value, classDefiningField);
seenFields.add(classDefiningField, attrName);
}
}
}
Map implicitCollectionsForCurrentObject = null;
while (reader.hasMoreChildren()) {
reader.moveDown();
try {
String fieldName = mapper.realMember(result.getClass(), reader.getNodeName());
boolean implicitCollectionHasSameName =
mapper.getImplicitCollectionDefForFieldName(result.getClass(), reader.getNodeName())
!= null;
Class classDefiningField = determineWhichClassDefinesField(reader);
boolean fieldExistsInClass =
!implicitCollectionHasSameName && fieldDefinedInClass(result, fieldName);
Class type =
determineType(reader, fieldExistsInClass, result, fieldName, classDefiningField);
final Object value;
if (fieldExistsInClass) {
Field field = reflectionProvider.getField(result.getClass(), fieldName);
value = unmarshalField(context, result, type, field);
// TODO the reflection provider should have returned the proper field in first place ....
Class definedType =
reflectionProvider.getFieldType(result, fieldName, classDefiningField);
if (!definedType.isPrimitive()) {
type = definedType;
}
} else {
value = context.convertAnother(result, type);
}
if (value != null && !type.isAssignableFrom(value.getClass())) {
LOGGER.warning(
"Cannot convert type " + value.getClass().getName() + " to type " + type.getName());
// behave as if we didn't see this element
} else {
if (fieldExistsInClass) {
reflectionProvider.writeField(result, fieldName, value, classDefiningField);
seenFields.add(classDefiningField, fieldName);
} else {
implicitCollectionsForCurrentObject =
writeValueToImplicitCollection(
context, value, implicitCollectionsForCurrentObject, result, fieldName);
}
}
} catch (NonExistentFieldException e) {
LOGGER.log(WARNING, "Skipping a non-existent field " + e.getFieldName(), e);
addErrorInContext(context, e);
} catch (CannotResolveClassException e) {
LOGGER.log(WARNING, "Skipping a non-existent type", e);
addErrorInContext(context, e);
} catch (LinkageError e) {
LOGGER.log(WARNING, "Failed to resolve a type", e);
addErrorInContext(context, e);
}
reader.moveUp();
}
// Report any class/field errors in Saveable objects
if (context.get("ReadError") != null && context.get("Saveable") == result) {
OldDataMonitor.report((Saveable) result, (ArrayList<Throwable>) context.get("ReadError"));
context.put("ReadError", null);
}
return result;
}
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
OrmEntity entity = new OrmEntity();
entity.setClassName(reader.getAttribute("class"));
return entity;
}
private Class determineWhichClassDefinesField(HierarchicalStreamReader reader) {
String definedIn = reader.getAttribute(mapper.aliasForAttribute("defined-in"));
return definedIn == null ? null : mapper.realClass(definedIn);
}