1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
/*
* Copyright (c) 2016 Cisco and/or its affiliates.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.fd.honeycomb.v3po.impl.trans.impl;
import com.google.common.annotations.Beta;
import com.google.common.base.Optional;
import com.google.common.base.Predicate;
import com.google.common.collect.Collections2;
import com.google.common.collect.Lists;
import io.fd.honeycomb.v3po.impl.trans.ChildVppReader;
import io.fd.honeycomb.v3po.impl.trans.VppReader;
import io.fd.honeycomb.v3po.impl.trans.util.ReflectionUtils;
import io.fd.honeycomb.v3po.impl.trans.util.VppRWUtils;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@Beta
abstract class AbstractCompositeVppReader<D extends DataObject, B extends Builder<D>> implements VppReader<D> {
// TODO add debug + trace logs here and there
private final Map<Class<? extends DataObject>, ChildVppReader<? extends ChildOf<D>>> childReaders;
private final Map<Class<? extends DataObject>, ChildVppReader<? extends Augmentation<D>>> augReaders;
private final InstanceIdentifier<D> instanceIdentifier;
AbstractCompositeVppReader(final Class<D> managedDataObjectType,
final List<ChildVppReader<? extends ChildOf<D>>> childReaders,
final List<ChildVppReader<? extends Augmentation<D>>> augReaders) {
this.childReaders = VppRWUtils.uniqueLinkedIndex(childReaders, VppRWUtils.MANAGER_CLASS_FUNCTION);
this.augReaders = VppRWUtils.uniqueLinkedIndex(augReaders, VppRWUtils.MANAGER_CLASS_AUG_FUNCTION);
this.instanceIdentifier = InstanceIdentifier.create(managedDataObjectType);
}
@Nonnull
@Override
public final InstanceIdentifier<D> getManagedDataObjectType() {
return instanceIdentifier;
}
/**
* @param id {@link InstanceIdentifier} pointing to current node. In case of keyed list, key must be present.
*/
protected List<D> readCurrent(final InstanceIdentifier<D> id) {
final B builder = getBuilder(id);
// Cache empty value to determine if anything has changed later TODO cache in a field
final D emptyValue = builder.build();
readCurrentAttributes(id, builder);
// TODO expect exceptions from reader
for (ChildVppReader<? extends ChildOf<D>> child : childReaders.values()) {
child.read(id, builder);
}
for (ChildVppReader<? extends Augmentation<D>> child : augReaders.values()) {
child.read(id, builder);
}
// Need to check whether anything was filled in to determine if data is present or not.
final D built = builder.build();
return built.equals(emptyValue) ? Collections.<D>emptyList() : Collections.singletonList(built);
}
@Nonnull
@Override
@SuppressWarnings("unchecked")
public List<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id) {
// This is read for one of children, we need to read and then filter, not parent)
// If this is target, just read
if (id.getTargetType().equals(getManagedDataObjectType().getTargetType())) {
return readCurrent((InstanceIdentifier<D>) id);
} else {
return readSubtree(id);
}
}
private List<? extends DataObject> readSubtree(final InstanceIdentifier<? extends DataObject> id) {
// Read only specific subtree
final Class<? extends DataObject> next = VppRWUtils.getNextId(id, getManagedDataObjectType()).getType();
final ChildVppReader<? extends ChildOf<D>> vppReader = childReaders.get(next);
if (vppReader != null) {
return vppReader.read(id);
} else {
// If there's no dedicated reader, use read current
final InstanceIdentifier<D> currentId = VppRWUtils.cutId(id, getManagedDataObjectType());
final List<D> current = readCurrent(currentId);
// then perform post-reading filtering (return only requested sub-node)
return current.isEmpty() ? current : filterSubtree(current, id, getManagedDataObjectType().getTargetType()) ;
}
}
/**
* Fill in current node's attributes
*
* @param id {@link InstanceIdentifier} pointing to current node. In case of keyed list, key must be present.
* @param builder Builder object for current node where the read attributes must be placed
*/
protected abstract void readCurrentAttributes(final InstanceIdentifier<D> id, B builder);
/**
* Return new instance of a builder object for current node
*
* @param id {@link InstanceIdentifier} pointing to current node. In case of keyed list, key must be present.
* @return Builder object for current node type
*/
protected abstract B getBuilder(InstanceIdentifier<D> id);
// TODO move filtering out of here into a dedicated Filter ifc
@Nonnull
private static List<? extends DataObject> filterSubtree(@Nonnull final List<? extends DataObject> built,
@Nonnull final InstanceIdentifier<? extends DataObject> absolutPath,
@Nonnull final Class<?> managedType) {
// TODO is there a better way than reflection ? e.g. convert into NN and filter out with a utility
// FIXME this needs to be recursive. right now it expects only 1 additional element in ID + test
List<DataObject> filtered = Lists.newArrayList();
for (DataObject parent : built) {
final InstanceIdentifier.PathArgument nextId =
VppRWUtils.getNextId(absolutPath, InstanceIdentifier.create(parent.getClass()));
Optional<Method> method = ReflectionUtils.findMethodReflex(managedType, "get",
Collections.<Class<?>>emptyList(), nextId.getType());
if (method.isPresent()) {
filterSingle(filtered, parent, nextId, method);
} else {
// List child nodes
method = ReflectionUtils.findMethodReflex(managedType,
"get" + nextId.getType().getSimpleName(), Collections.<Class<?>>emptyList(), List.class);
if (method.isPresent()) {
filterList(filtered, parent, nextId, method);
} else {
throw new IllegalStateException(
"Unable to filter " + nextId + " from " + parent + " getters not found using reflexion");
}
}
}
return filtered;
}
@SuppressWarnings("unchecked")
private static void filterList(final List<DataObject> filtered, final DataObject parent,
final InstanceIdentifier.PathArgument nextId, final Optional<Method> method) {
final List<? extends DataObject> invoke = (List<? extends DataObject>)invoke(method.get(), nextId, parent);
if (nextId instanceof InstanceIdentifier.IdentifiableItem<?, ?>) {
final Identifier key = ((InstanceIdentifier.IdentifiableItem) nextId).getKey();
filtered.addAll(Collections2.filter(invoke, new Predicate<DataObject>() {
@Override
public boolean apply(@Nullable final DataObject input) {
final Optional<Method> keyGetter =
ReflectionUtils.findMethodReflex(nextId.getType(), "get",
Collections.<Class<?>>emptyList(), key.getClass());
final Object actualKey;
actualKey = invoke(keyGetter.get(), nextId, input);
return key.equals(actualKey);
}
}));
} else {
filtered.addAll(invoke);
}
}
private static void filterSingle(final List<DataObject> filtered, final DataObject parent,
final InstanceIdentifier.PathArgument nextId, final Optional<Method> method) {
filtered.add(nextId.getType().cast(invoke(method.get(), nextId, parent)));
}
private static Object invoke(final Method method,
final InstanceIdentifier.PathArgument nextId, final DataObject parent) {
try {
return method.invoke(parent);
} catch (IllegalAccessException | InvocationTargetException e) {
throw new IllegalArgumentException("Unable to get " + nextId + " from " + parent, e);
}
}
}
|
