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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * org.openecomp.aai
   4  * ================================================================================
   5  * Copyright (C) 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
  21 package org.openecomp.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.Direction;
  30 import org.apache.tinkerpop.gremlin.structure.Edge;
  31 import org.apache.tinkerpop.gremlin.structure.Element;
  32 import org.apache.tinkerpop.gremlin.structure.Graph;
  33 import org.apache.tinkerpop.gremlin.structure.Vertex;
  34 import org.apache.tinkerpop.gremlin.structure.util.detached.DetachedVertex;
  35
  36 /**
  37  * Represents a {@link Vertex} that is disconnected from a {@link Graph} however,
  38  * traversals are supported as they are backed by a Tree with saturated {@link Vertex} and {@link Edge} objects.
  39  * These objects are not mutable and can only be used to read information out.
  40  *
  41  */
  42
  43 public class TreeBackedVertex extends DetachedVertex implements Vertex {
  44
  45         private static final long serialVersionUID = -976854460992756953L;
  46         private final Tree<Element> tree;
  47         private final Vertex self;
  48         public TreeBackedVertex (Vertex v, Tree<Element> tree) {
  49                 super(v, true);
  50                 this.self = v;
  51                 this.tree = tree;
  52         }
  53
  54          @Override
  55     public Iterator<Edge> edges(final Direction direction, final String... edgeLabels) {
  56                 final List<Element> edges = tree.getObjectsAtDepth(2);
  57                 final List<Tree<Element>> trees = tree.getTreesAtDepth(2);
  58                 final List<Tree<Element>> vTrees = tree.getTreesAtDepth(3);
  59         return edges.stream().map( ele -> (Edge)ele).filter(e -> {
  60                         if (Direction.IN.equals(direction)) {
  61                                 return e.inVertex().equals(self);
  62                         } else if (Direction.OUT.equals(direction)) {
  63                                 return e.outVertex().equals(self);
  64                         } else {
  65                                 return true;
  66                         }
  67                 }).filter(e -> {
  68                         boolean result = false;
  69                         if (edgeLabels.length == 0) {
  70                                 return true;
  71                         }
  72                         for (String label : edgeLabels) {
  73                                 if (label.equals(e.label())) {
  74                                         result = true;
  75                                         break;
  76                                 }
  77                         }
  78                         return result;
  79                 }).map(e -> {
  80                         Tree<Element> eTree = new Tree<>();
  81                         for (Tree<Element> tree : trees) {
  82                                 if (tree.keySet().contains(e)) {
  83                                         eTree = tree;
  84                                         break;
  85                                 }
  86                         }
  87                         TreeBackedVertex in = null;
  88                         TreeBackedVertex out = null;
  89                         if (e.inVertex().equals(self)) {
  90                                 in = this;
  91                                 out = this.createForVertex(e.outVertex(), vTrees);
  92                         } else if (e.outVertex().equals(self)) {
  93                                 out = this;
  94                                 in = this.createForVertex(e.inVertex(), vTrees);
  95                         }
  96                         return (Edge)new TreeBackedEdge(e, in, out);
  97                 }).iterator();
  98
  99     }
 100
 101         private TreeBackedVertex createForVertex(Vertex v, List<Tree<Element>> trees) {
 102                 Tree<Element> vTree = new Tree<>();
 103                 for (Tree<Element> tree : trees) {
 104                         if (tree.keySet().contains(v)) {
 105                                 vTree = tree;
 106                                 break;
 107                         }
 108                 }
 109
 110                 return new TreeBackedVertex((Vertex)vTree.keySet().iterator().next(), vTree);
 111         }
 112     @Override
 113     public Iterator<Vertex> vertices(final Direction direction, final String... labels) {
 114         final List<Tree<Element>> vertexElements = tree.getTreesAtDepth(3);
 115                 final List<Element> edgeElements = tree.getObjectsAtDepth(2);
 116                 return edgeElements.stream().map( ele -> (Edge)ele).filter(e -> {
 117                         boolean result = false;
 118                         if (labels.length == 0) {
 119                                 return true;
 120                         }
 121                         for (String label : labels) {
 122                                 if (label.equals(e.label())) {
 123                                         result = true;
 124                                         break;
 125                                 }
 126                         }
 127                         return result;
 128                 }).filter(e -> {
 129                         if (Direction.IN.equals(direction) && e.inVertex().equals(self)) {
 130                                 return true;
 131                         } else if (Direction.OUT.equals(direction) && e.outVertex().equals(self)) {
 132                                 return true;
 133                         } else if (Direction.BOTH.equals(direction)){
 134                                 return true;
 135                         } else {
 136                                 return false;
 137                         }
 138                 }).map(e -> {
 139                         final List<Vertex> list;
 140                         if (Direction.IN.equals(direction)) {
 141                                 list = Collections.singletonList(e.outVertex());
 142                         } else if (Direction.OUT.equals(direction)){
 143                                 list = Collections.singletonList(e.inVertex());
 144                         } else {
 145                                 list = new ArrayList<>();
 146                                 Iterator<Vertex> itr = e.bothVertices();
 147                                 while (itr.hasNext()) {
 148                                 list.add(itr.next());
 149                                 }
 150                         }
 151                         return list;
 152
 153                 }).flatMap(list -> list.stream()).map(v -> {
 154                         Tree<Element> vTree = new Tree<Element>();
 155                         for (Tree<Element> tree : vertexElements) {
 156                                 if (tree.keySet().contains(v)) {
 157                                         vTree = tree;
 158                                         break;
 159                                 }
 160                         }
 161
 162                         return (Vertex)new TreeBackedVertex(v, vTree);
 163                 }).iterator();
 164         }
 165
 166 }