aai-core/src/main/java/org/onap/aai/serialization/tinkerpop/TreeBackedVertex.java

   1 /**
   2  * ============LICENSE_START=======================================================
   3  * org.onap.aai
   4  * ================================================================================
   5  * Copyright © 2017-2018 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *    http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.aai.serialization.tinkerpop;
  22
  23 import java.util.ArrayList;
  24 import java.util.Collections;
  25 import java.util.Iterator;
  26 import java.util.List;
  27
  28 import org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree;
  29 import org.apache.tinkerpop.gremlin.structure.*;
  30 import org.apache.tinkerpop.gremlin.structure.util.detached.DetachedVertex;
  31
  32 /**
  33  * Represents a {@link Vertex} that is disconnected from a {@link Graph} however,
  34  * traversals are supported as they are backed by a Tree with saturated {@link Vertex} and {@link Edge} objects.
  35  * These objects are not mutable and can only be used to read information out.
  36  *
  37  */
  38
  39 public class TreeBackedVertex extends DetachedVertex implements Vertex {
  40
  41     private static final long serialVersionUID = -976854460992756953L;
  42     private final transient Tree<Element> tree;
  43     private final transient Vertex self;
  44
  45     public TreeBackedVertex(Vertex v, Tree<Element> tree) {
  46         super(v, true);
  47         this.self = v;
  48         this.tree = tree;
  49     }
  50
  51     @Override
  52     public Iterator<Edge> edges(final Direction direction, final String... edgeLabels) {
  53         final List<Element> edges = tree.getObjectsAtDepth(2);
  54         final List<Tree<Element>> trees = tree.getTreesAtDepth(2);
  55         final List<Tree<Element>> vTrees = tree.getTreesAtDepth(3);
  56         return edges.stream().map(ele -> (Edge) ele).filter(e -> {
  57             if (Direction.IN.equals(direction)) {
  58                 return e.inVertex().equals(self);
  59             } else if (Direction.OUT.equals(direction)) {
  60                 return e.outVertex().equals(self);
  61             } else {
  62                 return true;
  63             }
  64         }).filter(e -> {
  65             boolean result = false;
  66             if (edgeLabels.length == 0) {
  67                 return true;
  68             }
  69             for (String label : edgeLabels) {
  70                 if (label.equals(e.label())) {
  71                     result = true;
  72                     break;
  73                 }
  74             }
  75             return result;
  76         }).map(e -> {
  77             Tree<Element> eTree = new Tree<>();
  78             for (Tree<Element> tree : trees) {
  79                 if (tree.keySet().contains(e)) {
  80                     eTree = tree;
  81                     break;
  82                 }
  83             }
  84             TreeBackedVertex in = null;
  85             TreeBackedVertex out = null;
  86             if (e.inVertex().equals(self)) {
  87                 in = this;
  88                 out = this.createForVertex(e.outVertex(), vTrees);
  89             } else if (e.outVertex().equals(self)) {
  90                 out = this;
  91                 in = this.createForVertex(e.inVertex(), vTrees);
  92             }
  93             return (Edge) new TreeBackedEdge(e, in, out);
  94         }).iterator();
  95
  96     }
  97
  98     private TreeBackedVertex createForVertex(Vertex v, List<Tree<Element>> trees) {
  99         Tree<Element> vTree = new Tree<>();
 100         for (Tree<Element> tree : trees) {
 101             if (tree.keySet().contains(v)) {
 102                 vTree = tree;
 103                 break;
 104             }
 105         }
 106
 107         return new TreeBackedVertex((Vertex) vTree.keySet().iterator().next(), vTree);
 108     }
 109
 110     @Override
 111     public Iterator<Vertex> vertices(final Direction direction, final String... labels) {
 112         final List<Tree<Element>> vertexElements = tree.getTreesAtDepth(3);
 113         final List<Element> edgeElements = tree.getObjectsAtDepth(2);
 114         return edgeElements.stream().map(ele -> (Edge) ele).filter(e -> {
 115             boolean result = false;
 116             if (labels.length == 0) {
 117                 return true;
 118             }
 119             for (String label : labels) {
 120                 if (label.equals(e.label())) {
 121                     result = true;
 122                     break;
 123                 }
 124             }
 125             return result;
 126         }).filter(e -> {
 127             if (Direction.IN.equals(direction) && e.inVertex().equals(self)) {
 128                 return true;
 129             } else if (Direction.OUT.equals(direction) && e.outVertex().equals(self)) {
 130                 return true;
 131             } else if (Direction.BOTH.equals(direction)) {
 132                 return true;
 133             } else {
 134                 return false;
 135             }
 136         }).map(e -> {
 137             final List<Vertex> list;
 138             if (Direction.IN.equals(direction)) {
 139                 list = Collections.singletonList(e.outVertex());
 140             } else if (Direction.OUT.equals(direction)) {
 141                 list = Collections.singletonList(e.inVertex());
 142             } else {
 143                 list = new ArrayList<>();
 144                 Iterator<Vertex> itr = e.bothVertices();
 145                 while (itr.hasNext()) {
 146                     list.add(itr.next());
 147                 }
 148             }
 149             return list;
 150
 151         }).flatMap(list -> list.stream()).map(v -> {
 152             Tree<Element> vTree = new Tree<Element>();
 153             for (Tree<Element> tree : vertexElements) {
 154                 if (tree.keySet().contains(v)) {
 155                     vTree = tree;
 156                     break;
 157                 }
 158             }
 159
 160             return (Vertex) new TreeBackedVertex(v, vTree);
 161         }).iterator();
 162     }
 163
 164 }