How to use

org.apache.stanbol.entityhub.servicesapi.yard.YardException

constructor

/**
 * This will case the SolrIndex to be optimised
 * @throws YardException on any error while optimising
 */
public final void optimize() throws YardException {
  if(closed){
    throw new IllegalStateException("The SolrYard is already closed!");
  }
  try {
    server.optimize();
  } catch (SolrServerException e) {
    throw new YardException("Unable to optimise SolrIndex!", e);
  } catch (IOException e) {
    throw new YardException("Unable to optimise SolrIndex!", e);
  }
}
/**

/**
 * This will case the SolrIndex to be optimised
 * @throws YardException on any error while optimising
 */
public final void optimize() throws YardException {
  if(closed){
    throw new IllegalStateException("The SolrYard is already closed!");
  }
  try {
    server.optimize();
  } catch (SolrServerException e) {
    throw new YardException("Unable to optimise SolrIndex!", e);
  } catch (IOException e) {
    throw new YardException("Unable to optimise SolrIndex!", e);
  }
}
/**

@Override
public final boolean isRepresentation(String id) throws YardException {
  if (id == null) {
    throw new IllegalArgumentException("The parsed Representation id MUST NOT be NULL!");
  }
  if (id.isEmpty()) {
    throw new IllegalArgumentException("The parsed Representation id MUST NOT be empty!");
  }
  try {
    return getSolrDocument(id, Arrays.asList(fieldMapper.getDocumentIdField())) != null;
  } catch (SolrServerException e) {
    throw new YardException("Error while performing getDocumentByID request for id " + id, e);
  } catch (IOException e) {
    throw new YardException("Unable to access SolrServer", e);
  }
}

@Override
public final boolean isRepresentation(String id) throws YardException {
  if (id == null) {
    throw new IllegalArgumentException("The parsed Representation id MUST NOT be NULL!");
  }
  if (id.isEmpty()) {
    throw new IllegalArgumentException("The parsed Representation id MUST NOT be empty!");
  }
  try {
    return getSolrDocument(id, Arrays.asList(fieldMapper.getDocumentIdField())) != null;
  } catch (SolrServerException e) {
    throw new YardException("Error while performing getDocumentByID request for id " + id, e);
  } catch (IOException e) {
    throw new YardException("Unable to access SolrServer", e);
  }
}

Exception e = pae.getException();
if(e instanceof SolrServerException){
  throw new YardException("Error while deleting documents from the Solr server", e);
} else if(e instanceof IOException){
  throw new YardException("Unable to access SolrServer",e);
} else if(e instanceof YardException){
  throw (YardException)e;

/**
 * @return
 * @throws YardException
 */
private Lock writeLockGraph() throws YardException {
  if (immutable) {
     throw new YardException("Unable modify data in ClerezzaYard '"+getId()
      + "' because the backing RDF graph '"+yardGraphUri
      + "' is read-only!");
  }
  final Lock writeLock;
  writeLock = graph.getLock().writeLock();
  writeLock.lock();
  return writeLock;
}
@Override

Exception e = pae.getException();
if(e instanceof SolrServerException){
  throw new YardException("Error while deleting documents from the Solr server", e);
} else if(e instanceof IOException){
  throw new YardException("Unable to access SolrServer",e);
} else {
  throw RuntimeException.class.cast(e);

  doc = getSolrDocument(id);
} catch (SolrServerException e) {
  throw new YardException("Error while getting SolrDocument for id" + id, e);
} catch (IOException e) {
  throw new YardException("Unable to access SolrServer", e);

  doc = getSolrDocument(id);
} catch (SolrServerException e) {
  throw new YardException("Error while getting SolrDocument for id" + id, e);
} catch (IOException e) {
  throw new YardException("Unable to access SolrServer", e);

/**
 * Returns the SPARQL result set for a given {@link SparqlFieldQuery} that
 * was executed on this yard
 * @param query the SparqlFieldQuery instance
 * @return the results of the SPARQL query in the yard
 * @throws YardException in case the generated SPARQL query could not be parsed
 * or the generated Query is not an SPARQL SELECT query.
 */
private ResultSet executeSparqlFieldQuery(final SparqlFieldQuery query) throws YardException {
  int limit = QueryUtils.getLimit(query, getConfig().getDefaultQueryResultNumber(), getConfig().getMaxQueryResultNumber());
  SelectQuery sparqlQuery;
  String sparqlQueryString = SparqlQueryUtils.createSparqlSelectQuery(query, false,limit,EndpointTypeEnum.Standard);
  try {
    sparqlQuery = (SelectQuery)QueryParser.getInstance().parse(sparqlQueryString);
  } catch (ParseException e) {
    log.error("ParseException for SPARQL Query in findRepresentation");
    log.error("FieldQuery: "+query);
    log.error("SPARQL Query: "+sparqlQueryString);
    throw new YardException("Unable to parse SPARQL query generated for the parse FieldQuery",e);
  } catch (ClassCastException e){
    log.error("ClassCastExeption because parsed SPARQL Query is not of Type "+SelectQuery.class);
    log.error("FieldQuery: "+query);
    log.error("SPARQL Query: "+sparqlQueryString);
    throw new YardException("Unable to parse SPARQL SELECT query generated for the parse FieldQuery",e);
  }
  return tcManager.executeSparqlQuery(sparqlQuery, graph);
}
@Override

@Override
public Representation getRepresentation(String id) throws YardException{
  if(id == null){
    throw new IllegalArgumentException("The parsed representation id MUST NOT be NULL!");
  }
  if(id.isEmpty()){
    throw new IllegalArgumentException("The parsed representation id MUST NOT be EMTPY!");
  }
  RepositoryConnection con = null;
  try {
    con = repository.getConnection();
    con.begin();
    Representation rep = getRepresentation(con, sesameFactory.createURI(id), true);
    con.commit();
    return rep;
  } catch (RepositoryException e) {
    throw new YardException("Unable to get Representation "+id, e);
  } finally {
    if(con != null){
      try {
        con.close();
      } catch (RepositoryException ignore) {}
    }
  }
}
/**

@Override
public boolean isRepresentation(String id) throws YardException {
  if(id == null) {
    throw new IllegalArgumentException("The parsed id MUST NOT be NULL!");
  }
  if(id.isEmpty()){
    throw new IllegalArgumentException("The parsed id MUST NOT be EMPTY!");
  }
  RepositoryConnection con = null;
  try {
    con = repository.getConnection();
    con.begin();
    boolean state = isRepresentation(con, sesameFactory.createURI(id));
    con.commit();
    return state;
  } catch (RepositoryException e) {
    throw new YardException("Unable to check for Representation "+id, e);
  } finally {
    if(con != null){
      try {
        con.close();
      } catch (RepositoryException ignore) {}
    }
  }
}
/**

Exception e = pae.getException();
if(e instanceof SolrServerException){
  throw new YardException("Error while performing query on the SolrServer (query: "
      + query.getQuery()+")!", e);
} else if(e instanceof IOException){
  throw new YardException("Unable to access SolrServer",e);
} else {
  throw RuntimeException.class.cast(e);

log.error("FieldQuery: "+query);
log.error("SPARQL Query: "+sparqlQueryString);
throw new YardException("Unable to parse SPARQL query generated for the parse FieldQuery",e);
log.error("FieldQuery: "+query);
log.error("SPARQL Query: "+sparqlQueryString);
throw new YardException("Unable to process results of Query");

Exception e = pae.getException();
if(e instanceof SolrServerException){
  throw new YardException("Error while performing query on the SolrServer (query: "
      + query.getQuery()+")!", e);
} else if(e instanceof IOException){
  throw new YardException("Unable to access SolrServer",e);
} else {
  throw RuntimeException.class.cast(e);

  return added;
} catch (RepositoryException e) {
  throw new YardException("Unable to remove parsed Representations", e);
} catch (IllegalArgumentException e) {
  try { 

@Override
public void remove(String id) throws YardException, IllegalArgumentException {
  if(id == null) {
    throw new IllegalArgumentException("The parsed Representation id MUST NOT be NULL!");
  }
  RepositoryConnection con = null;
  try {
    con = repository.getConnection();
    con.begin();
    remove(con, sesameFactory.createURI(id));
    con.commit();
  } catch (RepositoryException e) {
    throw new YardException("Unable to remove for Representation "+id, e);
  } finally {
    if(con != null){
      try {
        con.close();
      } catch (RepositoryException ignore) {}
    }
  }
}
/**

@Override
public final void remove(Iterable<String> ids) throws IllegalArgumentException, YardException {
  if(ids == null){
    throw new IllegalArgumentException("The parsed Iterable over the IDs to remove MUST NOT be NULL!");
  }
  RepositoryConnection con = null;
  try {
    con = repository.getConnection();
    con.begin();
    for(String id : ids){
      if(id != null){
        remove(con, sesameFactory.createURI(id));
      }
    }
    con.commit();
  } catch (RepositoryException e) {
    throw new YardException("Unable to remove parsed Representations", e);
  } finally {
    if(con != null){
      try {
        con.close();
      } catch (RepositoryException ignore) {}
    }
  }
}
@Override

@Override
public final void removeAll() throws YardException {
  RepositoryConnection con = null;
  try {
    con = repository.getConnection();
    con.begin();
    con.clear(contexts); //removes everything
    con.commit();
  } catch (RepositoryException e) {
    throw new YardException("Unable to remove parsed Representations", e);
  } finally {
    if(con != null){
      try {
        con.close();
      } catch (RepositoryException ignore) {}
    }
  }
}
@Override

  return added;
} catch (RepositoryException e) {
  throw new YardException("Unable to remove parsed Representations", e);
} catch (IllegalArgumentException e) {
  try {