node.go

// Copyright 2021 Cloud Privacy Labs, LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//  http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package lpg

import (
	"fmt"
	"strings"
)

// A Node represents a graph node.
type Node struct {
	next, prev *Node
	labels     *StringSet
	contexts   *StringSet
	properties
	graph    *Graph
	incoming edgeMap
	outgoing edgeMap
	id       int
}

// GetProperty returns the property value in the string table
func (node *Node) GetProperty(key string) (interface{}, bool) {
	return node.getProperty(key)
}

func (node *Node) ForEachProperty(f func(string, interface{}) bool) bool {
	return node.forEachProperty(f)
}

// GetGraph returns the graph owning the node
func (node *Node) GetGraph() *Graph { return node.graph }

// GetLabels returns a copy of the node labels
func (node *Node) GetLabels() *StringSet { return node.labels.Clone() }
func (node *Node) GetNLabels(n int) *StringSet {
	return node.labels.CloneN(n)
}

func (node *Node) HasAnyLabel(labels ...string) bool {
	return node.labels.HasAny(labels...)
}
func (node *Node) HasAllLabels(labels ...string) bool {
	return node.labels.HasAll(labels...)
}
func (node *Node) getContext() *StringSet { return node.contexts.Clone() }

func (node *Node) HasAnyContext(contexts ...string) bool {
	return node.contexts.HasAny(contexts...)
}
func (node *Node) HasAllContext(context ...string) bool {
	return node.contexts.HasAll(context...)
}

func (node *Node) HasAllContextsSet(contexts *StringSet) bool {
	return node.contexts.HasAllSet(contexts)
}

func (node *Node) HasAnyContextsSet(contexts *StringSet) bool {
	return node.contexts.HasAnySet(contexts)
}
func (node *Node) SetContexts(contexts *StringSet) {
	node.graph.setNodeContexts(node, contexts)
}

func (node *Node) GetContexts() *StringSet {
	return node.contexts.Clone()
}

// HasLabel returns true if the node has the given label
func (node *Node) HasLabel(s string) bool { return node.labels.Has(s) }

// GetID returns the unique node ID. The ID is meaningless if the node
// is removed from the graph
func (node *Node) GetID() int { return node.id }

// Returns an edge iterator for incoming or outgoing edges
func (node *Node) GetEdges(dir EdgeDir) EdgeIterator {
	switch dir {
	case IncomingEdge:
		return node.incoming.iterator(2)
	case OutgoingEdge:
		return node.outgoing.iterator(1)
	}
	i1 := node.incoming.iterator(2)
	i2 := node.outgoing.iterator(1)
	return edgeIterator{withSize(MultiIterator(i1, i2), i1.MaxSize()+i2.MaxSize())}
}

// Returns an edge iterator for incoming or outgoing edges with the given label
func (node *Node) GetEdgesWithLabel(dir EdgeDir, label string) EdgeIterator {
	switch dir {
	case IncomingEdge:
		return node.incoming.iteratorLabel(label, 2)
	case OutgoingEdge:
		return node.outgoing.iteratorLabel(label, 1)
	}
	i1 := node.incoming.iteratorLabel(label, 2)
	i2 := node.outgoing.iteratorLabel(label, 1)
	return edgeIterator{withSize(MultiIterator(i1, i2), i1.MaxSize()+i2.MaxSize())}
}

// Returns an edge iterator for incoming or outgoingn edges that has the given labels
func (node *Node) GetEdgesWithAnyLabel(dir EdgeDir, labels *StringSet) EdgeIterator {
	switch dir {
	case IncomingEdge:
		if labels == nil || labels.Len() == 0 {
			return node.incoming.iterator(2)
		}
		return node.incoming.iteratorAnyLabel(labels, 2)
	case OutgoingEdge:
		if labels == nil || labels.Len() == 0 {
			return node.outgoing.iterator(1)
		}
		return node.outgoing.iteratorAnyLabel(labels, 1)
	}
	i1 := node.GetEdgesWithAnyLabel(IncomingEdge, labels)
	i2 := node.GetEdgesWithAnyLabel(OutgoingEdge, labels)
	return edgeIterator{withSize(MultiIterator(i1, i2), i1.MaxSize()+i2.MaxSize())}
}

// SetLabels sets the node labels
func (node *Node) SetLabels(labels *StringSet) {
	node.graph.setNodeLabels(node, labels)
}

// SetProperty sets a node property
func (node *Node) SetProperty(key string, value interface{}) {
	node.graph.setNodeProperty(node, key, value)
}

// RemoveProperty removes a node property
func (node *Node) RemoveProperty(key string) {
	node.graph.removeNodeProperty(node, key)
}

// Remove all connected edges, and remove the node
func (node *Node) DetachAndRemove() {
	node.graph.detachRemoveNode(node)
}

// Remove all connected edges
func (node *Node) Detach() {
	node.graph.detachNode(node)
}

func (node *Node) OutgoingEdgeCount() int {
	return node.outgoing.n
}

func (node *Node) IncomingEdgeCount() int {
	return node.incoming.n
}

// String returns the string representation of the node
func (node *Node) String() string {
	labels := strings.Join(node.labels.Slice(), ":")
	if node.labels.Len() > 0 {
		labels = ":" + labels
	}
	return fmt.Sprintf("(%s %s)", labels, node.properties)
}

// NextNodesWith returns the nodes reachable from source with the given label at one step
func NextNodesWith(source *Node, label string) []*Node {
	return TargetNodes(source.GetEdgesWithLabel(OutgoingEdge, label))
}

// PrevNodesWith returns the nodes reachable from source with the given label at one step
func PrevNodesWith(source *Node, label string) []*Node {
	return SourceNodes(source.GetEdgesWithLabel(IncomingEdge, label))
}