binding2/mdsal-binding2-dom-codec/src/main/java/org/opendaylight/mdsal/binding/javav2/dom/codec/impl/context/base/LazyTreeNode.java

   1 /*
   2  * Copyright (c) 2017 Pantheon Technologies s.r.o. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.mdsal.binding.javav2.dom.codec.impl.context.base;
  10
  11 import com.google.common.annotations.Beta;
  12 import com.google.common.base.MoreObjects;
  13 import com.google.common.base.MoreObjects.ToStringHelper;
  14 import com.google.common.base.Preconditions;
  15 import com.google.common.collect.ImmutableMap;
  16 import java.lang.reflect.InvocationHandler;
  17 import java.lang.reflect.InvocationTargetException;
  18 import java.lang.reflect.Method;
  19 import java.lang.reflect.Proxy;
  20 import java.util.Arrays;
  21 import java.util.Map;
  22 import java.util.Objects;
  23 import java.util.Optional;
  24 import java.util.concurrent.ConcurrentHashMap;
  25 import org.opendaylight.mdsal.binding.javav2.dom.codec.api.AugmentationReader;
  26 import org.opendaylight.mdsal.binding.javav2.runtime.reflection.BindingReflections;
  27 import org.opendaylight.mdsal.binding.javav2.spec.base.TreeNode;
  28 import org.opendaylight.mdsal.binding.javav2.spec.structural.Augmentable;
  29 import org.opendaylight.mdsal.binding.javav2.spec.structural.Augmentation;
  30 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  31 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  32 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
  33 import org.slf4j.Logger;
  34 import org.slf4j.LoggerFactory;
  35
  36 @Beta
  37 class LazyTreeNode<D extends TreeNode> implements InvocationHandler, AugmentationReader {
  38
  39     private static final Logger LOG = LoggerFactory.getLogger(LazyTreeNode.class);
  40     private static final String GET_IMPLEMENTED_INTERFACE = "implementedInterface";
  41     private static final String TO_STRING = "toString";
  42     private static final String EQUALS = "equals";
  43     private static final String GET_AUGMENTATION = "getAugmentation";
  44     private static final String HASHCODE = "hashCode";
  45     private static final String AUGMENTATIONS = "augmentations";
  46     private static final Object NULL_VALUE = new Object();
  47
  48     private final ConcurrentHashMap<Method, Object> cachedData = new ConcurrentHashMap<>();
  49     private final NormalizedNodeContainer<?, PathArgument, NormalizedNode<?, ?>> data;
  50     private final TreeNodeCodecContext<D,?> context;
  51
  52     private volatile ImmutableMap<Class<? extends Augmentation<?>>, Augmentation<?>> cachedAugmentations = null;
  53     private volatile Integer cachedHashcode = null;
  54
  55     @SuppressWarnings({ "rawtypes", "unchecked" })
  56     LazyTreeNode(final TreeNodeCodecContext<D,?> ctx, final NormalizedNodeContainer data) {
  57         this.context = Preconditions.checkNotNull(ctx, "Context must not be null");
  58         this.data = Preconditions.checkNotNull(data, "Data must not be null");
  59     }
  60
  61     @Override
  62     public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
  63         if (method.getParameterTypes().length == 0) {
  64             final String name = method.getName();
  65             if (GET_IMPLEMENTED_INTERFACE.equals(name)) {
  66                 return context.getBindingClass();
  67             } else if (TO_STRING.equals(name)) {
  68                 return bindingToString();
  69             } else if (HASHCODE.equals(name)) {
  70                 return bindingHashCode();
  71             } else if (AUGMENTATIONS.equals(name)) {
  72                 return getAugmentationsImpl();
  73             }
  74             return getBindingData(method);
  75         } else if (GET_AUGMENTATION.equals(method.getName())) {
  76             return getAugmentationImpl((Class<?>) args[0]);
  77         } else if (EQUALS.equals(method.getName())) {
  78             return bindingEquals(args[0]);
  79         }
  80         throw new UnsupportedOperationException("Unsupported method " + method);
  81     }
  82
  83     private boolean bindingEquals(final Object other) {
  84         if (other == null) {
  85             return false;
  86         }
  87         if (!context.getBindingClass().isAssignableFrom(other.getClass())) {
  88             return false;
  89         }
  90         try {
  91             for (final Method m : context.getHashCodeAndEqualsMethods()) {
  92                 final Object thisValue = getBindingData(m);
  93                 final Object otherValue = m.invoke(other);
  94                 /*
  95                  *   added for valid byte array comparison, when list key type is binary
  96                  *   deepEquals is not used since it does excessive amount of instanceof calls.
  97                  */
  98                 if (thisValue instanceof byte[] && otherValue instanceof byte[]) {
  99                     if (!Arrays.equals((byte[]) thisValue, (byte[]) otherValue)) {
 100                         return false;
 101                     }
 102                 } else if (!Objects.equals(thisValue, otherValue)) {
 103                     return false;
 104                 }
 105             }
 106
 107             if (Augmentable.class.isAssignableFrom(context.getBindingClass())) {
 108                 if (!getAugmentationsImpl().equals(getAllAugmentations(other))) {
 109                     return false;
 110                 }
 111             }
 112         } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
 113             LOG.warn("Can not determine equality of {} and {}", this, other, e);
 114             return false;
 115         }
 116         return true;
 117     }
 118
 119     private static Map<Class<? extends Augmentation<?>>, Augmentation<?>> getAllAugmentations(final Object dataObject) {
 120         if (dataObject instanceof AugmentationReader) {
 121             return ((AugmentationReader) dataObject).getAugmentations(dataObject);
 122         } else if (dataObject instanceof Augmentable<?>) {
 123             return BindingReflections.getAugmentations((Augmentable<?>) dataObject);
 124         }
 125
 126         throw new IllegalArgumentException("Unable to get all augmentations from " + dataObject);
 127     }
 128
 129     private Integer bindingHashCode() {
 130         final Integer ret = cachedHashcode;
 131         if (ret != null) {
 132             return ret;
 133         }
 134
 135         final int prime = 31;
 136         int result = 1;
 137         for (final Method m : context.getHashCodeAndEqualsMethods()) {
 138             final Object value = getBindingData(m);
 139             result = prime * result + Objects.hashCode(value);
 140         }
 141         if (Augmentable.class.isAssignableFrom(context.getBindingClass())) {
 142             result = prime * result + getAugmentationsImpl().hashCode();
 143         }
 144         cachedHashcode = result;
 145         return result;
 146     }
 147
 148     private Object getBindingData(final Method method) {
 149         Object cached = cachedData.get(method);
 150         if (cached == null) {
 151             final Object readedValue = context.getBindingChildValue(method, data);
 152             if (readedValue == null) {
 153                 cached = NULL_VALUE;
 154             } else {
 155                 cached = readedValue;
 156             }
 157             cachedData.putIfAbsent(method, cached);
 158         }
 159
 160         return cached == NULL_VALUE ? null : cached;
 161     }
 162
 163     private Map<Class<? extends Augmentation<?>>, Augmentation<?>> getAugmentationsImpl() {
 164         ImmutableMap<Class<? extends Augmentation<?>>, Augmentation<?>> ret = cachedAugmentations;
 165         if (ret == null) {
 166             synchronized (this) {
 167                 ret = cachedAugmentations;
 168                 if (ret == null) {
 169                     ret = ImmutableMap.copyOf(context.getAllAugmentationsFrom(data));
 170                     cachedAugmentations = ret;
 171                 }
 172             }
 173         }
 174
 175         return ret;
 176     }
 177
 178     @Override
 179     public Map<Class<? extends Augmentation<?>>, Augmentation<?>> getAugmentations(final Object obj) {
 180         Preconditions.checkArgument(this == Proxy.getInvocationHandler(obj),
 181                 "Supplied object is not associated with this proxy handler");
 182
 183         return getAugmentationsImpl();
 184     }
 185
 186     private Object getAugmentationImpl(final Class<?> cls) {
 187         final ImmutableMap<Class<? extends Augmentation<?>>, Augmentation<?>> aug = cachedAugmentations;
 188         if (aug != null) {
 189             return aug.get(cls);
 190         }
 191         Preconditions.checkNotNull(cls,"Supplied augmentation must not be null.");
 192
 193         @SuppressWarnings({"unchecked","rawtypes"})
 194         final Optional<DataContainerCodecContext<?,?>> augCtx = context.possibleStreamChild((Class) cls);
 195         if (augCtx.isPresent()) {
 196             final Optional<NormalizedNode<?, ?>> augData = data.getChild(augCtx.get().getDomPathArgument());
 197             if (augData.isPresent()) {
 198                 return augCtx.get().deserialize(augData.get());
 199             }
 200         }
 201         return null;
 202     }
 203
 204     public String bindingToString() {
 205         final ToStringHelper helper = MoreObjects.toStringHelper(context.getBindingClass()).omitNullValues();
 206
 207         for (final Method m :context.getHashCodeAndEqualsMethods()) {
 208             helper.add(m.getName(), getBindingData(m));
 209         }
 210         if (Augmentable.class.isAssignableFrom(context.getBindingClass())) {
 211             helper.add("augmentations", getAugmentationsImpl());
 212         }
 213         return helper.toString();
 214     }
 215
 216     @Override
 217     public int hashCode() {
 218         return Objects.hash(this.context, this.data);
 219     }
 220
 221     @Override
 222     public boolean equals(final Object obj) {
 223         if (this == obj) {
 224             return true;
 225         }
 226         if (obj == null) {
 227             return false;
 228         }
 229         if (getClass() != obj.getClass()) {
 230             return false;
 231         }
 232         final LazyTreeNode<?> other = (LazyTreeNode<?>) obj;
 233         return Objects.equals(context, other.context) && Objects.equals(data, other.data);
 234     }
 235 }