overflowdb.NodeDb Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of overflowdb-core Show documentation
overflowdb-core
There is a newer version: 1.173
package overflowdb;

import overflowdb.util.ArrayOffsetIterator;
import overflowdb.util.DummyEdgeIterator;
import overflowdb.util.MultiIterator;
import overflowdb.util.PropertyHelper;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;

/**
 * Holds node properties and edges to adjacent nodes (including edge properties).
 * Each {{@link NodeRef}} refers to exactly one NodeDb instance, and if required can set that instance to `null`, thus
 * freeing up memory, e.g. if heap memory is low. While {{@link NodeRef}} instances are very small (they will never be
 * garbage collected), NodeDb instances consume a bit more space.
 *
 * Adjacent nodes and edge properties are stored in a flat array (adjacentNodesWithEdgeProperties).
 * Edges only exist virtually and are created on request. This allows for a small memory footprint, especially given
 * that most graph domains have magnitudes more edges than nodes.
 *
 * All write operations are synchronized using `synchronized(this)`, in order to avoid race conditions when updating the adjacent nodes.
 * Read operations are not locked, i.e. they are fast because they do not wait, but they may read outdated data.
 */
public abstract class NodeDb extends Node {
  public final NodeRef ref;

  /**
   * Using separate volatile container for the large array (adjacentNodesWithEdgeProperties) and the small
   * array (edgeOffsets) to prevent jit/cpu reordering, potentially leading to race conditions when edges are
   * added/removed and traversed by other threads in parallel.
   */
  private volatile AdjacentNodes adjacentNodes;

  /**
   * Flag that helps us save time when serializing, both when overflowing to disk and when storing
   * the graph on close.
   * `true`  when node is first created, or is modified (property or edges)
   * `false` when node is freshly serialized to disk or deserialized from disk
   */
  private volatile boolean dirty;

  private static final String[] ALL_LABELS = new String[0];

  protected NodeDb(NodeRef ref) {
    this.ref = ref;

    ref.setNode(this);
    if (ref.graph != null) {
      ref.graph.applyBackpressureMaybe();
    }

    adjacentNodes = new AdjacentNodes(layoutInformation().numberOfDifferentAdjacentTypes());
  }

  public abstract NodeLayoutInformation layoutInformation();
  /**
   * Gets the adjacent nodes with properties, in internal packed format.
   * This function is really package-private, and only formally public to simplify internal organization of overflowdb.
   * */
  public AdjacentNodes getAdjacentNodes() {
    return adjacentNodes;
  }

  @Override
  public Graph graph() {
    return ref.graph;
  }

  public long id() {
    return ref.id;
  }

  @Override
  public String label() {
    return ref.label();
  }

  @Override
  public  A property(PropertyKey key) {
    return (A) property(key.name);
  }

  @Override
  public  Optional propertyOption(PropertyKey key) {
    return Optional.ofNullable(property(key));
  }

  @Override
  public Optional