2 * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.yangtools.binding.data.codec.impl;
10 import com.google.common.base.MoreObjects;
11 import com.google.common.base.MoreObjects.ToStringHelper;
12 import com.google.common.base.Optional;
13 import com.google.common.base.Preconditions;
14 import com.google.common.collect.ImmutableMap;
15 import java.lang.reflect.InvocationHandler;
16 import java.lang.reflect.InvocationTargetException;
17 import java.lang.reflect.Method;
18 import java.lang.reflect.Proxy;
20 import java.util.Objects;
21 import java.util.concurrent.ConcurrentHashMap;
22 import org.opendaylight.yangtools.binding.data.codec.util.AugmentationReader;
23 import org.opendaylight.yangtools.yang.binding.Augmentable;
24 import org.opendaylight.yangtools.yang.binding.Augmentation;
25 import org.opendaylight.yangtools.yang.binding.DataObject;
26 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
27 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
28 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
29 import org.slf4j.Logger;
30 import org.slf4j.LoggerFactory;
32 class LazyDataObject<D extends DataObject> implements InvocationHandler, AugmentationReader {
34 private static final Logger LOG = LoggerFactory.getLogger(LazyDataObject.class);
35 private static final String GET_IMPLEMENTED_INTERFACE = "getImplementedInterface";
36 private static final String TO_STRING = "toString";
37 private static final String EQUALS = "equals";
38 private static final String GET_AUGMENTATION = "getAugmentation";
39 private static final String HASHCODE = "hashCode";
40 private static final String AUGMENTATIONS = "augmentations";
41 private static final Object NULL_VALUE = new Object();
43 private final ConcurrentHashMap<Method, Object> cachedData = new ConcurrentHashMap<>();
44 private final NormalizedNodeContainer<?, PathArgument, NormalizedNode<?, ?>> data;
45 private final DataObjectCodecContext<D,?> context;
47 private volatile ImmutableMap<Class<? extends Augmentation<?>>, Augmentation<?>> cachedAugmentations = null;
48 private volatile Integer cachedHashcode = null;
50 @SuppressWarnings({ "rawtypes", "unchecked" })
51 LazyDataObject(final DataObjectCodecContext<D,?> ctx, final NormalizedNodeContainer data) {
52 this.context = Preconditions.checkNotNull(ctx, "Context must not be null");
53 this.data = Preconditions.checkNotNull(data, "Data must not be null");
57 public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
58 if (method.getParameterTypes().length == 0) {
59 final String name = method.getName();
60 if (GET_IMPLEMENTED_INTERFACE.equals(name)) {
61 return context.getBindingClass();
62 } else if (TO_STRING.equals(name)) {
63 return bindingToString();
64 } else if (HASHCODE.equals(name)) {
65 return bindingHashCode();
66 } else if (AUGMENTATIONS.equals(name)) {
67 return getAugmentationsImpl();
69 return getBindingData(method);
70 } else if (GET_AUGMENTATION.equals(method.getName())) {
71 return getAugmentationImpl((Class<?>) args[0]);
72 } else if (EQUALS.equals(method.getName())) {
73 return bindingEquals(args[0]);
75 throw new UnsupportedOperationException("Unsupported method " + method);
78 private boolean bindingEquals(final Object other) {
82 if (!context.getBindingClass().isAssignableFrom(other.getClass())) {
86 for (final Method m : context.getHashCodeAndEqualsMethods()) {
87 final Object thisValue = getBindingData(m);
88 final Object otherValue = m.invoke(other);
89 if(!Objects.equals(thisValue, otherValue)) {
93 } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
94 LOG.warn("Can not determine equality of {} and {}", this, other, e);
100 private Integer bindingHashCode() {
101 final Integer ret = cachedHashcode;
106 final int prime = 31;
108 for (final Method m : context.getHashCodeAndEqualsMethods()) {
109 final Object value = getBindingData(m);
110 result += prime * result + ((value == null) ? 0 : value.hashCode());
112 if (Augmentation.class.isAssignableFrom(context.getBindingClass())) {
113 result += prime * result + (getAugmentations(this).hashCode());
115 cachedHashcode = result;
119 private Object getBindingData(final Method method) {
120 Object cached = cachedData.get(method);
121 if (cached == null) {
122 final Object readedValue = context.getBindingChildValue(method, data);
123 if (readedValue == null) {
126 cached = readedValue;
128 cachedData.putIfAbsent(method, cached);
131 return cached == NULL_VALUE ? null : cached;
134 private Map<Class<? extends Augmentation<?>>, Augmentation<?>> getAugmentationsImpl() {
135 ImmutableMap<Class<? extends Augmentation<?>>, Augmentation<?>> ret = cachedAugmentations;
137 synchronized (this) {
138 ret = cachedAugmentations;
140 ret = ImmutableMap.copyOf(context.getAllAugmentationsFrom(data));
141 cachedAugmentations = ret;
150 public Map<Class<? extends Augmentation<?>>, Augmentation<?>> getAugmentations(final Object obj) {
151 Preconditions.checkArgument(this == Proxy.getInvocationHandler(obj),
152 "Supplied object is not associated with this proxy handler");
154 return getAugmentationsImpl();
157 private Object getAugmentationImpl(final Class<?> cls) {
158 final ImmutableMap<Class<? extends Augmentation<?>>, Augmentation<?>> aug = cachedAugmentations;
162 Preconditions.checkNotNull(cls,"Supplied augmentation must not be null.");
164 @SuppressWarnings({"unchecked","rawtypes"})
165 final Optional<DataContainerCodecContext<?,?>> augCtx= context.possibleStreamChild((Class) cls);
166 if(augCtx.isPresent()) {
167 final Optional<NormalizedNode<?, ?>> augData = data.getChild(augCtx.get().getDomPathArgument());
168 if (augData.isPresent()) {
169 return augCtx.get().deserialize(augData.get());
175 public String bindingToString() {
176 final ToStringHelper helper = MoreObjects.toStringHelper(context.getBindingClass()).omitNullValues();
178 for (final Method m :context.getHashCodeAndEqualsMethods()) {
179 helper.add(m.getName(), getBindingData(m));
181 if (Augmentable.class.isAssignableFrom(context.getBindingClass())) {
182 helper.add("augmentations", getAugmentationsImpl());
184 return helper.toString();
188 public int hashCode() {
189 final int prime = 31;
191 result = prime * result + context.hashCode();
192 result = prime * result + data.hashCode();
197 public boolean equals(final Object obj) {
204 if (getClass() != obj.getClass()) {
207 final LazyDataObject<?> other = (LazyDataObject<?>) obj;
208 if (context == null) {
209 if (other.context != null) {
212 } else if (!context.equals(other.context)) {
216 if (other.data != null) {
219 } else if (!data.equals(other.data)) {