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

   1 /**
   2  * ============LICENSE_START=======================================================
   3  * org.onap.aai
   4  * ================================================================================
   5  * Copyright © 2017 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  * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  21  */
  22 package org.onap.aai.serialization.tinkerpop;
  23
  24 import org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree;
  25 import org.apache.tinkerpop.gremlin.structure.*;
  26 import org.apache.tinkerpop.gremlin.structure.util.detached.DetachedVertex;
  27
  28 import java.util.ArrayList;
  29 import java.util.Collections;
  30 import java.util.Iterator;
  31 import java.util.List;
  32
  33 /**
  34  * Represents a {@link Vertex} that is disconnected from a {@link Graph} however,
  35  * traversals are supported as they are backed by a Tree with saturated {@link Vertex} and {@link Edge} objects.
  36  * These objects are not mutable and can only be used to read information out.
  37  *
  38  */
  39
  40 public class TreeBackedVertex extends DetachedVertex implements Vertex {
  41
  42         private static final long serialVersionUID = -976854460992756953L;
  43         private final Tree<Element> tree;
  44         private final Vertex self;
  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     @Override
 110     public Iterator<Vertex> vertices(final Direction direction, final String... labels) {
 111         final List<Tree<Element>> vertexElements = tree.getTreesAtDepth(3);
 112                 final List<Element> edgeElements = tree.getObjectsAtDepth(2);
 113                 return edgeElements.stream().map( ele -> (Edge)ele).filter(e -> {
 114                         boolean result = false;
 115                         if (labels.length == 0) {
 116                                 return true;
 117                         }
 118                         for (String label : labels) {
 119                                 if (label.equals(e.label())) {
 120                                         result = true;
 121                                         break;
 122                                 }
 123                         }
 124                         return result;
 125                 }).filter(e -> {
 126                         if (Direction.IN.equals(direction) && e.inVertex().equals(self)) {
 127                                 return true;
 128                         } else if (Direction.OUT.equals(direction) && e.outVertex().equals(self)) {
 129                                 return true;
 130                         } else if (Direction.BOTH.equals(direction)){
 131                                 return true;
 132                         } else {
 133                                 return false;
 134                         }
 135                 }).map(e -> {
 136                         final List<Vertex> list;
 137                         if (Direction.IN.equals(direction)) {
 138                                 list = Collections.singletonList(e.outVertex());
 139                         } else if (Direction.OUT.equals(direction)){
 140                                 list = Collections.singletonList(e.inVertex());
 141                         } else {
 142                                 list = new ArrayList<>();
 143                                 Iterator<Vertex> itr = e.bothVertices();
 144                                 while (itr.hasNext()) {
 145                                 list.add(itr.next());
 146                                 }
 147                         }
 148                         return list;
 149
 150                 }).flatMap(list -> list.stream()).map(v -> {
 151                         Tree<Element> vTree = new Tree<Element>();
 152                         for (Tree<Element> tree : vertexElements) {
 153                                 if (tree.keySet().contains(v)) {
 154                                         vTree = tree;
 155                                         break;
 156                                 }
 157                         }
 158
 159                         return (Vertex)new TreeBackedVertex(v, vTree);
 160                 }).iterator();
 161         }
 162
 163 }