aai-core/src/main/java/org/openecomp/aai/introspection/IntrospectorWalker.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.introspection;
  22
  23 import java.util.HashSet;
  24 import java.util.LinkedHashSet;
  25 import java.util.List;
  26 import java.util.Set;
  27
  28 import org.openecomp.aai.exceptions.AAIException;
  29 import org.openecomp.aai.introspection.exceptions.AAIUnknownObjectException;
  30 import com.att.eelf.configuration.EELFLogger;
  31 import com.att.eelf.configuration.EELFManager;
  32
  33 public class IntrospectorWalker {
  34
  35         private static final EELFLogger LOGGER = EELFManager.getInstance().getLogger(IntrospectorWalker.class);
  36
  37         private Wanderer w = null;
  38         private Set<String> blacklist = null;
  39         private boolean preventCycles = false;
  40         private final PropertyPredicate<Introspector, String> propVisibility;
  41
  42         /**
  43          * Instantiates a new introspector walker.
  44          *
  45          * @param w the w
  46          * @param llBuilder the ll builder
  47          */
  48         public IntrospectorWalker(Wanderer w) {
  49                 this.w = w;
  50                 this.blacklist = new HashSet<>();
  51                 this.propVisibility = null;
  52         }
  53
  54         public IntrospectorWalker(Wanderer w, PropertyPredicate<Introspector, String> p) {
  55                 this.w = w;
  56                 this.blacklist = new HashSet<>();
  57                 this.propVisibility = p;
  58         }
  59
  60
  61         /**
  62          * Sets the blacklist.
  63          *
  64          * @param list the new blacklist
  65          */
  66         public void setBlacklist(List<String> list) {
  67                 blacklist.addAll(list);
  68         }
  69
  70         /**
  71          * Prevent cycles.
  72          *
  73          * @param prevent the prevent
  74          */
  75         public void preventCycles(boolean prevent) {
  76                 this.preventCycles = prevent;
  77         }
  78
  79         /**
  80          * Walk.
  81          *
  82          * @param obj the obj
  83          * @throws AAIException
  84          */
  85         public void walk(Introspector obj) throws AAIException {
  86                 Set<String> visited = new HashSet<>();
  87
  88                 walk(obj, null, visited);
  89         }
  90
  91         /**
  92          * Walk.
  93          *
  94          * @param obj the obj
  95          * @param parent the parent
  96          * @throws AAIException
  97          */
  98         private void walk(Introspector obj, Introspector parent, Set<String> visited) throws AAIException {
  99                 boolean stopRecursion = false;
 100                 Set<String> localVisited = new HashSet<>();
 101                 localVisited.addAll(visited);
 102                 if (preventCycles) {
 103                         if (visited.contains(obj.getName())) {
 104                                 stopRecursion = true;
 105                         }
 106                         if (!obj.isContainer()) {
 107                                 localVisited.add(obj.getName()); //so we don't recurse while walking its children
 108                         }
 109                 }
 110                 Set<String> props;
 111                 //props must duplicate the result from getProperties because
 112                 //it is unmodifiable
 113                 if (this.propVisibility == null) {
 114                         props = new LinkedHashSet<>(obj.getProperties());
 115                 } else {
 116                         props = new LinkedHashSet<>(obj.getProperties(this.propVisibility));
 117                 }
 118
 119                 w.processComplexObj(obj);
 120                 props.removeAll(blacklist);
 121                 if (!obj.isContainer()) {
 122                         parent = obj;
 123                 }
 124                 for (String prop : props) {
 125
 126                         if (obj.isSimpleType(prop)) {
 127
 128                                 w.processPrimitive(prop, obj);
 129                         } else if (obj.isListType(prop) && !stopRecursion) {
 130
 131                                 List<Object> listReference = obj.getValue(prop);
 132                                 boolean isComplexType = obj.isComplexGenericType(prop);
 133                                 if (isComplexType) {
 134                                         List<Introspector> list = obj.getWrappedListValue(prop);
 135                                         try {
 136                                                 Introspector child = obj.newIntrospectorInstanceOfNestedProperty(prop);
 137                                                 w.modifyComplexList(list, listReference, parent, child);
 138                                                 for (Object item : listReference) {
 139                                                         child = IntrospectorFactory.newInstance(obj.getModelType(), item);
 140                                                         walk(child, parent, localVisited);
 141                                                 }
 142                                         } catch (AAIUnknownObjectException e) {
 143                                                 LOGGER.warn("Skipping property " + prop + " (Unknown Object)", e);
 144                                         }
 145                                 } else {
 146                                         w.processPrimitiveList(prop, obj);
 147                                 }
 148                                 if (listReference.size() == 0) {
 149                                         if (isComplexType) {
 150                                                 try {
 151                                                         Introspector child = obj.newIntrospectorInstanceOfNestedProperty(prop);
 152                                                         int size = w.createComplexListSize(parent, child);
 153                                                         for (int i = 0; i < size; i++) {
 154                                                                 child = obj.newIntrospectorInstanceOfNestedProperty(prop);
 155                                                                 walk(child, parent, localVisited);
 156                                                                 listReference.add(child.getUnderlyingObject());
 157                                                         }
 158
 159                                                         obj.setValue(prop, listReference);
 160                                                 } catch (AAIUnknownObjectException e) {
 161                                                         LOGGER.warn("Skipping property " + prop + " (Unknown Object)", e);
 162                                                 }
 163                                         } else if (!isComplexType){
 164                                                 w.processPrimitiveList(prop, obj);
 165                                         }
 166                                 }
 167
 168                         } else if (obj.isComplexType(prop) && !stopRecursion) {
 169                                 Introspector child = null;
 170                                 if (obj.getValue(prop) != null) {
 171                                         child = IntrospectorFactory.newInstance(obj.getModelType(), obj.getValue(prop));
 172                                 } else {
 173                                         if (w.createComplexObjIfNull()) {
 174                                                 try {
 175                                                         child = obj.newIntrospectorInstanceOfProperty(prop);
 176                                                         obj.setValue(prop, child.getUnderlyingObject());
 177                                                 } catch (AAIUnknownObjectException e) {
 178                                                         LOGGER.warn("Skipping property " + prop + " (Unknown Object)", e);
 179                                                 }
 180                                         }
 181                                 }
 182                                 if (child != null) {
 183                                         walk(child, obj, localVisited);
 184                                 }
 185                         }
 186
 187                 }
 188                 /*
 189                 if (preventCycles && !obj.isContainer()) {
 190                         visited.remove(obj.getName()); //so we can see it down another path that isn't in danger of recursing over it
 191                 }*/
 192         }
 193 }