/*******************************************************************************
* Copyright (c) 2011, 2013 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Blaise Doughan - 2.4 - initial implementation
******************************************************************************/
package org.eclipse.persistence.internal.oxm.record.json;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import javax.xml.namespace.QName;
import org.eclipse.persistence.exceptions.XMLMarshalException;
import org.eclipse.persistence.internal.libraries.antlr.runtime.ANTLRInputStream;
import org.eclipse.persistence.internal.libraries.antlr.runtime.ANTLRReaderStream;
import org.eclipse.persistence.internal.libraries.antlr.runtime.CharStream;
import org.eclipse.persistence.internal.libraries.antlr.runtime.RecognitionException;
import org.eclipse.persistence.internal.libraries.antlr.runtime.TokenRewriteStream;
import org.eclipse.persistence.internal.libraries.antlr.runtime.TokenStream;
import org.eclipse.persistence.internal.libraries.antlr.runtime.tree.CommonTree;
import org.eclipse.persistence.internal.libraries.antlr.runtime.tree.Tree;
import org.eclipse.persistence.internal.oxm.CollectionGroupingElementNodeValue;
import org.eclipse.persistence.internal.oxm.Constants;
import org.eclipse.persistence.internal.oxm.ContainerValue;
import org.eclipse.persistence.internal.oxm.MappingNodeValue;
import org.eclipse.persistence.internal.oxm.MediaType;
import org.eclipse.persistence.internal.oxm.NamespaceResolver;
import org.eclipse.persistence.internal.oxm.NodeValue;
import org.eclipse.persistence.internal.oxm.Root;
import org.eclipse.persistence.internal.oxm.XMLConversionManager;
import org.eclipse.persistence.internal.oxm.XPathFragment;
import org.eclipse.persistence.internal.oxm.mappings.Field;
import org.eclipse.persistence.internal.oxm.record.AbstractUnmarshalRecord;
import org.eclipse.persistence.internal.oxm.record.SAXUnmarshallerHandler;
import org.eclipse.persistence.internal.oxm.record.UnmarshalRecord;
import org.eclipse.persistence.internal.oxm.XPathNode;
import org.eclipse.persistence.internal.oxm.record.XMLReaderAdapter;
import org.eclipse.persistence.internal.oxm.record.deferred.DeferredContentHandler;
import org.eclipse.persistence.oxm.mappings.nullpolicy.AbstractNullPolicy;
import org.eclipse.persistence.oxm.record.XMLRootRecord;
import org.xml.sax.ErrorHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import org.xml.sax.helpers.AttributesImpl;
public class JSONReader extends XMLReaderAdapter {
private static final String TRUE = "true";
private static final String FALSE = "false";
private Properties properties;
private String attributePrefix = null;
private NamespaceResolver namespaces = null;
private boolean includeRoot;
private String textWrapper;
private Class unmarshalClass;
private boolean isInCollection;
public JSONReader(String attrPrefix, NamespaceResolver nr, boolean namespaceAware, boolean includeRoot, Character namespaceSeparator, ErrorHandler errorHandler, String textWrapper){
this(attrPrefix, nr, namespaceAware, includeRoot, namespaceSeparator, errorHandler, textWrapper, null);
}
public JSONReader(String attrPrefix, NamespaceResolver nr, boolean namespaceAware, boolean includeRoot, Character namespaceSeparator, ErrorHandler errorHandler, String textWrapper, Class unmarshalClass){
this.attributePrefix = attrPrefix;
if(attributePrefix == Constants.EMPTY_STRING){
attributePrefix = null;
}
namespaces = nr;
this.namespaceAware = namespaceAware;
if(namespaceSeparator == null){
this.namespaceSeparator = Constants.DOT;
}else{
this.namespaceSeparator = namespaceSeparator;
}
this.includeRoot = includeRoot;
this.setErrorHandler(errorHandler);
this.textWrapper = textWrapper;
this.unmarshalClass = unmarshalClass;
}
private JSONAttributes attributes = new JSONAttributes();
@Override
public void parse(InputSource input) throws IOException, SAXException {
try {
CharStream charStream;
InputStream inputStream = null;
if(null != input.getByteStream()) {
charStream = new ANTLRInputStream(input.getByteStream());
} else if (null != input.getCharacterStream()){
charStream = new ANTLRReaderStream(input.getCharacterStream());
} else {
try {
URL url = new URL(input.getSystemId());
inputStream = url.openStream();
} catch(MalformedURLException malformedURLException) {
try {
inputStream = new FileInputStream(input.getSystemId());
} catch(FileNotFoundException fileNotFoundException) {
throw malformedURLException;
}
}
charStream = new ANTLRInputStream(inputStream);
}
JSONLexer lexer = new JSONLexer(charStream);
TokenRewriteStream tokens = new TokenRewriteStream(lexer);
ExtendedJSONParser parser = new ExtendedJSONParser(tokens, input, getErrorHandler());
CommonTree commonTree = (CommonTree) parser.message().getTree();
parseRoot(commonTree);
if(null != inputStream) {
inputStream.close();
}
} catch(RecognitionException e) {
SAXParseException saxParseException = new SAXParseException(e.getLocalizedMessage(), input.getPublicId(), input.getSystemId(), e.line, e.index, e);
getErrorHandler().fatalError(saxParseException);
} catch(SAXExceptionWrapper e){
throw e.getCause();
}
}
@Override
public void parse(String systemId) {
try {
parse(new InputSource(systemId));
} catch (IOException e) {
throw XMLMarshalException.unmarshalException(e);
} catch (SAXException e) {
throw XMLMarshalException.unmarshalException(e);
}
}
private void parseRoot(Tree tree) throws SAXException {
if(namespaces != null){
Map <String, String> namespacePairs = namespaces.getPrefixesToNamespaces();
Iterator<String> keys = namespacePairs.keySet().iterator();
while(keys.hasNext()){
String nextKey = keys.next();
contentHandler.startPrefixMapping(nextKey, namespacePairs.get(nextKey));
}
}
if(tree.getType() == JSONLexer.OBJECT){
contentHandler.startDocument();
int children = tree.getChildCount();
if(children == 0 && unmarshalClass == null){
return;
}
if(includeRoot){
parse((CommonTree) tree.getChild(0));
}else{
if(children == 1){
CommonTree ct = (CommonTree) tree.getChild(0);
if(ct != null && ct.getType() == JSONLexer.NULL){
contentHandler.setNil(true);
}
contentHandler.startElement(Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, attributes.setTree(tree, attributePrefix, namespaces, namespaceSeparator, namespaceAware));
parse(ct);
contentHandler.endElement(Constants.EMPTY_STRING,Constants.EMPTY_STRING, null);
}else{
contentHandler.startElement(Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, attributes.setTree(tree, attributePrefix, namespaces, namespaceSeparator, namespaceAware));
for(int x=0, size=children; x<size; x++) {
parse((CommonTree) tree.getChild(x));
}
contentHandler.endElement(Constants.EMPTY_STRING,Constants.EMPTY_STRING, null);
}
}
contentHandler.endDocument();
} else if(tree.getType() == JSONLexer.ARRAY){
SAXUnmarshallerHandler rootContentHandler = null;
if(getContentHandler() instanceof SAXUnmarshallerHandler) {
rootContentHandler = (SAXUnmarshallerHandler)getContentHandler();
}
int size = tree.getChildCount();
List list = new ArrayList(size);
for(int x=0; x<size; x++) {
parseRoot(tree.getChild(x));
if(getContentHandler() instanceof SAXUnmarshallerHandler) {
SAXUnmarshallerHandler saxUnmarshallerHandler = (SAXUnmarshallerHandler) contentHandler;
list.add(saxUnmarshallerHandler.getObject());
saxUnmarshallerHandler.setObject(null);
} else if(getContentHandler() instanceof UnmarshalRecord) {
UnmarshalRecord unmarshalRecord = (UnmarshalRecord) contentHandler;
Object unmarshalledObject = unmarshalRecord.getCurrentObject();
if(includeRoot && unmarshalClass != null){
if(!(unmarshalledObject instanceof Root)) {
Root xmlRoot = unmarshalRecord.createRoot();
xmlRoot.setNamespaceURI(unmarshalRecord.getRootElementNamespaceUri());
xmlRoot.setLocalName(unmarshalRecord.getLocalName());
xmlRoot.setObject(unmarshalledObject);
unmarshalledObject = xmlRoot;
}
}
list.add(unmarshalledObject);
unmarshalRecord.setCurrentObject(null);
unmarshalRecord.setRootElementName(null);
unmarshalRecord.setLocalName(null);
}
}
if(getContentHandler() instanceof SAXUnmarshallerHandler) {
((SAXUnmarshallerHandler) getContentHandler()).setObject(list);
} else if(getContentHandler() instanceof UnmarshalRecord) {
((UnmarshalRecord) getContentHandler()).setCurrentObject(list);
((UnmarshalRecord) getContentHandler()).setRootElementName(Constants.EMPTY_STRING);
((UnmarshalRecord) getContentHandler()).setLocalName(Constants.EMPTY_STRING);
if(rootContentHandler != null){
rootContentHandler.setObject(list);
}
}
} else {
getContentHandler().startDocument();
parse(tree);
}
}
private void parse(Tree tree) throws SAXException {
if(tree == null){
return;
}
switch(tree.getType()) {
case JSONLexer.PAIR: {
Tree valueTree = tree.getChild(1);
if(valueTree.getType() == JSONLexer.ARRAY) {
parse(valueTree);
} else {
Tree stringTree = tree.getChild(0);
String qualifiedName = stringTree.getText().substring(1, stringTree.getText().length() - 1);
String localName = qualifiedName;
if(attributePrefix != null && qualifiedName.startsWith(attributePrefix)){
break;
}
String uri = Constants.EMPTY_STRING;
if(namespaceAware && namespaces != null){
if(localName.length() > 2){
int nsIndex = localName.indexOf(namespaceSeparator, 1);
String prefix = Constants.EMPTY_STRING;
if(nsIndex > -1){
prefix = localName.substring(0, nsIndex);
}
uri = namespaces.resolveNamespacePrefix(prefix);
if(uri == null){
uri = namespaces.getDefaultNamespaceURI();
}else{
localName = localName.substring(nsIndex + 1);
}
if(localName.equals(Constants.SCHEMA_TYPE_ATTRIBUTE) && uri != null && uri.equals(javax.xml.XMLConstants.W3C_XML_SCHEMA_INSTANCE_NS_URI)){
break;
}
}else{
uri = namespaces.getDefaultNamespaceURI();
}
}
if(contentHandler instanceof XMLRootRecord || contentHandler instanceof DeferredContentHandler){
//if its not namespaceAware don't report the "type" child as it is will be read by the xsi:type lookup
if(!namespaceAware && localName.equals(Constants.SCHEMA_TYPE_ATTRIBUTE)){
break;
}
if(textWrapper != null && textWrapper.equals(localName)){
parse(valueTree);
break;
}
}else if(contentHandler instanceof UnmarshalRecord && ((UnmarshalRecord)contentHandler).getXPathNode() != null){
if(!namespaceAware && localName.equals(Constants.SCHEMA_TYPE_ATTRIBUTE) && !((UnmarshalRecord)contentHandler).getXPathNode().hasTypeChild()){
break;
}
boolean isTextValue = isTextValue(localName);
if(isTextValue){
parse(valueTree);
break;
}
NodeValue nv = ((UnmarshalRecord)contentHandler).getAttributeChildNodeValue(uri, localName);
if(attributePrefix == null && nv !=null ){
break;
}
}
if(valueTree != null && valueTree.getType() == JSONLexer.NULL){
contentHandler.setNil(true);
}
contentHandler.startElement(uri, localName, localName, attributes.setTree(valueTree, attributePrefix, namespaces, namespaceSeparator, namespaceAware));
parse(valueTree);
contentHandler.endElement(uri, localName, localName);
}
break;
}
case JSONLexer.STRING: {
String string = string(tree.getChild(0).getText());
contentHandler.characters(string);
break;
}
case JSONLexer.NUMBER: {
contentHandler.characters(tree.getChild(0).getText());
break;
}
case JSONLexer.TRUE: {
contentHandler.characters(TRUE);
break;
}
case JSONLexer.FALSE: {
contentHandler.characters(FALSE);
break;
}
case JSONLexer.NULL: {
break;
}
case JSONLexer.ARRAY: {
Tree parentStringTree = tree.getParent().getChild(0);
String parentLocalName = parentStringTree.getText().substring(1, parentStringTree.getText().length() - 1);
if(attributePrefix != null && parentLocalName.startsWith(attributePrefix)){
break;
}
String uri = Constants.EMPTY_STRING;
if(namespaceAware && namespaces != null){
if(parentLocalName.length() > 2){
int nsIndex = parentLocalName.indexOf(namespaceSeparator, 1);
if(nsIndex > -1){
String prefix = parentLocalName.substring(0, nsIndex);
uri = namespaces.resolveNamespacePrefix(prefix);
}
if(uri == null){
uri = namespaces.getDefaultNamespaceURI();
}else{
parentLocalName = parentLocalName.substring(nsIndex + 1);
}
}else{
uri = namespaces.getDefaultNamespaceURI();
}
}
boolean isTextValue = false;
int size = tree.getChildCount();
if(size == 0){
if(contentHandler instanceof UnmarshalRecord){
isTextValue = isTextValue(parentLocalName);
UnmarshalRecord ur = (UnmarshalRecord)contentHandler;
XPathNode node = ur.getNonAttributeXPathNode(uri, parentLocalName, parentLocalName, null);
if(node != null){
NodeValue nv = node.getNodeValue();
if(nv == null && node.getTextNode() != null){
nv = node.getTextNode().getUnmarshalNodeValue();
}
if(nv != null && nv.isContainerValue()){
ur.getContainerInstance(((ContainerValue)nv));
}
}
}
}
startCollection();
XPathFragment groupingXPathFragment = null;
XPathFragment itemXPathFragment = null;
if(contentHandler instanceof UnmarshalRecord) {
isTextValue = isTextValue(parentLocalName);
UnmarshalRecord unmarshalRecord = (UnmarshalRecord) contentHandler;
if(unmarshalRecord.getUnmarshaller().isWrapperAsCollectionName()) {
XPathNode unmarshalRecordXPathNode = unmarshalRecord.getXPathNode();
if(null != unmarshalRecordXPathNode) {
XPathFragment currentFragment = new XPathFragment();
currentFragment.setLocalName(parentLocalName);
currentFragment.setNamespaceURI(uri);
currentFragment.setNamespaceAware(namespaceAware);
XPathNode groupingXPathNode = unmarshalRecordXPathNode.getNonAttributeChildrenMap().get(currentFragment);
if(groupingXPathNode != null) {
if(groupingXPathNode.getUnmarshalNodeValue() instanceof CollectionGroupingElementNodeValue) {
groupingXPathFragment = groupingXPathNode.getXPathFragment();
contentHandler.startElement(uri, parentLocalName, parentLocalName, new AttributesImpl());
XPathNode itemXPathNode = groupingXPathNode.getNonAttributeChildren().get(0);
itemXPathFragment = itemXPathNode.getXPathFragment();
} else if(groupingXPathNode.getUnmarshalNodeValue() == null) {
XPathNode itemXPathNode = groupingXPathNode.getNonAttributeChildren().get(0);
if(itemXPathNode != null) {
if(((MappingNodeValue)itemXPathNode.getUnmarshalNodeValue()).isContainerValue()) {
groupingXPathFragment = groupingXPathNode.getXPathFragment();
contentHandler.startElement(uri, parentLocalName, parentLocalName, new AttributesImpl());
itemXPathFragment = itemXPathNode.getXPathFragment();
}
}
}
}
}
}
}
for(int x=0; x<size; x++) {
CommonTree nextChildTree = (CommonTree) tree.getChild(x);
if(nextChildTree.getType() == JSONLexer.NULL){
((UnmarshalRecord)contentHandler).setNil(true);
}
if(!isTextValue){
if(null != itemXPathFragment) {
contentHandler.startElement(itemXPathFragment.getNamespaceURI(), itemXPathFragment.getLocalName(), itemXPathFragment.getLocalName(), attributes.setTree(nextChildTree, attributePrefix, namespaces, namespaceSeparator, namespaceAware));
} else {
contentHandler.startElement(uri, parentLocalName, parentLocalName, attributes.setTree(nextChildTree, attributePrefix, namespaces, namespaceSeparator, namespaceAware));
}
}
parse(nextChildTree);
if(!isTextValue){
if(null != itemXPathFragment) {
contentHandler.endElement(uri, itemXPathFragment.getLocalName(), itemXPathFragment.getLocalName());
} else {
contentHandler.endElement(uri, parentLocalName, parentLocalName);
}
}
}
if(null != groupingXPathFragment) {
contentHandler.endElement(uri, groupingXPathFragment.getLocalName(), groupingXPathFragment.getLocalName());
}
endCollection();
break;
}
default: {
for(int x=0, size=tree.getChildCount(); x<size; x++) {
parse((CommonTree) tree.getChild(x));
}
}
}
}
public boolean isNullRepresentedByXsiNil(AbstractNullPolicy nullPolicy){
return true;
}
private void startCollection(){
isInCollection = true;
}
private void endCollection(){
isInCollection = false;
}
public boolean isInCollection(){
return isInCollection;
}
private boolean isTextValue(String localName){
XPathNode currentNode = ((UnmarshalRecord)contentHandler).getXPathNode();
if(currentNode == null){
return textWrapper != null && textWrapper.equals(localName);
}
return((currentNode.getNonAttributeChildrenMap() == null
|| currentNode.getNonAttributeChildrenMap().size() ==0
|| (currentNode.getNonAttributeChildrenMap().size() == 1 && currentNode.getTextNode() != null))
&& textWrapper != null && textWrapper.equals(localName));
}
private static String string(String string) {
string = string.substring(1, string.length()-1);
string = string.replace("\r\n", "\n");
String returnString = "";
int slashIndex = string.indexOf('\\');
if(slashIndex == -1){
return string;
}
int position = 0;
while(slashIndex > -1){
String subString = string.substring(position, slashIndex);
returnString += subString;
position = slashIndex;
char nextChar = string.charAt(slashIndex + 1);
switch (nextChar){
case 'b':{
position += 2;
returnString += '\b';
break;
}
case 'r':{
position += 2;
returnString += '\r';
break;
}
case 'f':{
position += 2;
returnString += '\f';
break;
}
case 'n':{
position += 2;
returnString += '\n';
break;
}
case 't': {
position += 2;
returnString += '\t';
break;
}
case '"': {
position += 2;
returnString += '"';
break;
}
case '\\':{
position += 2;
returnString += '\\';
break;
}
case '/':{
position += 2;
returnString += '/';
break;
}
case 'u':{
position += 6;
String hexValue = string.substring(slashIndex+2, slashIndex+6);
returnString += Character.toString((char)Integer.parseInt(hexValue, 16));
break;
}
}
slashIndex = string.indexOf('\\', position);
}
//If there is content after the last '\' then append it.
if(position < string.length()){
String subString = string.substring(position, string.length());
returnString += subString;
}
return returnString;
}
/**
* INTERNAL:
* @since 2.4
*/
@Override
public Object convertValueBasedOnSchemaType(Field xmlField, Object value, XMLConversionManager xmlConversionManager, AbstractUnmarshalRecord record) {
if (xmlField.getSchemaType() != null) {
if(Constants.QNAME_QNAME.equals(xmlField.getSchemaType())){
String stringValue = (String)value;
int indexOpen = stringValue.indexOf('{');
int indexClose = stringValue.indexOf('}');
String uri = null;
String localName = null;
if(indexOpen > -1 && indexClose > -1){
uri = stringValue.substring(indexOpen+1, indexClose);
localName = stringValue.substring(indexClose + 1);
}else{
QName obj = (QName)xmlField.convertValueBasedOnSchemaType(stringValue, xmlConversionManager, record);
localName = obj.getLocalPart();
uri = obj.getNamespaceURI();
}
if(uri != null){
return new QName(uri, localName);
}else{
return new QName(localName);
}
}else{
Class fieldType = xmlField.getType();
if (fieldType == null) {
fieldType = xmlField.getJavaClass(xmlField.getSchemaType());
}
return xmlConversionManager.convertObject(value, fieldType, xmlField.getSchemaType());
}
}
return value;
}
/**
* INTERNAL:
* The MediaType associated with this reader
* @return
*/
@Override
public MediaType getMediaType(){
return Constants.APPLICATION_JSON;
}
private static class JSONAttributes extends IndexedAttributeList {
private Tree tree;
private String attributePrefix;
private char namespaceSeparator;
private NamespaceResolver namespaces;
private boolean namespaceAware;
public JSONAttributes setTree(Tree tree, String attributePrefix, NamespaceResolver nr, char namespaceSeparator, boolean namespaceAware) {
reset();
this.tree = tree;
this.attributePrefix = attributePrefix;
this.namespaces = nr;
this.namespaceSeparator = namespaceSeparator;
this.namespaceAware = namespaceAware;
return this;
}
private void addSimpleAttribute(List attributes, String uri, String attributeLocalName,Tree childValueTree){
switch(childValueTree.getType()) {
case JSONLexer.STRING: {
String stringValue = JSONReader.string(childValueTree.getChild(0).getText());
attributes.add(new Attribute(uri, attributeLocalName, attributeLocalName, stringValue));
break;
}
case JSONLexer.NUMBER: {
attributes.add(new Attribute(uri, attributeLocalName, attributeLocalName, childValueTree.getChild(0).getText()));
break;
}
case JSONLexer.TRUE: {
attributes.add(new Attribute(uri, attributeLocalName, attributeLocalName, TRUE));
break;
}
case JSONLexer.FALSE: {
attributes.add(new Attribute(uri, attributeLocalName, attributeLocalName, FALSE));
break;
}
case JSONLexer.NULL: {
break;
}
}
}
public int getIndex(String uri, String localName) {
if(null == localName) {
return -1;
}
int index = 0;
for(Attribute attribute : attributes()) {
if(namespaceAware){
QName testQName = new QName(uri, localName);
if(localName.equals(attribute.getLocalName()) && uri.equals(attribute.getUri())){
return index;
}
}else{
if(attribute.getName().equals(localName)) {
return index;
}
}
index++;
}
return -1;
}
@Override
protected Attribute[] attributes() {
if(null == attributes) {
if(tree.getType() == JSONLexer.NULL){
return NO_ATTRIBUTES;
}
if(tree.getType() == JSONLexer.OBJECT) {
ArrayList<Attribute> attributesList = new ArrayList<Attribute>(tree.getChildCount());
for(int x=0; x<tree.getChildCount(); x++) {
Tree childTree = tree.getChild(x);
String attributeLocalName = childTree.getChild(0).getText().substring(1, childTree.getChild(0).getText().length() - 1);
if(attributePrefix != null){
if(attributeLocalName.startsWith(attributePrefix)){
attributeLocalName = attributeLocalName.substring(attributePrefix.length());
}else{
break;
}
}
String uri = Constants.EMPTY_STRING;
if(namespaceAware && namespaces != null){
if(attributeLocalName.length() > 2){
String prefix = Constants.EMPTY_STRING;
int nsIndex = attributeLocalName.indexOf(namespaceSeparator, 1);
if(nsIndex > -1){
prefix = attributeLocalName.substring(0, nsIndex);
}
uri = namespaces.resolveNamespacePrefix(prefix);
if(uri == null){
uri = namespaces.getDefaultNamespaceURI();
}else{
attributeLocalName = attributeLocalName.substring(nsIndex + 1);
}
}else{
uri = namespaces.getDefaultNamespaceURI();
}
}
Tree childValueTree = childTree.getChild(1);
if(childValueTree.getType() == JSONLexer.ARRAY){
int size = childValueTree.getChildCount();
if(size == 0){
attributesList.add(new Attribute(uri, attributeLocalName, attributeLocalName, ""));
}
for(int y=0; y<size; y++) {
CommonTree nextChildTree = (CommonTree) childValueTree.getChild(y);
addSimpleAttribute(attributesList, uri, attributeLocalName, nextChildTree);
}
}else{
addSimpleAttribute(attributesList, uri, attributeLocalName, childValueTree);
}
}
attributes = attributesList.toArray(new Attribute[attributesList.size()]);
} else {
attributes = NO_ATTRIBUTES;
}
}
return attributes;
}
}
/**
* JSONParser is a generated class and maybe regenerated.
* this is a subclass to throw errors that may occur instead of just logging them.
*/
private static class ExtendedJSONParser extends JSONParser {
private InputSource inputSource;
private ErrorHandler errorHandler;
public ExtendedJSONParser(TokenStream input, InputSource inputSource, ErrorHandler errorHandler) {
super(input);
this.inputSource = inputSource;
this.errorHandler = errorHandler;
}
public void displayRecognitionError(String[] tokenNames,RecognitionException re){
super.displayRecognitionError(tokenNames, re);
SAXParseException saxParseException = new SAXParseException(re.getLocalizedMessage(), inputSource.getPublicId(),inputSource.getSystemId(), re.line, re.index, re);
try {
errorHandler.fatalError(saxParseException);
} catch (SAXException e) {
throw new SAXExceptionWrapper(e);
}
}
}
//Runtime exception to wrap a SAXException
private static class SAXExceptionWrapper extends RuntimeException {
SAXExceptionWrapper(SAXException e){
super(e);
}
public SAXException getCause() {
return (SAXException)super.getCause();
}
}
}