import org.neo4j.graphdb.NotFoundException; //导入依赖的package包/类
public Error convert(final Exception exception) {
    Class errorClass = exception.getClass();
    Class causeClass;

    if (errorClass.equals(ConstraintViolationException.class)) {
        causeClass = exception.getCause().getClass();

        /*if (causeClass.equals(UniqueConstraintViolationKernelException.class)) {
            return analyseUniqueConstraintViolation((ConstraintViolationException) exception);
        }*/
    }
    else if (errorClass.equals(NotFoundException.class)) {
        return analyseNotFound((NotFoundException) exception);
    }

    return new Error(
            Error.EXCEPTION,
            exception.getMessage()
    );
}
 

import org.neo4j.graphdb.NotFoundException; //导入依赖的package包/类
@Ignore( "an issue that should be fixed at some point" )
@Test( expected = NotFoundException.class )
public void shouldNotBeAbleToIndexNodeThatIsNotCommitted() throws Exception
{
    Index<Node> index = nodeIndex(
            LuceneIndexImplementation.EXACT_CONFIG );
    Node node = graphDb.createNode();
    String key = "noob";
    String value = "Johan";

    WorkThread thread = new WorkThread( "other thread", index, graphDb, node );
    thread.beginTransaction();
    try
    {
        thread.add( node, key, value );
    }
    finally
    {
        thread.rollback();
    }
}
 

import org.neo4j.graphdb.NotFoundException; //导入依赖的package包/类
@Test
public void shouldThrowIllegalStateForActionsAfterDeletedOnIndex()
{
    restartTx();
    index.delete();
    restartTx();
    try
    {
        index.query( key, "own" );
        fail( "Should fail" );
    }
    catch ( NotFoundException e )
    {
        assertThat( e.getMessage(), containsString( "doesn't exist" ) );
    }
}
 

import org.neo4j.graphdb.NotFoundException; //导入依赖的package包/类
public Node getNodeById( long id )
{
    NodeBatchImpl node = nodes.get( id );
    if ( node == null )
    {
        try
        {
            node = new NodeBatchImpl( id, this,
                batchInserter.getNodeProperties( id ) );
            nodes.put( id, node );
        }
        catch ( InvalidRecordException e )
        {
            throw new NotFoundException( e );
        }
    }
    return node;
}
 

import org.neo4j.graphdb.NotFoundException; //导入依赖的package包/类
public Relationship getRelationshipById( long id )
{
    RelationshipBatchImpl rel = rels.get( id );
    if ( rel == null )
    {
        try
        {
            SimpleRelationship simpleRel =
                batchInserter.getRelationshipById( id );
            Map<String,Object> props =
                batchInserter.getRelationshipProperties( id );
            rel = new RelationshipBatchImpl( simpleRel, this, props );
            rels.put( id, rel );
        }
        catch ( InvalidRecordException e )
        {
            throw new NotFoundException( e );
        }
    }
    return rel;
}
 

import org.neo4j.graphdb.NotFoundException; //导入依赖的package包/类
public Relationship getSingleRelationship( RelationshipType type,
    Direction dir )
{
    Iterator<Relationship> relItr =
        newRelIterator( dir, new RelationshipType[] { type } );
    if ( relItr.hasNext() )
    {
        Relationship rel = relItr.next();
        if ( relItr.hasNext() )
        {
            throw new NotFoundException( "More than one relationship[" +
                type + ", " + dir + "] found for " + this );
        }
        return rel;
    }
    return null;
}
 

import org.neo4j.graphdb.NotFoundException; //导入依赖的package包/类
public static boolean renameFile( File srcFile, File renameToFile )
{
    if ( !srcFile.exists() )
    {
        throw new NotFoundException( "Source file[" + srcFile.getName()
                + "] not found" );
    }
    if ( renameToFile.exists() )
    {
        throw new NotFoundException( "Target file[" + renameToFile.getName()
                + "] already exists" );
    }
    int count = 0;
    boolean renamed = false;
    do
    {
        renamed = srcFile.renameTo( renameToFile );
        if ( !renamed )
        {
            count++;
            waitSome();
        }
    }
    while ( !renamed && count <= WINDOWS_RETRY_COUNT );
    return renamed;
}
 

import org.neo4j.graphdb.NotFoundException; //导入依赖的package包/类
public Relationship getSingleRelationship( NodeManager nodeManager, RelationshipType type,
    Direction dir )
{
    DirectionWrapper direction = RelIdArray.wrap( dir );
    RelationshipType types[] = new RelationshipType[] { type };
    Iterator<Relationship> rels = new IntArrayIterator( getAllRelationshipsOfType( nodeManager,
            direction, types ), this, direction, nodeManager, types, !hasMoreRelationshipsToLoad() );
    if ( !rels.hasNext() )
    {
        return null;
    }
    Relationship rel = rels.next();
    if ( rels.hasNext() )
    {
        throw new NotFoundException( "More than one relationship[" +
            type + ", " + dir + "] found for " + this );
    }
    return rel;
}
 

import org.neo4j.graphdb.NotFoundException; //导入依赖的package包/类
public PropertyIndex getIndexFor( int keyId )
{
    PropertyIndex index = idToIndexMap.get( keyId );
    if ( index == null )
    {
        TxCommitHook commitHook = txCommitHooks.get( getTransaction() );
        if ( commitHook != null )
        {
            index = commitHook.getIndex( keyId );
            if ( index != null )
            {
                return index;
            }
        }
        String indexString;
        indexString = persistenceManager.loadIndex( keyId );
        if ( indexString == null )
        {
            throw new NotFoundException( "Index not found [" + keyId + "]" );
        }
        index = new PropertyIndex( indexString, keyId );
        addPropertyIndex( index );
    }
    return index;
}
 

import org.neo4j.graphdb.NotFoundException; //导入依赖的package包/类
@Override
public synchronized boolean hasNext()
{
    while ( currentNode == null && currentNodeId <= highId )
    {
        try
        {
            currentNode = getNodeById( currentNodeId++ );
        }
        catch ( NotFoundException e )
        {
            // ok we try next
        }
    }
    return currentNode != null;
}
 

import org.neo4j.graphdb.NotFoundException; //导入依赖的package包/类
@Override
public boolean isSingleValue() {
	// TODO handle false Metadata
	String value = "";
	try (Transaction tx = mRepo.beginTx()) {
		value = (String) mMe.getProperty(KEY_META_CARDINALITY);
		tx.success();
	} catch (NotFoundException e) {
		log.warn("This Metadata does not has the Cardinality-Property set! "
				+ this);
	}
	if (value.equals(VALUE_META_CARDINALITY_SINGLE)) {
		return true;
	}
	return false;
}
 

import org.neo4j.graphdb.NotFoundException; //导入依赖的package包/类
@Override
public long getDeleteTimestamp() {
	// TODO handle false Metadata
	if(this.isNotify()) {
		return getPublishTimestamp();
	}
	String value = "";
	try (Transaction tx = mRepo.beginTx()) {
		value = mMe.getProperty(KEY_TIMESTAMP_DELETE,
				InternalMetadata.METADATA_NOT_DELETED_TIMESTAMP + "")
				.toString();
		tx.success();
	} catch (NotFoundException e) {
		log.warn("This Metadata does not has a DeleteTimestamp! " + this);
	}
	return Long.parseLong(value);
}
 

import org.neo4j.graphdb.NotFoundException; //导入依赖的package包/类
public static Node getStatementForASTNode(Node node)
{
	Node n = node;
	Node parent = node;

	while (true)
	{

		try
		{
			Object property = n.getProperty(NodeKeys.IS_CFG_NODE);
			return n;
		}
		catch (NotFoundException ex)
		{

		}

		Iterable<Relationship> rels = n
				.getRelationships(Direction.INCOMING);
		for (Relationship rel : rels)
		{
			parent = rel.getStartNode();
			break;
		}

		if (n == parent)
			return null;
		n = parent;
	}
}
 

import org.neo4j.graphdb.NotFoundException; //导入依赖的package包/类
protected Error analyseNotFound(final NotFoundException notFoundException) {
    ObjectNode detailsNode = jsonObjectMapper.getObjectMapper().createObjectNode();

    return new Error(
            Error.NOT_FOUND,
            notFoundException.getMessage(),
            detailsNode
    );
}
 

import org.neo4j.graphdb.NotFoundException; //导入依赖的package包/类
@Test
public void shouldThrowIllegalStateForActionsAfterDeletedOnIndex2()
{
    restartTx();
    index.delete();
    restartTx();
    try
    {
        index.add( node, key, value );
    }
    catch ( NotFoundException e )
    {
        assertThat( e.getMessage(), containsString( "doesn't exist" ) );
    }
}
 

import org.neo4j.graphdb.NotFoundException; //导入依赖的package包/类
@Override
public void activate(final Collection<Neo4jPosLengthMatch> matches) {
	for (final Neo4jPosLengthMatch match : matches) {
		final Node segment = match.getSegment();
		try {
			final Number lengthNumber = (Number) segment.getProperty(ModelConstants.LENGTH);
			final int length = Neo4jHelper.numberToInt(lengthNumber);

			segment.setProperty(ModelConstants.LENGTH, -length + 1);
		} catch (final NotFoundException e) {
			// do nothing (node has been removed)
		}
	}
}
 

import org.neo4j.graphdb.NotFoundException; //导入依赖的package包/类
@Override
public void activate(final Collection<Neo4jPosLengthMatch> matches) throws IOException {
	for (final Neo4jPosLengthMatch match : matches) {
		try {
			final Map<String, Object> parameters = ImmutableMap.of( //
				QueryConstants.VAR_SEGMENT, match.getSegment() //
			);
			driver.runTransformation(transformationDefinition, parameters);
		} catch (final NotFoundException e) {
			// do nothing (node has been removed)
		}
	}
}
 

import org.neo4j.graphdb.NotFoundException; //导入依赖的package包/类
/**
 * GET Node {"id": …}
 *
 * Fetch a single node by ID.
 */
@Override
public PropertyContainer get(RequestInterface request, DatabaseInterface database) throws ClientError, ServerError {
    long id = resolveNode(database, request.getArgument("id")).getId();
    try {
        Node node = database.getNode(id);
        responder.sendBody(node);
        return node;
    } catch (NotFoundException ex) {
        throw new ClientError("Node " + id + " not found");
    }
}
 

import org.neo4j.graphdb.NotFoundException; //导入依赖的package包/类
/**
 * SET Node {"id": …, "labels": …, "properties": …}
 *
 * Replace all labels and properties on a node identified by ID.
 * This will not create a node with the given ID if one does not
 * already exist.
 */
@Override
public PropertyContainer set(RequestInterface request, DatabaseInterface database) throws ClientError, ServerError {
    long id = resolveNode(database, request.getArgument("id")).getId();
    List labelNames = request.getArgumentAsList("labels");
    Map<String, Object> properties = request.getArgumentAsMap("properties");
    try {
        Node node = database.putNode(id, labelNames, properties);
        responder.sendBody(node);
        return node;
    } catch (NotFoundException ex) {
        throw new ClientError("Node " + id + " not found");
    }
}
 

import org.neo4j.graphdb.NotFoundException; //导入依赖的package包/类
/**
 * PATCH Node {"id": …, "labels": …}
 * PATCH Node {"id": …, "properties": …}
 * PATCH Node {"id": …, "labels": …, "properties": …}
 *
 * Add new labels and properties to a node identified by ID.
 * This will not create a node with the given ID if one does not
 * already exist and any existing labels and properties will be
 * maintained.
 */
@Override
public PropertyContainer patch(RequestInterface request, DatabaseInterface database) throws ClientError, ServerError {
    long id = resolveNode(database, request.getArgument("id")).getId();
    List labelNames = request.getArgumentAsList("labels", new ArrayList());
    Map<String, Object> properties = request.getArgumentAsMap("properties", new HashMap<String, Object>());
    try {
        Node node = database.patchNode(id, labelNames, properties);
        responder.sendBody(node);
        return node;
    } catch (NotFoundException ex) {
        throw new ClientError("Node " + id + " not found");
    }
}