org.neo4j.graphmatching.PatternRelationship Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of neo4j-graph-matching Show documentation
A graph pattern matcher for Neo4j.
There is a newer version: 3.2.0-alpha02
/*
 * Copyright (c) 2002-2017 "Neo Technology,"
 * Network Engine for Objects in Lund AB [http://neotechnology.com]
 *
 * This file is part of Neo4j.
 *
 * Neo4j is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see .
 */
package org.neo4j.graphmatching;

import org.neo4j.graphdb.Direction;
import org.neo4j.graphdb.Relationship;
import org.neo4j.graphdb.RelationshipType;

/**
 * Represents a pattern for matching a {@link Relationship}.
 */
@Deprecated
public class PatternRelationship extends AbstractPatternObject
{
    private final RelationshipType type;
    private final boolean directed;
    private final boolean optional;
    private final boolean anyType;
    private final PatternNode firstNode;
    private final PatternNode secondNode;

    private boolean isMarked = false;

    PatternRelationship( PatternNode firstNode,
        PatternNode secondNode, boolean optional, boolean directed )
    {
        this.directed = directed;
        this.anyType = true;
        this.firstNode = firstNode;
        this.secondNode = secondNode;
        this.optional = optional;
        this.type = null;
    }

    PatternRelationship( RelationshipType type, PatternNode firstNode,
        PatternNode secondNode, boolean optional, boolean directed )
    {
        this.directed = directed;
        this.anyType = false;
        this.type = type;
        this.firstNode = firstNode;
        this.secondNode = secondNode;
        this.optional = optional;
    }

    boolean anyRelType()
    {
        return anyType;
    }

    /**
     * Get the {@link PatternNode} that this pattern relationship relates, that
     * is not the specified node.
     *
     * @param node one of the {@link PatternNode}s this pattern relationship
     *            relates.
     * @return the other pattern node.
     */
    public PatternNode getOtherNode( PatternNode node )
    {
        if ( node == firstNode )
        {
            return secondNode;
        }
        if ( node == secondNode )
        {
            return firstNode;
        }
        throw new RuntimeException( "Node[" + node +
            "] not in this relationship" );
    }

    /**
     * Get the first pattern node that this pattern relationship relates.
     *
     * @return the first pattern node.
     */
    public PatternNode getFirstNode()
    {
        return firstNode;
    }

    /**
     * Get the second pattern node that this pattern relationship relates.
     *
     * @return the second pattern node.
     */
    public PatternNode getSecondNode()
    {
        return secondNode;
    }

    /**
     * Does this pattern relationship represent a relationship that has to exist
     * in the subgraph to consider the subgraph a match of the pattern, or is it
     * an optional relationship.
     *
     * @return true if this pattern relationship represents an
     *         optional relationship, false if it represents a
     *         required relationship.
     */
    public boolean isOptional()
    {
        return optional;
    }

    void mark()
    {
        isMarked = true;
    }

    void unMark()
    {
        isMarked = false;
    }

    boolean isMarked()
    {
        return isMarked;
    }

    /**
     * Get the {@link RelationshipType} a relationship must have in order to
     * match this pattern relationship. Will return null if a
     * relationship with any {@link RelationshipType} will match.
     *
     * @return the {@link RelationshipType} of this relationship pattern.
     */
    public RelationshipType getType()
    {
        return type;
    }

    /**
     * Get the direction in which relationships are discovered using this
     * relationship pattern from the specified node. May be
     * {@link Direction#OUTGOING outgoing}, {@link Direction#INCOMING incoming},
     * or {@link Direction#BOTH both}.
     *
     * @param fromNode the pattern node to find the direction of this pattern
     *            relationship from.
     * @return the direction to discover relationships matching this pattern in.
     */
    public Direction getDirectionFrom( PatternNode fromNode )
    {
        if ( !directed )
        {
            return Direction.BOTH;
        }
        if ( fromNode.equals( firstNode ) )
        {
            return Direction.OUTGOING;
        }
        if ( fromNode.equals( secondNode ) )
        {
            return Direction.INCOMING;
        }
        throw new RuntimeException( fromNode + " not in " + this );
    }

    @Override
    public String toString()
    {
        return type + ":" + optional;
    }
}