How to use

YardException

in

org.apache.stanbol.entityhub.servicesapi.yard

/**
 * 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 QueryResultList<String> findReferences(FieldQuery query) throws ManagedSiteException {
  try {
    return getYard().findReferences(query);
  } catch (YardException e) {
    throw new ManagedSiteException(e.getMessage(), 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 QueryResultList<Representation> find(FieldQuery query) throws ManagedSiteException {
  try {
    return getYard().find(query);
  } catch (YardException e) {
    throw new ManagedSiteException(e.getMessage(), 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 void delete(String id) throws ManagedSiteException {
  try {
    getYard().remove(id);
  }  catch (YardException e) {
    throw new ManagedSiteException(e.getMessage(), 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 void deleteAll() throws ManagedSiteException {
  try {
    getYard().removeAll();
  }  catch (YardException e) {
    throw new ManagedSiteException(e.getMessage(), 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;

/**
 * Stores the parsed representation to the Yard and also applies the
 * configured {@link #getFieldMapper() FieldMappings}.
 * @param The representation to store
 */
@Override
public void store(Representation representation) throws ManagedSiteException {
  try {
    Yard yard = getYard();
    fieldMapper.applyMappings(representation, representation, yard.getValueFactory());
    yard.store(representation);
  }  catch (YardException e) {
    throw new ManagedSiteException(e.getMessage(), 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;

@Override
public Entity getEntity(String id) throws ManagedSiteException {
  Representation rep;
  try {
    rep = getYard().getRepresentation(id);
  } catch (YardException e) {
    throw new ManagedSiteException(e.getMessage(), e);
  }
  if(rep != null){
    Entity entity = new EntityImpl(config.getId(), rep, null);
    SiteUtils.initEntityMetadata(entity, siteMetadata, null);
    return entity;
  } else {
    return null;
  }
}

/**
 * @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

throw new ManagedSiteException(e.getMessage(), 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 {
  throw RuntimeException.class.cast(e);

@Override
public QueryResultList<Entity> findEntities(FieldQuery query) throws ManagedSiteException {
  QueryResultList<Representation> results;
  try {
    results = getYard().findRepresentation(query);
  } catch (YardException e) {
    throw new ManagedSiteException(e.getMessage(), e);
  }
  return new QueryResultListImpl<Entity>(results.getQuery(),
      new AdaptingIterator<Representation,Entity>(
          results.iterator(), 
          new AdaptingIterator.Adapter<Representation,Entity>() {
            private final String siteId = config.getId();
            @Override
            public Entity adapt(Representation value, Class<Entity> type) {
              Entity entity = new EntityImpl(siteId,value,null);
              SiteUtils.initEntityMetadata(entity, siteMetadata, null);
              return entity;
            }
          }, Entity.class),Entity.class);
}

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

Exception e = pae.getException();
if(e instanceof SolrServerException){
  throw new YardException("Error while deleting document " + id + " from the Solr server", e);
} else if(e instanceof IOException){
  throw new YardException("Unable to access SolrServer",e);
} else {
  throw RuntimeException.class.cast(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 {
  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);