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 }