code-generator/binding-data-codec/src/main/java/org/opendaylight/yangtools/binding/data/codec/impl/LazyDataObject.java

   1 /*
   2  * Copyright (c) 2014 Cisco Systems, Inc. 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 package org.opendaylight.yangtools.binding.data.codec.impl;
   9
  10 import com.google.common.base.Objects.ToStringHelper;
  11 import com.google.common.base.Optional;
  12 import com.google.common.base.Preconditions;
  13 import com.google.common.collect.ImmutableMap;
  14 import java.lang.reflect.InvocationHandler;
  15 import java.lang.reflect.InvocationTargetException;
  16 import java.lang.reflect.Method;
  17 import java.lang.reflect.Proxy;
  18 import java.util.Map;
  19 import java.util.Objects;
  20 import java.util.concurrent.ConcurrentHashMap;
  21 import org.opendaylight.yangtools.binding.data.codec.util.AugmentationReader;
  22 import org.opendaylight.yangtools.yang.binding.Augmentable;
  23 import org.opendaylight.yangtools.yang.binding.Augmentation;
  24 import org.opendaylight.yangtools.yang.binding.DataObject;
  25 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  26 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  27 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
  28 import org.slf4j.Logger;
  29 import org.slf4j.LoggerFactory;
  30
  31 class LazyDataObject implements InvocationHandler, AugmentationReader {
  32
  33     private static final Logger LOG = LoggerFactory.getLogger(LazyDataObject.class);
  34     private static final String GET_IMPLEMENTED_INTERFACE = "getImplementedInterface";
  35     private static final String TO_STRING = "toString";
  36     private static final String EQUALS = "equals";
  37     private static final String GET_AUGMENTATION = "getAugmentation";
  38     private static final String HASHCODE = "hashCode";
  39     private static final Object NULL_VALUE = new Object();
  40
  41     private final ConcurrentHashMap<Method, Object> cachedData = new ConcurrentHashMap<>();
  42     private final NormalizedNodeContainer<?, PathArgument, NormalizedNode<?, ?>> data;
  43     private final DataObjectCodecContext<?> context;
  44
  45     private volatile ImmutableMap<Class<? extends Augmentation<?>>, Augmentation<?>> cachedAugmentations = null;
  46     private volatile Integer cachedHashcode = null;
  47
  48     @SuppressWarnings({ "rawtypes", "unchecked" })
  49     private LazyDataObject(final DataObjectCodecContext<?> ctx, final NormalizedNodeContainer data) {
  50         this.context = Preconditions.checkNotNull(ctx, "Context must not be null");
  51         this.data = Preconditions.checkNotNull(data, "Data must not be null");
  52     }
  53
  54     @SuppressWarnings("rawtypes")
  55     static DataObject create(final DataObjectCodecContext ctx, final NormalizedNodeContainer<?, ?, ?> data) {
  56         Class<?> bindingClass = ctx.bindingClass();
  57         return (DataObject) Proxy.newProxyInstance(bindingClass.getClassLoader(), new Class<?>[] { bindingClass },
  58                 new LazyDataObject(ctx, data));
  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             String name = method.getName();
  65             if (GET_IMPLEMENTED_INTERFACE.equals(name)) {
  66                 return context.bindingClass();
  67             } else if (TO_STRING.equals(name)) {
  68                 return bindingToString();
  69             } else if (HASHCODE.equals(name)) {
  70                 return bindingHashCode();
  71             }
  72             return getBindingData(method);
  73         } else if (GET_AUGMENTATION.equals(method.getName())) {
  74             return getAugmentationImpl((Class<?>) args[0]);
  75         } else if (EQUALS.equals(method.getName())) {
  76             return bindingEquals(args[0]);
  77         }
  78         throw new UnsupportedOperationException("Unsupported method " + method);
  79     }
  80
  81     private boolean bindingEquals(final Object other) {
  82         if (other == null) {
  83             return false;
  84         }
  85         if (!context.bindingClass().isAssignableFrom(other.getClass())) {
  86             return false;
  87         }
  88         try {
  89             for (Method m : context.getHashCodeAndEqualsMethods()) {
  90                 Object thisValue = getBindingData(m);
  91                 Object otherValue = m.invoke(other);
  92                 if(!Objects.equals(thisValue, otherValue)) {
  93                     return false;
  94                 }
  95             }
  96         } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
  97             LOG.warn("Can not determine equality of {} and {}", this, other, e);
  98             return false;
  99         }
 100         return true;
 101     }
 102
 103     private Integer bindingHashCode() {
 104         Integer ret = cachedHashcode;
 105         if (ret != null) {
 106             return ret;
 107         }
 108
 109         final int prime = 31;
 110         int result = 1;
 111         for (Method m : context.getHashCodeAndEqualsMethods()) {
 112             Object value = getBindingData(m);
 113             result += prime * result + ((value == null) ? 0 : value.hashCode());
 114         }
 115         if (Augmentation.class.isAssignableFrom(context.bindingClass())) {
 116             result += prime * result + (getAugmentations(this).hashCode());
 117         }
 118         cachedHashcode = result;
 119         return result;
 120     }
 121
 122     private Object getBindingData(final Method method) {
 123         Object cached = cachedData.get(method);
 124         if (cached == null) {
 125             Object readedValue = context.getBindingChildValue(method, data);
 126             if (readedValue == null) {
 127                 cached = NULL_VALUE;
 128             } else {
 129                 cached = readedValue;
 130             }
 131             cachedData.putIfAbsent(method, cached);
 132         }
 133
 134         return cached == NULL_VALUE ? null : cached;
 135     }
 136
 137     private Map<Class<? extends Augmentation<?>>, Augmentation<?>> getAugmentationsImpl() {
 138         ImmutableMap<Class<? extends Augmentation<?>>, Augmentation<?>> ret = cachedAugmentations;
 139         if (ret == null) {
 140             synchronized (this) {
 141                 ret = cachedAugmentations;
 142                 if (ret == null) {
 143                     ret = ImmutableMap.copyOf(context.getAllAugmentationsFrom(data));
 144                     cachedAugmentations = ret;
 145                 }
 146             }
 147         }
 148
 149         return ret;
 150     }
 151
 152     @Override
 153     public Map<Class<? extends Augmentation<?>>, Augmentation<?>> getAugmentations(final Object obj) {
 154         Preconditions.checkArgument(this == Proxy.getInvocationHandler(obj),
 155                 "Supplied object is not associated with this proxy handler");
 156
 157         return getAugmentationsImpl();
 158     }
 159
 160     private Object getAugmentationImpl(final Class<?> cls) {
 161         final ImmutableMap<Class<? extends Augmentation<?>>, Augmentation<?>> aug = cachedAugmentations;
 162         if (aug != null) {
 163             return aug.get(cls);
 164         }
 165         Preconditions.checkNotNull(cls,"Supplied augmentation must not be null.");
 166         final Optional<DataContainerCodecContext<?>> augCtx= context.getPossibleStreamChild(cls);
 167         if(augCtx.isPresent()) {
 168             final Optional<NormalizedNode<?, ?>> augData = data.getChild(augCtx.get().getDomPathArgument());
 169             if (augData.isPresent()) {
 170                 return augCtx.get().dataFromNormalizedNode(augData.get());
 171             }
 172         }
 173         return null;
 174     }
 175
 176     public String bindingToString() {
 177         ToStringHelper helper = com.google.common.base.Objects.toStringHelper(context.bindingClass()).omitNullValues();
 178
 179         for (Method m :context.getHashCodeAndEqualsMethods()) {
 180             helper.add(m.getName(), getBindingData(m));
 181         }
 182         if (Augmentable.class.isAssignableFrom(context.bindingClass())) {
 183             helper.add("augmentations", getAugmentationsImpl());
 184         }
 185         return helper.toString();
 186     }
 187
 188     @Override
 189     public int hashCode() {
 190         final int prime = 31;
 191         int result = 1;
 192         result = prime * result + context.hashCode();
 193         result = prime * result + data.hashCode();
 194         return result;
 195     }
 196
 197     @Override
 198     public boolean equals(final Object obj) {
 199         if (this == obj) {
 200             return true;
 201         }
 202         if (obj == null) {
 203             return false;
 204         }
 205         if (getClass() != obj.getClass()) {
 206             return false;
 207         }
 208         LazyDataObject other = (LazyDataObject) obj;
 209         if (context == null) {
 210             if (other.context != null) {
 211                 return false;
 212             }
 213         } else if (!context.equals(other.context)) {
 214             return false;
 215         }
 216         if (data == null) {
 217             if (other.data != null) {
 218                 return false;
 219             }
 220         } else if (!data.equals(other.data)) {
 221             return false;
 222         }
 223         return true;
 224     }
 225
 226 }