org.graphper.draw.PipelineRenderEngine Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of graph-support Show documentation
Java re-implementation of tiny graphviz
The newest version!
/*
 * Copyright 2022 The graph-support project
 *
 * 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 org.graphper.draw;

import java.util.List;
import org.graphper.api.GraphResource;
import org.graphper.util.Asserts;

/**
 * {@link RenderEngine} based on chained pipeline rendering.
 *
 * @param  node brush type
 * @param  line brush type
 * @param  cluster brush type
 * @param  graphviz brush type
 * @author Jamison Jiang
 */
@SuppressWarnings("all")
public abstract class PipelineRenderEngine<
    NB extends Brush,
    LB extends Brush,
    CB extends Brush,
    GB extends Brush>
    extends AbstractRenderEngine
    implements RenderEngine {

  protected volatile List> nodeEditors;

  protected volatile List> lineEditors;

  protected volatile List> clusterEditors;

  protected volatile List> graphEditors;

  protected final PipelineFactory pipelineFactory;

  protected PipelineRenderEngine(PipelineFactory pipelineFactory) {
    Asserts.nullArgument(pipelineFactory, "pipelineFactory");
    this.pipelineFactory = pipelineFactory;
  }

  @Override
  public GraphResource render0(DrawGraph drawGraph) throws ExecuteException {
    Asserts.nullArgument(drawGraph, "drawGraph");

    GraphPipelineTrigger> graphExecutePipeline = pipelineFactory
        .graphExecutePipeline(graphEditors(), drawGraph);
    ClusterPipelineTrigger> clusterExecutePipeline = pipelineFactory
        .clusterExecutePipeline(clusterEditors(), drawGraph);
    NodePipelineTrigger> nodeExecutePipeline = pipelineFactory
        .nodeExecutePipeline(nodeEditors(), drawGraph);
    LinePipelineTrigger> lineExecutePipeline = pipelineFactory
        .lineExecutePipeline(lineEditors(), drawGraph);

    try {
      // Triggle all editors of graph items
      DrawBoard board = drawBoard(drawGraph);
      graphExecutePipeline.trigger(board::drawGraph);
      clusterExecutePipeline.trigger(board::drawCluster);
      nodeExecutePipeline.trigger(board::drawNode);
      lineExecutePipeline.trigger(board::drawLine);

      return board.graphResource();
    } catch (FailInitResourceException ex) {
      throw new ExecuteException(ex);
    }
  }

  private synchronized List> nodeEditors() {
    if (nodeEditors == null) {
      nodeEditors = initNodeEditors();
    }

    return nodeEditors;
  }

  private synchronized List> lineEditors() {
    if (lineEditors == null) {
      lineEditors = initLineEditors();
    }

    return lineEditors;
  }

  private synchronized List> clusterEditors() {
    if (clusterEditors == null) {
      clusterEditors = initClusterEditors();
    }

    return clusterEditors;
  }

  private synchronized List> graphEditors() {
    if (graphEditors == null) {
      graphEditors = initGraphEditors();
    }

    return graphEditors;
  }

  protected abstract List> initNodeEditors();

  protected abstract List> initLineEditors();

  protected abstract List> initClusterEditors();

  protected abstract List> initGraphEditors();

  protected abstract DrawBoard drawBoard(DrawGraph drawGraph);
}