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 org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree;
  24 import org.apache.tinkerpop.gremlin.structure.*;
  25 import org.apache.tinkerpop.gremlin.structure.util.detached.DetachedVertex;
  26
  27 import java.util.ArrayList;
  28 import java.util.Collections;
  29 import java.util.Iterator;
  30 import java.util.List;
  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 Tree<Element> tree;
  43         private final Vertex self;
  44         public TreeBackedVertex (Vertex v, Tree<Element> tree) {
  45                 super(v, true);
  46                 this.self = v;
  47                 this.tree = tree;
  48         }
  49
  50          @Override
  51     public Iterator<Edge> edges(final Direction direction, final String... edgeLabels) {
  52                 final List<Element> edges = tree.getObjectsAtDepth(2);
  53                 final List<Tree<Element>> trees = tree.getTreesAtDepth(2);
  54                 final List<Tree<Element>> vTrees = tree.getTreesAtDepth(3);
  55         return edges.stream().map( ele -> (Edge)ele).filter(e -> {
  56                         if (Direction.IN.equals(direction)) {
  57                                 return e.inVertex().equals(self);
  58                         } else if (Direction.OUT.equals(direction)) {
  59                                 return e.outVertex().equals(self);
  60                         } else {
  61                                 return true;
  62                         }
  63                 }).filter(e -> {
  64                         boolean result = false;
  65                         if (edgeLabels.length == 0) {
  66                                 return true;
  67                         }
  68                         for (String label : edgeLabels) {
  69                                 if (label.equals(e.label())) {
  70                                         result = true;
  71                                         break;
  72                                 }
  73                         }
  74                         return result;
  75                 }).map(e -> {
  76                         Tree<Element> eTree = new Tree<>();
  77                         for (Tree<Element> tree : trees) {
  78                                 if (tree.keySet().contains(e)) {
  79                                         eTree = tree;
  80                                         break;
  81                                 }
  82                         }
  83                         TreeBackedVertex in = null;
  84                         TreeBackedVertex out = null;
  85                         if (e.inVertex().equals(self)) {
  86                                 in = this;
  87                                 out = this.createForVertex(e.outVertex(), vTrees);
  88                         } else if (e.outVertex().equals(self)) {
  89                                 out = this;
  90                                 in = this.createForVertex(e.inVertex(), vTrees);
  91                         }
  92                         return (Edge)new TreeBackedEdge(e, in, out);
  93                 }).iterator();
  94
  95     }
  96
  97         private TreeBackedVertex createForVertex(Vertex v, List<Tree<Element>> trees) {
  98                 Tree<Element> vTree = new Tree<>();
  99                 for (Tree<Element> tree : trees) {
 100                         if (tree.keySet().contains(v)) {
 101                                 vTree = tree;
 102                                 break;
 103                         }
 104                 }
 105
 106                 return new TreeBackedVertex((Vertex)vTree.keySet().iterator().next(), vTree);
 107         }
 108     @Override
 109     public Iterator<Vertex> vertices(final Direction direction, final String... labels) {
 110         final List<Tree<Element>> vertexElements = tree.getTreesAtDepth(3);
 111                 final List<Element> edgeElements = tree.getObjectsAtDepth(2);
 112                 return edgeElements.stream().map( ele -> (Edge)ele).filter(e -> {
 113                         boolean result = false;
 114                         if (labels.length == 0) {
 115                                 return true;
 116                         }
 117                         for (String label : labels) {
 118                                 if (label.equals(e.label())) {
 119                                         result = true;
 120                                         break;
 121                                 }
 122                         }
 123                         return result;
 124                 }).filter(e -> {
 125                         if (Direction.IN.equals(direction) && e.inVertex().equals(self)) {
 126                                 return true;
 127                         } else if (Direction.OUT.equals(direction) && e.outVertex().equals(self)) {
 128                                 return true;
 129                         } else if (Direction.BOTH.equals(direction)){
 130                                 return true;
 131                         } else {
 132                                 return false;
 133                         }
 134                 }).map(e -> {
 135                         final List<Vertex> list;
 136                         if (Direction.IN.equals(direction)) {
 137                                 list = Collections.singletonList(e.outVertex());
 138                         } else if (Direction.OUT.equals(direction)){
 139                                 list = Collections.singletonList(e.inVertex());
 140                         } else {
 141                                 list = new ArrayList<>();
 142                                 Iterator<Vertex> itr = e.bothVertices();
 143                                 while (itr.hasNext()) {
 144                                 list.add(itr.next());
 145                                 }
 146                         }
 147                         return list;
 148
 149                 }).flatMap(list -> list.stream()).map(v -> {
 150                         Tree<Element> vTree = new Tree<Element>();
 151                         for (Tree<Element> tree : vertexElements) {
 152                                 if (tree.keySet().contains(v)) {
 153                                         vTree = tree;
 154                                         break;
 155                                 }
 156                         }
 157
 158                         return (Vertex)new TreeBackedVertex(v, vTree);
 159                 }).iterator();
 160         }
 161
 162 }