package com.ontotext.ordi.wsmo4rdf.remote.client;
   
   import static com.ontotext.ordi.wsmo4rdf.remote.Constants.SRX_NAMESPACE;
   
   import java.io.ByteArrayInputStream;
   import java.io.IOException;
   import java.io.UnsupportedEncodingException;
   import java.math.BigDecimal;
   import java.util.LinkedList;
  import java.util.List;
  import java.util.Set;
  
  import javanet.staxutils.SimpleNamespaceContext;
  
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.parsers.ParserConfigurationException;
  import javax.xml.xpath.XPath;
  import javax.xml.xpath.XPathConstants;
  import javax.xml.xpath.XPathExpression;
  import javax.xml.xpath.XPathExpressionException;
  import javax.xml.xpath.XPathFactory;
  
  import org.apache.commons.lang.SerializationException;
  import org.apache.log4j.Logger;
  import org.omwg.ontology.Ontology;
  import org.openrdf.query.MalformedQueryException;
  import org.w3c.dom.Attr;
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  import org.w3c.dom.NodeList;
  import org.wsmo.common.Entity;
  import org.wsmo.common.IRI;
  import org.wsmo.common.Identifier;
  import org.wsmo.common.exception.SynchronisationException;
  import org.wsmo.factory.DataFactory;
  import org.wsmo.factory.Factory;
  import org.wsmo.factory.LogicalExpressionFactory;
  import org.wsmo.factory.WsmoFactory;
  import org.wsmo.mediator.Mediator;
  import org.wsmo.service.Goal;
  import org.wsmo.service.WebService;
  import org.xml.sax.SAXException;
  
  import com.ontotext.ordi.DataSource;
  import com.ontotext.ordi.IsolationLevel;
  import com.ontotext.ordi.exception.ORDIException;
  import com.ontotext.ordi.exception.ORDIWarning;
  import com.ontotext.ordi.wsmo4rdf.QueryResultListener;
  import com.ontotext.ordi.wsmo4rdf.WsmoConnection;
  import com.ontotext.ordi.wsmo4rdf.remote.DOMUtil;
  import com.ontotext.ordi.wsmo4rdf.remote.Marshaller;
  import com.ontotext.ordi.wsmo4rdf.remote.client.conn.MalformedQueryException_Exception;
  import com.ontotext.ordi.wsmo4rdf.remote.client.conn.NonExistingEntryException_Exception;
  import com.ontotext.ordi.wsmo4rdf.remote.client.conn.ORDIException_Exception;
  import com.ontotext.ordi.wsmo4rdf.remote.client.conn.OrdiConfigurationException_Exception;
  import com.ontotext.ordi.wsmo4rdf.remote.client.conn.SynchronisationException_Exception;
  import com.ontotext.ordi.wsmo4rdf.remote.client.conn.UnmarshalException_Exception;
  import com.ontotext.ordi.wsmo4rdf.remote.exception.UnmarshalException;
  
  public class RemoteWsmoConnection implements WsmoConnection {
  
      private final static Logger logger = Logger
  	    .getLogger(RemoteWsmoConnection.class);
  
      private final int id;
      private final RemoteWsmo4rdfGate gate;
      private final WsmoFactory wsmoFactory;
      private final LogicalExpressionFactory leFactory;
      private final DataFactory dtFactory;
  
      public RemoteWsmoConnection(int conId, RemoteWsmo4rdfGate gate) {
  	this.id = conId;
  	this.gate = gate;
  
  	this.wsmoFactory = Factory.createWsmoFactory(null);
  	this.leFactory = Factory.createLogicalExpressionFactory(null);
  	this.dtFactory = Factory.createDataFactory(null);
      }
  
      @Override
      public void finalize() {
  	try {
  	    logger.debug("GarbageCollector requested closing this(ID="
  		    + this.id + ") connection.");
  	    close();
  	} catch (ORDIException e) {
  	    logger.warn("Trying to close "
  		    + RemoteWsmoConnection.class.getName() + "with ID="
  		    + this.id + " failed.");
  	    e.printStackTrace();
  	}
      }
  
      int getId() {
  	return this.id;
      }
  
      public void evaluate(String query, QueryResultListener listener)
  	    throws MalformedQueryException {
 	String sxr = null;
 	try {
 	    sxr = this.gate.getConnectionService().evaluate(this.id, query);
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "evaluate");
 	    e.printStackTrace();
 	    return;
 	} catch (OrdiConfigurationException_Exception e) {
 	    logger
 		    .error("Invalid ORDI configuration on the server. Aborting query evaluation.");
 	    e.printStackTrace();
 	    return;
 	} catch (MalformedQueryException_Exception e) {
 	    // TODO (mihail): Use JAXB to map this to the right exception
 	    throw new MalformedQueryException(e);
 	}
 
 	Document resp = parseXmlFromResponseString(sxr);
 	if (resp == null) {
 	    logger
 		    .error("Cannot parse SPARQL XML Response. Aborting SPARQL query evaluation.");
 	    return;
 	}
 	// TODO (mihail): Validate result according to XMLSchema, а не на око
 	System.out.println(DOMUtil.convert(resp).toString());
 
 	XPathFactory factory = XPathFactory.newInstance();
 	XPath xpath = factory.newXPath();
 
 	SimpleNamespaceContext nsContext = new SimpleNamespaceContext();
 	nsContext.setPrefix("xsr", SRX_NAMESPACE);
 
 	xpath.setNamespaceContext(nsContext);
 
 	XPathExpression expr = null;
 	NodeList xpathResult = null;
 	try {
 	    expr = xpath.compile("//xsr:sparql/xsr:results/xsr:result");
 	    xpathResult = (NodeList) expr
 		    .evaluate(resp, XPathConstants.NODESET);
 	} catch (XPathExpressionException e) {
 	    assert (false);
 	}
 	assert (expr != null);
 	assert (xpathResult != null);
 
 	for (int i = 0; i < xpathResult.getLength(); i++) {
 	    Element resultElement = (Element) xpathResult.item(i);
 	    Element bindingElement = (Element) resultElement
 		    .getElementsByTagNameNS(SRX_NAMESPACE, "binding").item(0);
 
 	    String variableName = bindingElement.getAttribute("name");
 
 	    NodeList dataElementsList = bindingElement.getChildNodes();
 	    Element dataElement = null;
 	    int j;
 	    for (j = 0; j < dataElementsList.getLength()
 		    && !(dataElementsList.item(j) instanceof Element); j++) {
 	    }
 	    dataElement = (Element) dataElementsList.item(j);
 	    assert (dataElement != null); // Valid result document must always
 					    // contain child of <binding>
 					    // element
 
 	    String dataElementName = dataElement.getLocalName();
 	    if (dataElementName.equalsIgnoreCase("uri")) {
 		listener.nextBinding(variableName, this.wsmoFactory
 			.createIRI(dataElement.getTextContent()));
 	    } else if (dataElementName.equalsIgnoreCase("bnode")) {
 		listener.nextBinding(variableName, this.wsmoFactory
 			.createAnonymousID());
 	    } else if (dataElementName.equalsIgnoreCase("literal")) {
 		Attr datatypeAttribute = dataElement.getAttributeNodeNS(
 			SRX_NAMESPACE, "datatype");
 		if (datatypeAttribute != null) {
 		    // has datatype element
 		    String dtContent = datatypeAttribute.getValue();
 		    if (dtContent
 			    .equals("http://www.wsmo.org/wsml/wsml-syntax#variable")) {
 			listener.nextBinding(variableName, this.leFactory
 				.createVariable(dataElement.getTextContent()));
 		    }
 		    // other datatypes in the future
 		} else {
 		    String value = dataElement.getTextContent();
 		    try {
 			double pValue = Double.valueOf(value);
 			BigDecimal objValue = BigDecimal.valueOf(pValue);
 			listener.nextBinding(variableName, this.dtFactory
 				.createWsmlDecimal(objValue));
 		    } catch (NumberFormatException nfe1) {
 			try {
 			    @SuppressWarnings("unused")
 			    Integer objValue = Integer.valueOf(value);
 			    listener.nextBinding(variableName, this.dtFactory
 				    .createWsmlInteger(value));
 			} catch (NumberFormatException nfe2) {
 			    listener.nextBinding(variableName, this.dtFactory
 				    .createWsmlString(value));
 			}
 		    }
 
 		}
 
 	    }
 
 	}
     }
 
     public String getDescription() {
 	String result = null;
 	try {
 	    result = this.gate.getConnectionService().getDescription(this.id);
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "getDescription");
 	    e.printStackTrace();
 	}
 	return result;
     }
 
     public void setDescription(String desc) {
 	try {
 	    this.gate.getConnectionService().setDescription(this.id, desc);
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "setDescription");
 	    e.printStackTrace();
 	    return;
 	}
     }
 
     public String getVersion() throws SynchronisationException {
 	String version = null;
 	try {
 	    version = this.gate.getConnectionService().getVersion(this.id);
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "getVersion");
 	    e.printStackTrace();
 	} catch (SynchronisationException_Exception e) {
 	    throw new SynchronisationException(e);
 	}
 	return version;
     }
 
     public void addOntology(Ontology ont) throws SynchronisationException {
 	try {
 	    this.gate.getConnectionService().addOntology(this.id,
 		    Marshaller.marshal(ont));
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "addOntology");
 	    e.printStackTrace();
 	    return;
 	} catch (SynchronisationException_Exception e) {
 	    throw new SynchronisationException(e);
 	} catch (UnmarshalException_Exception e) {
 	    logException(e, "addOntology");
 	    e.printStackTrace();
 	    return;
 	}
     }
 
     public void deleteOntology(IRI id) throws SynchronisationException {
 	try {
 	    this.gate.getConnectionService().deleteOntology(this.id,
 		    id.toString());
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "deleteOntology");
 	    e.printStackTrace();
 	    return;
 	} catch (SynchronisationException_Exception e) {
 	    throw new SynchronisationException(e);
 	}
     }
 
     public Ontology getOntology(IRI id) throws SynchronisationException {
 	Ontology ontology = null;
 	String ontoString = null;
 	try {
 	    ontoString = this.gate.getConnectionService().getOntology(this.id,
 		    id.toString());
 	    ontology = Marshaller.unmarshalOntology(ontoString);
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "getOntology");
 	    e.printStackTrace();
 	    return null;
 	} catch (SynchronisationException_Exception e) {
 	    throw new SynchronisationException(e);
 	} catch (UnmarshalException e) {
 	    logException(e, "getOntology");
 	    e.printStackTrace();
 	    return null;
 	}
 	return ontology;
     }
 
     public void saveOntology(Ontology ont) throws SynchronisationException {
 	try {
 	    this.gate.getConnectionService().saveOntology(this.id,
 		    Marshaller.marshal(ont));
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "saveOntology");
 	    e.printStackTrace();
 	    return;
 	} catch (SynchronisationException_Exception e) {
 	    throw new SynchronisationException(e);
 	} catch (UnmarshalException_Exception e) {
 	    logException(e, "saveOntology");
 	    e.printStackTrace();
 	    return;
 	}
     }
 
     public List<IRI> listOntologies() throws SynchronisationException {
 	List<String> ontoIriStringList = null;
 	try {
 	    ontoIriStringList = this.gate.getConnectionService()
 		    .listOntologies(this.id);
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "listOntologies");
 	    e.printStackTrace();
 	    return null;
 	} catch (SynchronisationException_Exception e) {
 	    throw new SynchronisationException(e);
 	}
 	assert (ontoIriStringList != null);
 	List<IRI> result = new LinkedList<IRI>();
 	for (String iriString : ontoIriStringList) {
 	    result.add(Marshaller.newIRI(iriString));
 	}
 	return result;
     }
 
     public void addGoal(Goal goal) throws SynchronisationException {
 
 	try {
 	    this.gate.getConnectionService().addGoal(this.id,
 		    Marshaller.marshal(goal));
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "addGoal");
 	} catch (UnmarshalException_Exception e) {
 	    logException(e, "addGoal");
 	    e.printStackTrace();
 	} catch (SynchronisationException_Exception e) {
 	    throw new SynchronisationException(e);
 	}
     }
 
     public void saveGoal(Goal goal) throws SynchronisationException {
 	try {
 	    this.gate.getConnectionService().saveGoal(this.id,
 		    Marshaller.marshal(goal));
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "saveGoal");
 	} catch (UnmarshalException_Exception e) {
 	    logException(e, "saveGoal");
 	} catch (SynchronisationException_Exception e) {
 	    throw new SerializationException(e);
 	}
 
     }
 
     public Goal getGoal(IRI id) throws SynchronisationException {
 	String goalAsString = null;
 	try {
 	    goalAsString = this.gate.getConnectionService().getGoal(this.id,
 		    id.toString());
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "getGoal");
 	} catch (SynchronisationException_Exception e) {
 	    throw new SynchronisationException(e);
 	}
 	Goal goal = null;
 	try {
 	    goal = Marshaller.unmarshalGoal(goalAsString);
 	} catch (UnmarshalException e) {
 	    logException(e, "getGoal");
 	    e.printStackTrace();
 	    return null;
 	}
 	return goal;
     }
 
     public void deleteGoal(IRI id) throws SynchronisationException {
 	try {
 	    this.gate.getConnectionService().deleteGoal(this.id, id.toString());
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "deleteGoal");
 	} catch (SynchronisationException_Exception e) {
 	    throw new SynchronisationException(e);
 	}
     }
 
     public List<IRI> listGoals() throws SynchronisationException {
 	List<String> goalIriStringList = null;
 	try {
 	    goalIriStringList = this.gate.getConnectionService().listGoals(
 		    this.id);
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "listGoals");
 	    e.printStackTrace();
 	    return null;
 	} catch (SynchronisationException_Exception e) {
 	    throw new SynchronisationException(e);
 	}
 	assert (goalIriStringList != null);
 	List<IRI> result = new LinkedList<IRI>();
 	for (String iriString : goalIriStringList) {
 	    result.add(Marshaller.newIRI(iriString));
 	}
 	return result;
     }
 
     public void addMediator(Mediator med) throws SynchronisationException {
 	try {
 	    this.gate.getConnectionService().addMediator(this.id,
 		    Marshaller.marshal(med));
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "addMediator");
 	} catch (UnmarshalException_Exception e) {
 	    logException(e, "addMediator");
 	    e.printStackTrace();
 	} catch (SynchronisationException_Exception e) {
 	    throw new SynchronisationException(e);
 	}
     }
 
     public void addWebService(WebService ws) throws SynchronisationException {
 	try {
 	    this.gate.getConnectionService().addWebService(this.id,
 		    Marshaller.marshal(ws));
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "addWebService");
 	} catch (UnmarshalException_Exception e) {
 	    logException(e, "addWebService");
 	    e.printStackTrace();
 	} catch (SynchronisationException_Exception e) {
 	    throw new SynchronisationException(e);
 	}
     }
 
     public void deleteMediator(IRI id) throws SynchronisationException {
 	try {
 	    this.gate.getConnectionService().deleteMediator(this.id,
 		    id.toString());
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "deleteMediator");
 	    e.printStackTrace();
 	    return;
 	} catch (SynchronisationException_Exception e) {
 	    throw new SynchronisationException(e);
 	}
     }
 
     public void deleteWebService(IRI id) throws SynchronisationException {
 	try {
 	    this.gate.getConnectionService().deleteWebService(this.id,
 		    id.toString());
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "deleteWebService");
 	    e.printStackTrace();
 	    return;
 	} catch (SynchronisationException_Exception e) {
 	    throw new SynchronisationException(e);
 	}
     }
 
     public Mediator getMediator(IRI id) throws SynchronisationException {
 	String mediatorAsString = null;
 	try {
 	    mediatorAsString = this.gate.getConnectionService().getMediator(this.id,
 		    id.toString());
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "getMediator");
 	} catch (SynchronisationException_Exception e) {
 	    throw new SynchronisationException(e);
 	}
 	Mediator mediator = null;
 	try {
 	    mediator = Marshaller.unmarshalMediatior(mediatorAsString);
 	} catch (UnmarshalException e) {
 	    logException(e, "getMediator");
 	    e.printStackTrace();
 	    return null;
 	}
 	return mediator;
     }
 
     public WebService getWebService(IRI id) throws SynchronisationException {
 	String serviceAsString = null;
 	try {
 	    serviceAsString = this.gate.getConnectionService().getWebService(this.id,
 		    id.toString());
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "getWebService");
 	} catch (SynchronisationException_Exception e) {
 	    throw new SynchronisationException(e);
 	}
 	WebService webService = null;
 	try {
 	    webService = Marshaller.unmarshalWebService(serviceAsString);
 	} catch (UnmarshalException e) {
 	    logException(e, "getWebService");
 	    e.printStackTrace();
 	    return null;
 	}
 	return webService;
     }
 
     public List<IRI> listMediators() throws SynchronisationException {
 	List<String> mediatorIriStringList = null;
 	try {
 	    mediatorIriStringList = this.gate.getConnectionService().listMediators(
 		    this.id);
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "listMediators");
 	    e.printStackTrace();
 	    return null;
 	} catch (SynchronisationException_Exception e) {
 	    throw new SynchronisationException(e);
 	}
 	assert (mediatorIriStringList != null);
 	List<IRI> result = new LinkedList<IRI>();
 	for (String iriString : mediatorIriStringList) {
 	    result.add(Marshaller.newIRI(iriString));
 	}
 	return result;
     }
 
     public List<IRI> listWebServices() throws SynchronisationException {
 	List<String> serviceIriStringList = null;
 	try {
 	    serviceIriStringList = this.gate.getConnectionService().listWebServices(this.id);
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "listWebServices");
 	    e.printStackTrace();
 	    return null;
 	} catch (SynchronisationException_Exception e) {
 	    throw new SynchronisationException(e);
 	}
 	assert (serviceIriStringList != null);
 	List<IRI> result = new LinkedList<IRI>();
 	for (String iriString : serviceIriStringList) {
 	    result.add(Marshaller.newIRI(iriString));
 	}
 	return result;
     }
 
     public void saveMediator(Mediator med) throws SynchronisationException {
 	try {
 	    this.gate.getConnectionService().saveMediator(this.id,
 		    Marshaller.marshal(med));
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "saveMediator");
 	    e.printStackTrace();
 	    return;
 	} catch (SynchronisationException_Exception e) {
 	    throw new SynchronisationException(e);
 	} catch (UnmarshalException_Exception e) {
 	    logException(e, "saveMediator");
 	    e.printStackTrace();
 	    return;
 	}
     }
 
     public void saveWebService(WebService ws) throws SynchronisationException {
 	try {
 	    this.gate.getConnectionService().saveWebService(this.id,
 		    Marshaller.marshal(ws));
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "saveWebService");
 	    e.printStackTrace();
 	    return;
 	} catch (SynchronisationException_Exception e) {
 	    throw new SynchronisationException(e);
 	} catch (UnmarshalException_Exception e) {
 	    logException(e, "saveWebService");
 	    e.printStackTrace();
 	    return;
 	}
     }
 
     public Set<Entity> load(Identifier id) {
 	throw new UnsupportedOperationException();
     }
 
     @SuppressWarnings("unchecked")
     public Entity load(Identifier id, Class clazz) {
 	throw new UnsupportedOperationException();
     }
 
     public void remove(Identifier id) {
 	throw new UnsupportedOperationException();
     }
 
     @SuppressWarnings("unchecked")
     public void remove(Identifier id, Class clazz) {
 	throw new UnsupportedOperationException();
     }
 
     public void save(Entity item) {
 	throw new UnsupportedOperationException();
     }
 
     public void close() throws ORDIException {
 	try {
 	    this.gate.getConnectionService().close(this.id);
 	} catch (NonExistingEntryException_Exception nee) {
 	    logException(nee, "close");
 	    return;
 	} catch (ORDIException_Exception e) {
 	    throw new ORDIException(e);
 	}
     }
 
     public void commit() throws ORDIException {
 	try {
 	    this.gate.getConnectionService().commit(this.id);
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "commit");
 	    return;
 	} catch (ORDIException_Exception e) {
 	    throw new ORDIException(e);
 	}
     }
 
     public DataSource getDataSource() {
 	throw new UnsupportedOperationException();
     }
 
     public IsolationLevel getTransactionIsolationLevel() {
 	throw new UnsupportedOperationException();
     }
 
     public boolean isAutoCommit() {
 	try {
 	    boolean result = this.gate.getConnectionService().isAutoCommit(
 		    this.id);
 	    return result;
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "isAutoCommit");
 	    e.printStackTrace();
 	    return false; // XXX (mihail): This is bad
 	}
     }
 
     public boolean isOpen() {
 	try {
 	    this.gate.getConnectionService().isOpen(this.id);
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "isOpen");
 	    e.printStackTrace();
 	    return false; // XXX (mihail): not enough exceptions declared
 	}
 	return false;
     }
 
     public boolean isReadOnly() {
 	try {
 	    boolean result = this.gate.getConnectionService().isReadOnly(
 		    this.id);
 	    return result;
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "isReadOnly");
 	    e.printStackTrace();
 	    return true; // XXX (mihail): Assuming true is safer, but still
 			    // not good
 	}
     }
 
     public void rollback() throws ORDIException {
 	try {
 	    this.gate.getConnectionService().rollback(this.id);
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "rollback");
 	    return;
 	} catch (ORDIException_Exception e) {
 	    throw new ORDIException(e);
 	}
     }
 
     public void setAutoCommit(boolean mode) throws ORDIException {
 	try {
 	    this.gate.getConnectionService().setAutoCommit(this.id, mode);
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "setAutoCommit");
 	    return;
 	} catch (ORDIException_Exception e) {
 	    throw new ORDIException(e);
 	}
     }
 
     public void setTransactionIsolationLevel(IsolationLevel isolationLevel)
 	    throws ORDIException {
 	throw new UnsupportedOperationException();
     }
 
     public boolean isWrapperFor(Class<?> iface) throws ORDIException {
 	throw new UnsupportedOperationException();
     }
 
     public <T> T unwrap(Class<T> iface) throws ORDIException {
 	throw new UnsupportedOperationException();
     }
 
     public void clearWarnings() {
 	try {
 	    this.gate.getConnectionService().clearWarnings(this.id);
 	} catch (NonExistingEntryException_Exception e) {
 	    logException(e, "clearWarnings");
 	    e.printStackTrace();
 	    return;
 	}
     }
 
     // TODO (mihail): JAXB out-of-heap
     public ORDIWarning getWarning() {
 	throw new UnsupportedOperationException();
     }
 
     private Document parseXmlFromResponseString(String sxr) {
 	Document resp = null;
 
 	DocumentBuilderFactory docBuldFactory = DocumentBuilderFactory
 		.newInstance();
 	docBuldFactory.setNamespaceAware(true);
 	try {
 	    resp = docBuldFactory.newDocumentBuilder().parse(
 		    new ByteArrayInputStream(sxr.getBytes("UTF-8")));
 	} catch (UnsupportedEncodingException e) {
 	    logger
 		    .error("Response string is not encoeded in UTF-8. Aborting parsing.");
 	    e.printStackTrace();
 	    return null;
 	} catch (SAXException e) {
 	    logger
 		    .error("SAXException while trying to parse SPARQL XML Response. Aborting parsing.");
 	    e.printStackTrace();
 	    return null;
 	} catch (IOException e) {
 	    logger
 		    .error("IOException thrown while trying to parse the SPARQL XML Result. Aborting parsing.");
 	    e.printStackTrace();
 	    return null;
 	} catch (ParserConfigurationException e) {
 	    logger
 		    .error("ParserConfigurationException while trying to parse SPARQL XML Response. Aborting parsing.");
 	    e.printStackTrace();
 	    return null;
 	}
 	return resp;
     }
 
     /*
      * We need logging of exceptions since WsmoRepository and connection
      * interfaces does not support remote exceptions. TODO (mihail): solution?
      */
     private void logException(Exception e, String operation) {
 	logger.error(e.getClass().getName() + " thrown in " + operation
 		+ ". Aborting method execution.");
     }
 }