summaryrefslogtreecommitdiffstats
path: root/infra/translate-utils/src/main/java
diff options
context:
space:
mode:
authorMaros Marsalek <mmarsale@cisco.com>2016-11-08 10:13:36 +0100
committerMaros Marsalek <mmarsale@cisco.com>2016-11-08 13:17:57 +0100
commit757222979bc02d0aaba1870eea36413383d15bde (patch)
tree3fe2a502026fbfa9a4ae5627e1a453a057f6c1fa /infra/translate-utils/src/main/java
parent03a638b95da83e150d4f69451c8733b5f09c37aa (diff)
HONEYCOMB-270 Add isPresent() to Readers/Customizers
So that they can influence whether empty data is to be considered as present + Move registries implementations from util to impl + Introduce DelegatingReader trait + Extend GenericReader where possible to reduce duplication Change-Id: I5a416acd0c4eab1fbc30fcbe585719991dbe9215 Signed-off-by: Maros Marsalek <mmarsale@cisco.com>
Diffstat (limited to 'infra/translate-utils/src/main/java')
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/AbstractGenericReader.java9
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/BindingBrokerReader.java5
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/DelegatingReader.java103
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/KeepaliveReaderWrapper.java40
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/ReflexiveReader.java57
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/ReflexiveReaderCustomizer.java2
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReader.java241
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistry.java131
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistryBuilder.java114
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/InitSubtreeReader.java72
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/SubtreeReader.java241
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/TypeHierarchy.java101
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistry.java314
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistryBuilder.java71
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/SubtreeWriter.java85
15 files changed, 120 insertions, 1466 deletions
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/AbstractGenericReader.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/AbstractGenericReader.java
index 40c78b3c9..b19b72ecf 100644
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/AbstractGenericReader.java
+++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/AbstractGenericReader.java
@@ -56,18 +56,15 @@ public abstract class AbstractGenericReader<D extends DataObject, B extends Buil
@Nonnull final ReadContext ctx) throws ReadFailedException {
LOG.debug("{}: Reading current: {}", this, id);
final B builder = getBuilder(id);
- // The empty value could be cached, but no caching is safer since we call overridden getBuilder each time
- // and the build could produce something different (even if it shouldn't)
- final D emptyValue = builder.build();
LOG.trace("{}: Reading current attributes", this);
readCurrentAttributes(id, builder, ctx);
// Need to check whether anything was filled in to determine if data is present or not.
final D built = builder.build();
- final Optional<D> read = built.equals(emptyValue)
- ? Optional.absent()
- : Optional.of(built);
+ final Optional<D> read = isPresent(id, built, ctx)
+ ? Optional.of(built)
+ : Optional.absent();
LOG.debug("{}: Current node read successfully. Result: {}", this, read);
return read;
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/BindingBrokerReader.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/BindingBrokerReader.java
index b7a38e97f..e59e642c4 100644
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/BindingBrokerReader.java
+++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/BindingBrokerReader.java
@@ -50,6 +50,11 @@ public final class BindingBrokerReader<D extends DataObject, B extends Builder<D
this.datastoreType = datastoreType;
}
+ @Override
+ public boolean isPresent(final InstanceIdentifier<D> id, final D built, final ReadContext ctx) {
+ throw new UnsupportedOperationException("Not supported");
+ }
+
@Nonnull
@Override
public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id,
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/DelegatingReader.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/DelegatingReader.java
new file mode 100644
index 000000000..513639610
--- /dev/null
+++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/DelegatingReader.java
@@ -0,0 +1,103 @@
+/*
+ * 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.translate.util.read;
+
+import com.google.common.base.Optional;
+import io.fd.honeycomb.translate.read.ListReader;
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.read.Reader;
+import java.util.List;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.concepts.Builder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.Identifiable;
+import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+/**
+ * A trait of a delegating reader. Delegates all the calls to its delegate.
+ */
+public interface DelegatingReader<D extends DataObject, B extends Builder<D>> extends Reader<D, B> {
+
+ Reader<D, B> getDelegate();
+
+ @Nonnull
+ default Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id,
+ @Nonnull final ReadContext ctx) throws ReadFailedException {
+ return getDelegate().read(id, ctx);
+ }
+
+ default void readCurrentAttributes(@Nonnull final InstanceIdentifier<D> id,
+ @Nonnull final B builder,
+ @Nonnull final ReadContext ctx) throws ReadFailedException {
+ getDelegate().readCurrentAttributes(id, builder, ctx);
+ }
+
+ @Nonnull
+ default B getBuilder(final InstanceIdentifier<D> id) {
+ return getDelegate().getBuilder(id);
+ }
+
+ default void merge(@Nonnull final Builder<? extends DataObject> parentBuilder,
+ @Nonnull final D readValue) {
+ getDelegate().merge(parentBuilder, readValue);
+ }
+
+ @Override
+ default boolean isPresent(InstanceIdentifier<D> id, D built, final ReadContext ctx) throws ReadFailedException {
+ return getDelegate().isPresent(id, built, ctx);
+ }
+
+ @Nonnull
+ default InstanceIdentifier<D> getManagedDataObjectType() {
+ return getDelegate().getManagedDataObjectType();
+ }
+
+ /**
+ * ListReader specific delegating trait.
+ */
+ interface DelegatingListReader<D extends DataObject & Identifiable<K>, K extends Identifier<D>, B extends Builder<D>>
+ extends DelegatingReader<D, B>, ListReader<D, K, B> {
+
+ ListReader<D, K, B> getDelegate();
+
+ @Override
+ default List<K> getAllIds(@Nonnull InstanceIdentifier<D> id, @Nonnull ReadContext ctx)
+ throws ReadFailedException {
+ return getDelegate().getAllIds(id, ctx);
+ }
+
+ @Nonnull
+ @Override
+ default List<D> readList(@Nonnull final InstanceIdentifier<D> id, @Nonnull final ReadContext ctx)
+ throws ReadFailedException {
+ return getDelegate().readList(id, ctx);
+ }
+
+ @Override
+ default void merge(@Nonnull final Builder<? extends DataObject> builder,
+ @Nonnull final List<D> readData) {
+ getDelegate().merge(builder, readData);
+ }
+
+ @Override
+ default void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final D readValue) {
+ getDelegate().merge(parentBuilder, readValue);
+ }
+ }
+}
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/KeepaliveReaderWrapper.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/KeepaliveReaderWrapper.java
index 5ab9bc59e..9a695a53c 100644
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/KeepaliveReaderWrapper.java
+++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/KeepaliveReaderWrapper.java
@@ -18,11 +18,10 @@ package io.fd.honeycomb.translate.util.read;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import io.fd.honeycomb.translate.read.ReadContext;
-import io.fd.honeycomb.translate.read.Reader;
import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.ModificationCache;
-import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.read.Reader;
import java.io.Closeable;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
@@ -40,7 +39,7 @@ import org.slf4j.LoggerFactory;
* In case a specific error occurs, Keep-alive failure listener gets notified.
*/
public final class KeepaliveReaderWrapper<D extends DataObject, B extends Builder<D>>
- implements Reader<D, B>, Runnable, Closeable {
+ implements DelegatingReader<D, B>,Runnable, Closeable {
private static final Logger LOG = LoggerFactory.getLogger(KeepaliveReaderWrapper.class);
@@ -73,34 +72,6 @@ public final class KeepaliveReaderWrapper<D extends DataObject, B extends Builde
scheduledFuture = executor.scheduleWithFixedDelay(this, delayInSeconds, delayInSeconds, TimeUnit.SECONDS);
}
- @Nonnull
- public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier id,
- @Nonnull final ReadContext ctx) throws ReadFailedException {
- return delegate.read(id, ctx);
- }
-
- public void readCurrentAttributes(@Nonnull final InstanceIdentifier<D> id,
- @Nonnull final B builder,
- @Nonnull final ReadContext ctx) throws ReadFailedException {
- delegate.readCurrentAttributes(id, builder, ctx);
- }
-
- @Nonnull
- public B getBuilder(final InstanceIdentifier<D> id) {
- return delegate.getBuilder(id);
- }
-
- public void merge(@Nonnull final Builder<? extends DataObject> parentBuilder,
- @Nonnull final D readValue) {
- delegate.merge(parentBuilder, readValue);
- }
-
- @Nonnull
- @Override
- public InstanceIdentifier<D> getManagedDataObjectType() {
- return delegate.getManagedDataObjectType();
- }
-
@Override
public void run() {
LOG.trace("Invoking keepalive");
@@ -123,6 +94,11 @@ public final class KeepaliveReaderWrapper<D extends DataObject, B extends Builde
scheduledFuture.cancel(false);
}
+ @Override
+ public Reader<D, B> getDelegate() {
+ return delegate;
+ }
+
/**
* Listener that gets called whenever keepalive fails as expected.
*/
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/ReflexiveReader.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/ReflexiveReader.java
deleted file mode 100644
index 2aa35514e..000000000
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/ReflexiveReader.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * 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.translate.util.read;
-
-import io.fd.honeycomb.translate.read.ReadContext;
-import io.fd.honeycomb.translate.read.ReadFailedException;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.concepts.Builder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-/**
- * Reader that performs no read operation on its own, just fills in the hierarchy.
- * <p/>
- * Might be slow due to reflection !
- */
-public class ReflexiveReader<C extends DataObject, B extends Builder<C>> extends AbstractGenericReader<C, B> {
-
- private final ReflexiveReaderCustomizer<C, B> customizer;
-
- public ReflexiveReader(final InstanceIdentifier<C> identifier, final Class<B> builderClass) {
- super(identifier);
- this.customizer = new ReflexiveReaderCustomizer<>(identifier.getTargetType(), builderClass);
- }
-
- @Override
- public void readCurrentAttributes(@Nonnull final InstanceIdentifier<C> id, @Nonnull final B builder,
- @Nonnull final ReadContext ctx)
- throws ReadFailedException {
- customizer.readCurrentAttributes(id, builder, ctx);
- }
-
- @Nonnull
- @Override
- public B getBuilder(final InstanceIdentifier<C> id) {
- return customizer.getBuilder(id);
- }
-
- @Override
- public void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final C readValue) {
- customizer.merge(parentBuilder, readValue);
- }
-}
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/ReflexiveReaderCustomizer.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/ReflexiveReaderCustomizer.java
index 18e6285f3..087873306 100644
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/ReflexiveReaderCustomizer.java
+++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/ReflexiveReaderCustomizer.java
@@ -33,7 +33,7 @@ import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
/**
* Might be slow.
*/
-class ReflexiveReaderCustomizer<C extends DataObject, B extends Builder<C>> extends NoopReaderCustomizer<C, B> {
+public class ReflexiveReaderCustomizer<C extends DataObject, B extends Builder<C>> extends NoopReaderCustomizer<C, B> {
private final Class<C> typeClass;
private final Class<B> builderClass;
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReader.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReader.java
deleted file mode 100644
index b52fd09ec..000000000
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReader.java
+++ /dev/null
@@ -1,241 +0,0 @@
-/*
- * 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.translate.util.read.registry;
-
-import static com.google.common.base.Preconditions.checkArgument;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Iterables;
-import io.fd.honeycomb.translate.read.InitFailedException;
-import io.fd.honeycomb.translate.read.InitListReader;
-import io.fd.honeycomb.translate.read.Initializer;
-import io.fd.honeycomb.translate.read.ListReader;
-import io.fd.honeycomb.translate.read.ReadContext;
-import io.fd.honeycomb.translate.read.ReadFailedException;
-import io.fd.honeycomb.translate.read.Reader;
-import io.fd.honeycomb.translate.util.RWUtils;
-import io.fd.honeycomb.translate.util.read.AbstractGenericReader;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.yangtools.concepts.Builder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-class CompositeReader<D extends DataObject, B extends Builder<D>>
- extends AbstractGenericReader<D, B>
- implements Initializer<D> {
-
- private static final Logger LOG = LoggerFactory.getLogger(CompositeReader.class);
-
- private final Reader<D, B> delegate;
- private final ImmutableMap<Class<?>, Reader<? extends DataObject, ? extends Builder<?>>> childReaders;
-
- private CompositeReader(final Reader<D, B> reader,
- final ImmutableMap<Class<?>, Reader<? extends DataObject, ? extends Builder<?>>> childReaders) {
- super(reader.getManagedDataObjectType());
- this.delegate = reader;
- this.childReaders = childReaders;
- }
-
- @VisibleForTesting
- ImmutableMap<Class<?>, Reader<? extends DataObject, ? extends Builder<?>>> getChildReaders() {
- return childReaders;
- }
-
- @SuppressWarnings("unchecked")
- public static <D extends DataObject> InstanceIdentifier<D> appendTypeToId(
- final InstanceIdentifier<? extends DataObject> parentId, final InstanceIdentifier<D> type) {
- final InstanceIdentifier.PathArgument t = new InstanceIdentifier.Item<>(type.getTargetType());
- return (InstanceIdentifier<D>) InstanceIdentifier.create(Iterables.concat(
- parentId.getPathArguments(), Collections.singleton(t)));
- }
-
- @Nonnull
- @Override
- public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id,
- @Nonnull final ReadContext ctx) throws ReadFailedException {
- if (shouldReadCurrent(id)) {
- LOG.trace("{}: Reading current: {}", this, id);
- return readCurrent((InstanceIdentifier<D>) id, ctx);
- } else if (shouldDelegateToChild(id)) {
- LOG.trace("{}: Reading child: {}", this, id);
- return readSubtree(id, ctx);
- } else {
- // Fallback
- LOG.trace("{}: Delegating read: {}", this, id);
- return delegate.read(id, ctx);
- }
- }
-
- private boolean shouldReadCurrent(@Nonnull final InstanceIdentifier<? extends DataObject> id) {
- return id.getTargetType().equals(getManagedDataObjectType().getTargetType());
- }
-
- private boolean shouldDelegateToChild(@Nonnull final InstanceIdentifier<? extends DataObject> id) {
- return childReaders.containsKey(RWUtils.getNextId(id, getManagedDataObjectType()).getType());
- }
-
- private Optional<? extends DataObject> readSubtree(final InstanceIdentifier<? extends DataObject> id,
- final ReadContext ctx) throws ReadFailedException {
- final InstanceIdentifier.PathArgument nextId = RWUtils.getNextId(id, getManagedDataObjectType());
- final Reader<?, ? extends Builder<?>> nextReader = childReaders.get(nextId.getType());
- checkArgument(nextReader != null, "Unable to read: %s. No delegate present, available readers at next level: %s",
- id, childReaders.keySet());
- return nextReader.read(id, ctx);
- }
-
- @SuppressWarnings("unchecked")
- private void readChildren(final InstanceIdentifier<D> id, @Nonnull final ReadContext ctx, final B builder)
- throws ReadFailedException {
- LOG.debug("{}: Reading children: {}", this, childReaders.keySet());
- for (Reader child : childReaders.values()) {
- final InstanceIdentifier childId = appendTypeToId(id, child.getManagedDataObjectType());
-
- LOG.debug("{}: Reading child from: {}", this, child);
- if (child instanceof ListReader) {
- final List<? extends DataObject> list = ((ListReader) child).readList(childId, ctx);
- // Dont set empty lists
- if (!list.isEmpty()) {
- ((ListReader) child).merge(builder, list);
- }
- } else {
- final Optional<? extends DataObject> read = child.read(childId, ctx);
- if (read.isPresent()) {
- child.merge(builder, read.get());
- }
- }
- }
- }
-
- @Override
- public void readCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final B builder,
- @Nonnull final ReadContext ctx)
- throws ReadFailedException {
- delegate.readCurrentAttributes(id, builder, ctx);
- readChildren(id, ctx, builder);
- }
-
- @Nonnull
- @Override
- public B getBuilder(final InstanceIdentifier<D> id) {
- return delegate.getBuilder(id);
- }
-
- @Override
- public void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final D readValue) {
- delegate.merge(parentBuilder, readValue);
- }
-
- /**
- * Wrap a Reader as a Composite Reader.
- */
- static <D extends DataObject, B extends Builder<D>> Reader<D, B> createForReader(
- @Nonnull final Reader<D, B> reader,
- @Nonnull final ImmutableMap<Class<?>, Reader<?, ? extends Builder<?>>> childReaders) {
-
- return (reader instanceof ListReader)
- ? new CompositeListReader<>((ListReader) reader, childReaders)
- : new CompositeReader<>(reader, childReaders);
- }
-
- @SuppressWarnings("unchecked")
- @Override
- public void init(final DataBroker broker, final InstanceIdentifier<D> id, final ReadContext ctx) throws InitFailedException {
- if (delegate instanceof Initializer) {
- LOG.trace("{}: Initializing current: {}", this, id);
- ((Initializer<D>) delegate).init(broker, id, ctx);
- }
-
- for (Reader child : childReaders.values()) {
- final InstanceIdentifier childId = appendTypeToId(id, child.getManagedDataObjectType());
-
- if (child instanceof Initializer) {
- LOG.trace("{}: Initializing child: {}", this, childId);
- ((Initializer) child).init(broker, childId, ctx);
- }
- }
- }
-
- private static class CompositeListReader<D extends DataObject & Identifiable<K>, B extends Builder<D>, K extends Identifier<D>>
- extends CompositeReader<D, B>
- implements InitListReader<D, K, B> {
-
- private final ListReader<D, K, B> delegate;
-
- private CompositeListReader(final ListReader<D, K, B> reader,
- final ImmutableMap<Class<?>, Reader<? extends DataObject, ? extends Builder<?>>> childReaders) {
- super(reader, childReaders);
- this.delegate = reader;
- }
-
- @Nonnull
- @Override
- public List<D> readList(@Nonnull final InstanceIdentifier<D> id, @Nonnull final ReadContext ctx)
- throws ReadFailedException {
- LOG.trace("{}: Reading all list entries", this);
- final List<K> allIds = delegate.getAllIds(id, ctx);
- LOG.debug("{}: Reading list entries for: {}", this, allIds);
-
- // Override read list in order to perform readCurrent + readChildren here
- final ArrayList<D> allEntries = new ArrayList<>(allIds.size());
- for (K key : allIds) {
- final InstanceIdentifier.IdentifiableItem<D, K> currentBdItem = RWUtils.getCurrentIdItem(id, key);
- final InstanceIdentifier<D> keyedId = RWUtils.replaceLastInId(id, currentBdItem);
- final Optional<D> read = readCurrent(keyedId, ctx);
- if (read.isPresent()) {
- final DataObject singleItem = read.get();
- checkArgument(getManagedDataObjectType().getTargetType().isAssignableFrom(singleItem.getClass()));
- allEntries.add(getManagedDataObjectType().getTargetType().cast(singleItem));
- }
- }
- return allEntries;
- }
-
- @Override
- public void init(final DataBroker broker, final InstanceIdentifier<D> id, final ReadContext ctx)
- throws InitFailedException {
- try {
- final List<K> allIds = delegate.getAllIds(id, ctx);
- for (K key : allIds) {
- super.init(broker, RWUtils.replaceLastInId(id, RWUtils.getCurrentIdItem(id, key)), ctx);
- }
- } catch (ReadFailedException e) {
- throw new InitFailedException(id, e);
- }
- }
-
- @Override
- public void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<D> readData) {
- delegate.merge(builder, readData);
- }
-
- @Override
- public List<K> getAllIds(@Nonnull final InstanceIdentifier<D> id,
- @Nonnull final ReadContext ctx) throws ReadFailedException {
- return delegate.getAllIds(id, ctx);
- }
- }
-}
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistry.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistry.java
deleted file mode 100644
index 9505a7730..000000000
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistry.java
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * 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.translate.util.read.registry;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.LinkedListMultimap;
-import com.google.common.collect.Multimap;
-import io.fd.honeycomb.translate.read.InitFailedException;
-import io.fd.honeycomb.translate.read.Initializer;
-import io.fd.honeycomb.translate.read.ListReader;
-import io.fd.honeycomb.translate.read.ReadContext;
-import io.fd.honeycomb.translate.read.ReadFailedException;
-import io.fd.honeycomb.translate.read.Reader;
-import io.fd.honeycomb.translate.read.registry.ReaderRegistry;
-import io.fd.honeycomb.translate.util.RWUtils;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.yangtools.concepts.Builder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Simple reader registry able to perform and aggregated read (ROOT read) on top of all provided readers. Also able to
- * delegate a specific read to one of the delegate readers.
- * <p/>
- * This could serve as a utility to hold & hide all available readers in upper layers.
- */
-public final class CompositeReaderRegistry implements ReaderRegistry {
-
- private static final Logger LOG = LoggerFactory.getLogger(CompositeReaderRegistry.class);
-
- private final Map<Class<? extends DataObject>, Reader<? extends DataObject, ? extends Builder<?>>> rootReaders;
-
- /**
- * Create new {@link CompositeReaderRegistry}.
- *
- * @param rootReaders List of delegate readers
- */
- public CompositeReaderRegistry(@Nonnull final List<Reader<? extends DataObject, ? extends Builder<?>>> rootReaders) {
- this.rootReaders = RWUtils.uniqueLinkedIndex(checkNotNull(rootReaders), RWUtils.MANAGER_CLASS_FUNCTION);
- }
-
- @VisibleForTesting
- Map<Class<? extends DataObject>, Reader<? extends DataObject, ? extends Builder<?>>> getRootReaders() {
- return rootReaders;
- }
-
- @Override
- @Nonnull
- public Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> readAll(
- @Nonnull final ReadContext ctx) throws ReadFailedException {
-
- LOG.debug("Reading from all delegates: {}", this);
- LOG.trace("Reading from all delegates: {}", rootReaders.values());
-
- final Multimap<InstanceIdentifier<? extends DataObject>, DataObject> objects = LinkedListMultimap.create();
- for (Reader<? extends DataObject, ? extends Builder<?>> rootReader : rootReaders.values()) {
- LOG.debug("Reading from delegate: {}", rootReader);
-
- if (rootReader instanceof ListReader) {
- final List<? extends DataObject> listEntries =
- ((ListReader) rootReader).readList(rootReader.getManagedDataObjectType(), ctx);
- if (!listEntries.isEmpty()) {
- objects.putAll(rootReader.getManagedDataObjectType(), listEntries);
- }
- } else {
- final Optional<? extends DataObject> read = rootReader.read(rootReader.getManagedDataObjectType(), ctx);
- if (read.isPresent()) {
- objects.putAll(rootReader.getManagedDataObjectType(), Collections.singletonList(read.get()));
- }
- }
- }
-
- return objects;
- }
-
-
- @Override
- public void initAll(@Nonnull final DataBroker broker, @Nonnull final ReadContext ctx) throws InitFailedException {
- for (Reader<? extends DataObject, ? extends Builder<?>> rootReader : rootReaders.values()) {
- if (rootReader instanceof Initializer<?>) {
- ((Initializer) rootReader).init(broker, rootReader.getManagedDataObjectType(), ctx);
- }
- }
- }
-
- @Nonnull
- @Override
- public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id,
- @Nonnull final ReadContext ctx)
- throws ReadFailedException {
- final InstanceIdentifier.PathArgument first = checkNotNull(
- Iterables.getFirst(id.getPathArguments(), null), "Empty id");
- final Reader<? extends DataObject, ? extends Builder<?>> reader = rootReaders.get(first.getType());
- checkNotNull(reader,
- "Unable to read %s. Missing reader. Current readers for: %s", id, rootReaders.keySet());
- LOG.debug("Reading from delegate: {}", reader);
- return reader.read(id, ctx);
- }
-
- @Override
- public String toString() {
- return getClass().getSimpleName()
- + rootReaders.keySet().stream().map(Class::getSimpleName).collect(Collectors.toList());
- }
-
-}
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistryBuilder.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistryBuilder.java
deleted file mode 100644
index da9bbe934..000000000
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistryBuilder.java
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * 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.translate.util.read.registry;
-
-import com.google.common.collect.ImmutableMap;
-import io.fd.honeycomb.translate.read.InitReader;
-import io.fd.honeycomb.translate.read.Reader;
-import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder;
-import io.fd.honeycomb.translate.read.registry.ReaderRegistry;
-import io.fd.honeycomb.translate.read.registry.ReaderRegistryBuilder;
-import io.fd.honeycomb.translate.util.AbstractSubtreeManagerRegistryBuilderBuilder;
-import io.fd.honeycomb.translate.util.read.ReflexiveReader;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
-import java.util.stream.Collectors;
-import javax.annotation.Nonnull;
-import javax.annotation.concurrent.NotThreadSafe;
-import org.opendaylight.yangtools.concepts.Builder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-@NotThreadSafe
-public final class CompositeReaderRegistryBuilder
- extends AbstractSubtreeManagerRegistryBuilderBuilder<Reader<? extends DataObject, ? extends Builder<?>>, ReaderRegistry>
- implements ModifiableReaderRegistryBuilder, ReaderRegistryBuilder {
-
- private static final Logger LOG = LoggerFactory.getLogger(CompositeReaderRegistryBuilder.class);
-
- @Override
- protected Reader<? extends DataObject, ? extends Builder<?>> getSubtreeHandler(@Nonnull final Set<InstanceIdentifier<?>> handledChildren,
- @Nonnull final Reader<? extends DataObject, ? extends Builder<?>> reader) {
- return reader instanceof InitReader
- ? InitSubtreeReader.createForReader(handledChildren, reader)
- : SubtreeReader.createForReader(handledChildren, reader);
- }
-
- @Override
- public <D extends DataObject> void addStructuralReader(@Nonnull InstanceIdentifier<D> id,
- @Nonnull Class<? extends Builder<D>> builderType) {
- add(new ReflexiveReader<>(id, builderType));
- }
-
-
-
- /**
- * Create {@link CompositeReaderRegistry} with Readers ordered according to submitted relationships.
- * <p/>
- * Note: The ordering only applies between nodes on the same level, inter-level and inter-subtree relationships are
- * ignored.
- */
- @Override
- public ReaderRegistry build() {
- ImmutableMap<InstanceIdentifier<?>, Reader<? extends DataObject, ? extends Builder<?>>> mappedReaders =
- getMappedHandlers();
- LOG.debug("Building Reader registry with Readers: {}",
- mappedReaders.keySet().stream()
- .map(InstanceIdentifier::getTargetType)
- .map(Class::getSimpleName)
- .collect(Collectors.joining(", ")));
-
- LOG.trace("Building Reader registry with Readers: {}", mappedReaders);
- final List<InstanceIdentifier<?>> readerOrder = new ArrayList<>(mappedReaders.keySet());
-
- // Wrap readers into composite readers recursively, collect roots and create registry
- final TypeHierarchy typeHierarchy = TypeHierarchy.create(mappedReaders.keySet());
- final List<Reader<? extends DataObject, ? extends Builder<?>>> orderedRootReaders =
- typeHierarchy.getRoots().stream()
- .map(rootId -> toCompositeReader(rootId, mappedReaders, typeHierarchy))
- .collect(Collectors.toList());
-
- // We are violating the ordering from mappedReaders, since we are forming a composite structure
- // but at least order root writers
- orderedRootReaders.sort((reader1, reader2) -> readerOrder.indexOf(reader1.getManagedDataObjectType())
- - readerOrder.indexOf(reader2.getManagedDataObjectType()));
-
- return new CompositeReaderRegistry(orderedRootReaders);
- }
-
- private Reader<? extends DataObject, ? extends Builder<?>> toCompositeReader(
- final InstanceIdentifier<?> instanceIdentifier,
- final ImmutableMap<InstanceIdentifier<?>, Reader<? extends DataObject, ? extends Builder<?>>> mappedReaders,
- final TypeHierarchy typeHierarchy) {
-
- // Order child readers according to the mappedReadersCollection
- final ImmutableMap.Builder<Class<?>, Reader<?, ? extends Builder<?>>> childReadersMapB = ImmutableMap.builder();
- for (InstanceIdentifier<?> childId : mappedReaders.keySet()) {
- if (typeHierarchy.getDirectChildren(instanceIdentifier).contains(childId)) {
- childReadersMapB.put(childId.getTargetType(), toCompositeReader(childId, mappedReaders, typeHierarchy));
- }
- }
-
- final ImmutableMap<Class<?>, Reader<?, ? extends Builder<?>>> childReadersMap = childReadersMapB.build();
- return childReadersMap.isEmpty()
- ? mappedReaders.get(instanceIdentifier)
- : CompositeReader.createForReader(mappedReaders.get(instanceIdentifier), childReadersMap);
- }
-}
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/InitSubtreeReader.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/InitSubtreeReader.java
deleted file mode 100644
index 4edc38f9d..000000000
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/InitSubtreeReader.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * 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.translate.util.read.registry;
-
-import io.fd.honeycomb.translate.read.InitFailedException;
-import io.fd.honeycomb.translate.read.InitListReader;
-import io.fd.honeycomb.translate.read.InitReader;
-import io.fd.honeycomb.translate.read.ListReader;
-import io.fd.honeycomb.translate.read.ReadContext;
-import io.fd.honeycomb.translate.read.Reader;
-import java.util.Set;
-import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.yangtools.concepts.Builder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-class InitSubtreeReader<O extends DataObject, B extends Builder<O>>
- extends SubtreeReader<O, B>
- implements InitReader<O, B> {
-
- private InitSubtreeReader(final InitReader<O, B> delegate,
- final Set<InstanceIdentifier<?>> handledTypes) {
- super(delegate, handledTypes);
- }
-
- @Override
- public void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx) throws InitFailedException {
- ((InitReader<O, B>) delegate).init(broker, id, ctx);
- }
-
- /**
- * Wrap a Reader as an initializing subtree Reader.
- */
- static <D extends DataObject, B extends Builder<D>> Reader<D, B> createForReader(@Nonnull final Set<InstanceIdentifier<?>> handledChildren,
- @Nonnull final Reader<D, B> reader) {
- return (reader instanceof ListReader)
- ? new InitSubtreeListReader<>((InitListReader) reader, handledChildren)
- : new InitSubtreeReader<>(((InitReader<D, B>) reader), handledChildren);
- }
-
- private static class InitSubtreeListReader<D extends DataObject & Identifiable<K>, B extends Builder<D>, K extends Identifier<D>>
- extends SubtreeListReader<D, B, K>
- implements InitListReader<D, K, B> {
-
- InitSubtreeListReader(final InitListReader<D, K, B> delegate,
- final Set<InstanceIdentifier<?>> handledTypes) {
- super(delegate, handledTypes);
- }
-
- @Override
- public void init(final DataBroker broker, final InstanceIdentifier<D> id, final ReadContext ctx) throws InitFailedException {
- ((InitListReader<D, K, B>) delegate).init(broker, id, ctx);
- }
- }
-}
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/SubtreeReader.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/SubtreeReader.java
deleted file mode 100644
index 3bc76b19a..000000000
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/SubtreeReader.java
+++ /dev/null
@@ -1,241 +0,0 @@
-/*
- * 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.translate.util.read.registry;
-
-import static com.google.common.base.Preconditions.checkArgument;
-
-import com.google.common.base.Optional;
-import com.google.common.collect.Iterables;
-import io.fd.honeycomb.translate.read.ListReader;
-import io.fd.honeycomb.translate.read.ReadContext;
-import io.fd.honeycomb.translate.read.ReadFailedException;
-import io.fd.honeycomb.translate.read.Reader;
-import io.fd.honeycomb.translate.util.RWUtils;
-import io.fd.honeycomb.translate.util.ReflectionUtils;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.concepts.Builder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Simple Reader delegate for subtree Readers (Readers handling also children nodes) providing a list of all the
- * children nodes being handled.
- */
-class SubtreeReader<D extends DataObject, B extends Builder<D>> implements Reader<D, B> {
-
- private static final Logger LOG = LoggerFactory.getLogger(SubtreeReader.class);
-
- protected final Reader<D, B> delegate;
- private final Set<InstanceIdentifier<?>> handledChildTypes = new HashSet<>();
-
- SubtreeReader(final Reader<D, B> delegate, Set<InstanceIdentifier<?>> handledTypes) {
- this.delegate = delegate;
- for (InstanceIdentifier<?> handledType : handledTypes) {
- // Iid has to start with Reader's handled root type
- checkArgument(delegate.getManagedDataObjectType().getTargetType().equals(
- handledType.getPathArguments().iterator().next().getType()),
- "Handled node from subtree has to be identified by an instance identifier starting from: %s."
- + "Instance identifier was: %s", getManagedDataObjectType().getTargetType(), handledType);
- checkArgument(Iterables.size(handledType.getPathArguments()) > 1,
- "Handled node from subtree identifier too short: %s", handledType);
- handledChildTypes.add(InstanceIdentifier.create(Iterables.concat(
- getManagedDataObjectType().getPathArguments(), Iterables.skip(handledType.getPathArguments(), 1))));
- }
- }
-
- /**
- * Return set of types also handled by this Reader. All of the types are children of the type managed by this Reader
- * excluding the type of this Reader.
- */
- Set<InstanceIdentifier<?>> getHandledChildTypes() {
- return handledChildTypes;
- }
-
- @Override
- @Nonnull
- public Optional<? extends DataObject> read(
- @Nonnull final InstanceIdentifier<? extends DataObject> id,
- @Nonnull final ReadContext ctx) throws ReadFailedException {
- final InstanceIdentifier<?> wildcarded = RWUtils.makeIidWildcarded(id);
-
- // Reading entire subtree and filtering if is current reader responsible
- if (getHandledChildTypes().contains(wildcarded)) {
- LOG.debug("{}: Subtree node managed by this writer requested: {}. Reading current and filtering", this, id);
- // If there's no dedicated reader, use read current
- final InstanceIdentifier<D> currentId = RWUtils.cutId(id, getManagedDataObjectType());
- final Optional<? extends DataObject> current = delegate.read(currentId, ctx);
- // then perform post-reading filtering (return only requested sub-node)
- final Optional<? extends DataObject> readSubtree = current.isPresent()
- ? filterSubtree(current.get(), id, getManagedDataObjectType().getTargetType())
- : current;
-
- LOG.debug("{}: Subtree: {} read successfully. Result: {}", this, id, readSubtree);
- return readSubtree;
-
- // If child that's handled here is not requested, then delegate should be able to handle the read
- } else {
- return delegate.read(id, ctx);
- }
- }
-
- @Override
- public void readCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final B builder,
- @Nonnull final ReadContext ctx)
- throws ReadFailedException {
- delegate.readCurrentAttributes(id, builder, ctx);
- }
-
- @Nonnull
- @Override
- public B getBuilder(final InstanceIdentifier<D> id) {
- return delegate.getBuilder(id);
- }
-
- @Override
- public void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final D readValue) {
- delegate.merge(parentBuilder, readValue);
- }
-
- @Nonnull
- private static Optional<? extends DataObject> filterSubtree(@Nonnull final DataObject parent,
- @Nonnull final InstanceIdentifier<? extends DataObject> absolutPath,
- @Nonnull final Class<?> managedType) {
- final InstanceIdentifier.PathArgument nextId =
- RWUtils.getNextId(absolutPath, InstanceIdentifier.create(parent.getClass()));
-
- final Optional<? extends DataObject> nextParent = findNextParent(parent, nextId, managedType);
-
- if (Iterables.getLast(absolutPath.getPathArguments()).equals(nextId)) {
- return nextParent; // we found the dataObject identified by absolutePath
- } else if (nextParent.isPresent()) {
- return filterSubtree(nextParent.get(), absolutPath, nextId.getType());
- } else {
- return nextParent; // we can't go further, return Optional.absent()
- }
- }
-
- private static Optional<? extends DataObject> findNextParent(@Nonnull final DataObject parent,
- @Nonnull final InstanceIdentifier.PathArgument nextId,
- @Nonnull final Class<?> managedType) {
- Optional<Method> method = ReflectionUtils.findMethodReflex(managedType, "get",
- Collections.emptyList(), nextId.getType());
-
- if (method.isPresent()) {
- return Optional.fromNullable(filterSingle(parent, nextId, method.get()));
- } else {
- // List child nodes
- method = ReflectionUtils.findMethodReflex(managedType,
- "get" + nextId.getType().getSimpleName(), Collections.emptyList(), List.class);
-
- if (method.isPresent()) {
- return filterList(parent, nextId, method.get());
- } else {
- throw new IllegalStateException(
- "Unable to filter " + nextId + " from " + parent + " getters not found using reflexion");
- }
- }
- }
-
- @SuppressWarnings("unchecked")
- private static Optional<? extends DataObject> filterList(final DataObject parent,
- final InstanceIdentifier.PathArgument nextId,
- final Method method) {
- final List<? extends DataObject> invoke = (List<? extends DataObject>) invoke(method, nextId, parent);
-
- checkArgument(nextId instanceof InstanceIdentifier.IdentifiableItem<?, ?>,
- "Unable to perform wildcarded read for %s", nextId);
- final Identifier key = ((InstanceIdentifier.IdentifiableItem) nextId).getKey();
-
- final Method keyGetter = ReflectionUtils.findMethodReflex(nextId.getType(), "get",
- Collections.emptyList(), key.getClass()).get();
-
- return Optional.fromNullable(invoke.stream()
- .filter(item -> key.equals(invoke(keyGetter, nextId, item)))
- .findFirst().orElse(null));
- }
-
- private static DataObject filterSingle(final DataObject parent,
- final InstanceIdentifier.PathArgument nextId, final Method method) {
- return nextId.getType().cast(invoke(method, 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);
- }
- }
-
- @Override
- @Nonnull
- public InstanceIdentifier<D> getManagedDataObjectType() {
- return delegate.getManagedDataObjectType();
- }
-
- /**
- * Wrap a Reader as a subtree Reader.
- */
- static <D extends DataObject, B extends Builder<D>> Reader<D, B> createForReader(@Nonnull final Set<InstanceIdentifier<?>> handledChildren,
- @Nonnull final Reader<D, B> reader) {
- return (reader instanceof ListReader)
- ? new SubtreeListReader<>((ListReader) reader, handledChildren)
- : new SubtreeReader<>(reader, handledChildren);
- }
-
- static class SubtreeListReader<D extends DataObject & Identifiable<K>, B extends Builder<D>, K extends Identifier<D>>
- extends SubtreeReader<D, B> implements ListReader<D, K, B> {
-
- final ListReader<D, K, B> delegate;
-
- SubtreeListReader(final ListReader<D, K, B> delegate,
- final Set<InstanceIdentifier<?>> handledTypes) {
- super(delegate, handledTypes);
- this.delegate = delegate;
- }
-
- @Nonnull
- @Override
- public List<D> readList(@Nonnull final InstanceIdentifier<D> id, @Nonnull final ReadContext ctx)
- throws ReadFailedException {
- return delegate.readList(id, ctx);
- }
-
- @Override
- public void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<D> readData) {
- delegate.merge(builder, readData);
- }
-
- @Override
- public List<K> getAllIds(@Nonnull final InstanceIdentifier<D> id,
- @Nonnull final ReadContext ctx) throws ReadFailedException {
- return delegate.getAllIds(id, ctx);
- }
- }
-
-}
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/TypeHierarchy.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/TypeHierarchy.java
deleted file mode 100644
index a30663221..000000000
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/TypeHierarchy.java
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * 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.translate.util.read.registry;
-
-import static com.google.common.base.Preconditions.checkArgument;
-
-import com.google.common.collect.Iterables;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Set;
-import java.util.stream.Collectors;
-import javax.annotation.Nonnull;
-import org.jgrapht.experimental.dag.DirectedAcyclicGraph;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-final class TypeHierarchy {
- private final DirectedAcyclicGraph<InstanceIdentifier<?>, Parent> hierarchy;
-
- private TypeHierarchy(@Nonnull final DirectedAcyclicGraph<InstanceIdentifier<?>, Parent> hierarchy) {
- this.hierarchy = hierarchy;
- }
-
- Set<InstanceIdentifier<?>> getAllChildren(InstanceIdentifier<?> id) {
- final HashSet<InstanceIdentifier<?>> instanceIdentifiers = new HashSet<>();
- for (InstanceIdentifier<?> childId : getDirectChildren(id)) {
- instanceIdentifiers.add(childId);
- instanceIdentifiers.addAll(getAllChildren(childId));
- }
- return instanceIdentifiers;
- }
-
- Set<InstanceIdentifier<?>> getDirectChildren(InstanceIdentifier<?> id) {
- checkArgument(hierarchy.vertexSet().contains(id),
- "Unknown reader: %s. Known readers: %s", id, hierarchy.vertexSet());
-
- return hierarchy.outgoingEdgesOf(id).stream()
- .map(hierarchy::getEdgeTarget)
- .collect(Collectors.toSet());
- }
-
- Set<InstanceIdentifier<?>> getRoots() {
- return hierarchy.vertexSet().stream()
- .filter(vertex -> hierarchy.incomingEdgesOf(vertex).size() == 0)
- .collect(Collectors.toSet());
- }
-
- /**
- * Create reader hierarchy from a flat set of instance identifiers.
- *
- * @param allIds Set of unkeyed instance identifiers
- */
- static TypeHierarchy create(@Nonnull Set<InstanceIdentifier<?>> allIds) {
- final DirectedAcyclicGraph<InstanceIdentifier<?>, Parent>
- readersHierarchy = new DirectedAcyclicGraph<>((sourceVertex, targetVertex) -> new Parent());
-
- for (InstanceIdentifier<?> allId : allIds) {
- checkArgument(!Iterables.isEmpty(allId.getPathArguments()), "Empty ID detected");
-
- if (Iterables.size(allId.getPathArguments()) == 1) {
- readersHierarchy.addVertex(allId);
- }
-
- List<InstanceIdentifier.PathArgument> pathArgs = new LinkedList<>();
- pathArgs.add(allId.getPathArguments().iterator().next());
-
- for (InstanceIdentifier.PathArgument pathArgument : Iterables.skip(allId.getPathArguments(), 1)) {
- final InstanceIdentifier<?> previous = InstanceIdentifier.create(pathArgs);
- pathArgs.add(pathArgument);
- final InstanceIdentifier<?> current = InstanceIdentifier.create(pathArgs);
-
- readersHierarchy.addVertex(previous);
- readersHierarchy.addVertex(current);
-
- try {
- readersHierarchy.addDagEdge(previous, current);
- } catch (DirectedAcyclicGraph.CycleFoundException e) {
- throw new IllegalArgumentException("Loop in hierarchy detected", e);
- }
- }
- }
-
- return new TypeHierarchy(readersHierarchy);
- }
-
- private static final class Parent{}
-}
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistry.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistry.java
deleted file mode 100644
index e5b829d6a..000000000
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistry.java
+++ /dev/null
@@ -1,314 +0,0 @@
-/*
- * 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.translate.util.write.registry;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static io.fd.honeycomb.translate.util.RWUtils.makeIidWildcarded;
-
-import com.google.common.base.Optional;
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Multimap;
-import com.google.common.collect.Sets;
-import io.fd.honeycomb.translate.TranslationException;
-import io.fd.honeycomb.translate.util.RWUtils;
-import io.fd.honeycomb.translate.write.DataObjectUpdate;
-import io.fd.honeycomb.translate.write.WriteContext;
-import io.fd.honeycomb.translate.write.WriteFailedException;
-import io.fd.honeycomb.translate.write.Writer;
-import io.fd.honeycomb.translate.write.registry.WriterRegistry;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.ThreadSafe;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Flat writer registry, delegating updates to writers in the order writers were submitted.
- */
-@ThreadSafe
-final class FlatWriterRegistry implements WriterRegistry {
-
- private static final Logger LOG = LoggerFactory.getLogger(FlatWriterRegistry.class);
-
- // All types handled by writers directly or as children
- private final ImmutableSet<InstanceIdentifier<?>> handledTypes;
-
- private final Set<InstanceIdentifier<?>> writersOrderReversed;
- private final Set<InstanceIdentifier<?>> writersOrder;
- private final Map<InstanceIdentifier<?>, Writer<?>> writers;
-
- /**
- * Create flat registry instance.
- *
- * @param writers immutable, ordered map of writers to use to process updates. Order of the writers has to be
- * one in which create and update operations should be handled. Deletes will be handled in reversed
- * order. All deletes are handled before handling all the updates.
- */
- FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writers) {
- this.writers = writers;
- this.writersOrderReversed = Sets.newLinkedHashSet(Lists.reverse(Lists.newArrayList(writers.keySet())));
- this.writersOrder = writers.keySet();
- this.handledTypes = getAllHandledTypes(writers);
- }
-
- private static ImmutableSet<InstanceIdentifier<?>> getAllHandledTypes(
- @Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writers) {
- final ImmutableSet.Builder<InstanceIdentifier<?>> handledTypesBuilder = ImmutableSet.builder();
- for (Map.Entry<InstanceIdentifier<?>, Writer<?>> writerEntry : writers.entrySet()) {
- final InstanceIdentifier<?> writerType = writerEntry.getKey();
- final Writer<?> writer = writerEntry.getValue();
- handledTypesBuilder.add(writerType);
- if (writer instanceof SubtreeWriter) {
- handledTypesBuilder.addAll(((SubtreeWriter<?>) writer).getHandledChildTypes());
- }
- }
- return handledTypesBuilder.build();
- }
-
- @Override
- public void update(@Nonnull final DataObjectUpdates updates,
- @Nonnull final WriteContext ctx) throws TranslationException {
- if (updates.isEmpty()) {
- return;
- }
-
- // Optimization
- if (updates.containsOnlySingleType()) {
- // First process delete
- singleUpdate(updates.getDeletes(), ctx);
- // Next is update
- singleUpdate(updates.getUpdates(), ctx);
- } else {
- // First process deletes
- bulkUpdate(updates.getDeletes(), ctx, true, writersOrderReversed);
- // Next are updates
- bulkUpdate(updates.getUpdates(), ctx, true, writersOrder);
- }
-
- LOG.debug("Update successful for types: {}", updates.getTypeIntersection());
- LOG.trace("Update successful for: {}", updates);
- }
-
- private void singleUpdate(@Nonnull final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates,
- @Nonnull final WriteContext ctx) throws WriteFailedException {
- if (updates.isEmpty()) {
- return;
- }
-
- final InstanceIdentifier<?> singleType = updates.keySet().iterator().next();
- LOG.debug("Performing single type update for: {}", singleType);
- Collection<? extends DataObjectUpdate> singleTypeUpdates = updates.get(singleType);
- Writer<?> writer = getWriter(singleType);
-
- if (writer == null) {
- // This node must be handled by a subtree writer, find it and call it or else fail
- checkArgument(handledTypes.contains(singleType), "Unable to process update. Missing writers for: %s",
- singleType);
- writer = getSubtreeWriterResponsible(singleType);
- singleTypeUpdates = getParentDataObjectUpdate(ctx, updates, writer);
- }
-
- LOG.trace("Performing single type update with writer: {}", writer);
- for (DataObjectUpdate singleUpdate : singleTypeUpdates) {
- writer.update(singleUpdate.getId(), singleUpdate.getDataBefore(), singleUpdate.getDataAfter(), ctx);
- }
- }
-
- private Writer<?> getSubtreeWriterResponsible(final InstanceIdentifier<?> singleType) {
- return writers.values().stream()
- .filter(w -> w instanceof SubtreeWriter)
- .filter(w -> ((SubtreeWriter<?>) w).getHandledChildTypes().contains(singleType))
- .findFirst()
- .get();
- }
-
- private Collection<DataObjectUpdate> getParentDataObjectUpdate(final WriteContext ctx,
- final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates,
- final Writer<?> writer) {
- // Now read data for subtree reader root, but first keyed ID is needed and that ID can be cut from updates
- InstanceIdentifier<?> firstAffectedChildId = ((SubtreeWriter<?>) writer).getHandledChildTypes().stream()
- .filter(updates::containsKey)
- .map(unkeyedId -> updates.get(unkeyedId))
- .flatMap(doUpdates -> doUpdates.stream())
- .map(DataObjectUpdate::getId)
- .findFirst()
- .get();
-
- final InstanceIdentifier<?> parentKeyedId =
- RWUtils.cutId(firstAffectedChildId, writer.getManagedDataObjectType());
-
- final Optional<? extends DataObject> parentBefore = ctx.readBefore(parentKeyedId);
- final Optional<? extends DataObject> parentAfter = ctx.readAfter(parentKeyedId);
- return Collections.singleton(
- DataObjectUpdate.create(parentKeyedId, parentBefore.orNull(), parentAfter.orNull()));
- }
-
- private void bulkUpdate(@Nonnull final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates,
- @Nonnull final WriteContext ctx,
- final boolean attemptRevert,
- @Nonnull final Set<InstanceIdentifier<?>> writersOrder) throws BulkUpdateException {
- if (updates.isEmpty()) {
- return;
- }
-
- LOG.debug("Performing bulk update with revert attempt: {} for: {}", attemptRevert, updates.keySet());
-
- // Check that all updates can be handled
- checkAllTypesCanBeHandled(updates);
-
- // Capture all changes successfully processed in case revert is needed
- final Set<InstanceIdentifier<?>> processedNodes = new HashSet<>();
-
- // Iterate over all writers and call update if there are any related updates
- for (InstanceIdentifier<?> writerType : writersOrder) {
- Collection<? extends DataObjectUpdate> writersData = updates.get(writerType);
- final Writer<?> writer = getWriter(writerType);
-
- if (writersData.isEmpty()) {
- // If there are no data for current writer, but it is a SubtreeWriter and there are updates to
- // its children, still invoke it with its root data
- if (writer instanceof SubtreeWriter<?> && isAffected(((SubtreeWriter<?>) writer), updates)) {
- // Provide parent data for SubtreeWriter for further processing
- writersData = getParentDataObjectUpdate(ctx, updates, writer);
- } else {
- // Skipping unaffected writer
- // Alternative to this would be modification sort according to the order of writers
- continue;
- }
- }
-
- LOG.debug("Performing update for: {}", writerType);
- LOG.trace("Performing update with writer: {}", writer);
-
- for (DataObjectUpdate singleUpdate : writersData) {
- try {
- writer.update(singleUpdate.getId(), singleUpdate.getDataBefore(), singleUpdate.getDataAfter(), ctx);
- processedNodes.add(singleUpdate.getId());
- LOG.trace("Update successful for type: {}", writerType);
- LOG.debug("Update successful for: {}", singleUpdate);
- } catch (Exception e) {
- // do not log this exception here,its logged in ModifiableDataTreeDelegator
-
- final Reverter reverter = attemptRevert
- ? new ReverterImpl(processedNodes, updates, writersOrder)
- : (final WriteContext writeContext) -> {};//NOOP reverter
-
- // Find out which changes left unprocessed
- final Set<InstanceIdentifier<?>> unprocessedChanges = updates.values().stream()
- .map(DataObjectUpdate::getId)
- .filter(id -> !processedNodes.contains(id))
- .collect(Collectors.toSet());
- throw new BulkUpdateException(unprocessedChanges, reverter, e);
- }
- }
- }
- }
-
- private void checkAllTypesCanBeHandled(
- @Nonnull final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates) {
- if (!handledTypes.containsAll(updates.keySet())) {
- final Sets.SetView<InstanceIdentifier<?>> missingWriters = Sets.difference(updates.keySet(), handledTypes);
- LOG.warn("Unable to process update. Missing writers for: {}", missingWriters);
- throw new IllegalArgumentException("Unable to process update. Missing writers for: " + missingWriters);
- }
- }
-
- /**
- * Check whether {@link SubtreeWriter} is affected by the updates.
- *
- * @return true if there are any updates to SubtreeWriter's child nodes (those marked by SubtreeWriter
- * as being taken care of)
- * */
- private static boolean isAffected(final SubtreeWriter<?> writer,
- final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates) {
- return !Sets.intersection(writer.getHandledChildTypes(), updates.keySet()).isEmpty();
- }
-
- @Nullable
- private Writer<?> getWriter(@Nonnull final InstanceIdentifier<?> singleType) {
- return writers.get(singleType);
- }
-
- private final class ReverterImpl implements Reverter {
-
- private final Collection<InstanceIdentifier<?>> processedNodes;
- private final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates;
- private final Set<InstanceIdentifier<?>> revertDeleteOrder;
-
- ReverterImpl(final Collection<InstanceIdentifier<?>> processedNodes,
- final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates,
- final Set<InstanceIdentifier<?>> writersOrderOriginal) {
- this.processedNodes = processedNodes;
- this.updates = updates;
- // Use opposite ordering when executing revert
- this.revertDeleteOrder = writersOrderOriginal == FlatWriterRegistry.this.writersOrder
- ? FlatWriterRegistry.this.writersOrderReversed
- : FlatWriterRegistry.this.writersOrder;
- }
-
- @Override
- public void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException {
- checkNotNull(writeContext, "Cannot revert changes for null context");
-
- Multimap<InstanceIdentifier<?>, DataObjectUpdate> updatesToRevert =
- filterAndRevertProcessed(updates, processedNodes);
-
- LOG.info("Attempting revert for changes: {}", updatesToRevert);
- try {
- // Perform reversed bulk update without revert attempt
- bulkUpdate(updatesToRevert, writeContext, true, revertDeleteOrder);
- LOG.info("Revert successful");
- } catch (BulkUpdateException e) {
- LOG.error("Revert failed", e);
- throw new RevertFailedException(e.getFailedIds(), e);
- }
- }
-
- /**
- * Create new updates map, but only keep already processed changes. Switching before and after data for each
- * update.
- */
- private Multimap<InstanceIdentifier<?>, DataObjectUpdate> filterAndRevertProcessed(
- final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates,
- final Collection<InstanceIdentifier<?>> processedNodes) {
- final Multimap<InstanceIdentifier<?>, DataObjectUpdate> filtered = HashMultimap.create();
- for (InstanceIdentifier<?> processedNode : processedNodes) {
- final InstanceIdentifier<?> wildcardedIid = makeIidWildcarded(processedNode);
- if (updates.containsKey(wildcardedIid)) {
- updates.get(wildcardedIid).stream()
- .filter(dataObjectUpdate -> processedNode.contains(dataObjectUpdate.getId()))
- // putting under unkeyed identifier, to prevent failing of checkAllTypesCanBeHandled
- .forEach(dataObjectUpdate -> filtered.put(wildcardedIid, dataObjectUpdate.reverse()));
- }
- }
- return filtered;
- }
- }
-
-}
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistryBuilder.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistryBuilder.java
deleted file mode 100644
index 0f75de7e7..000000000
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistryBuilder.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * 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.translate.util.write.registry;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.collect.ImmutableMap;
-import io.fd.honeycomb.translate.write.registry.WriterRegistryBuilder;
-import io.fd.honeycomb.translate.util.AbstractSubtreeManagerRegistryBuilderBuilder;
-import io.fd.honeycomb.translate.write.Writer;
-import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder;
-import io.fd.honeycomb.translate.write.registry.WriterRegistry;
-import java.util.Set;
-import java.util.stream.Collectors;
-import javax.annotation.Nonnull;
-import javax.annotation.concurrent.NotThreadSafe;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Builder for {@link FlatWriterRegistry} allowing users to specify inter-writer relationships.
- */
-@NotThreadSafe
-public final class FlatWriterRegistryBuilder
- extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry>
- implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder {
-
- private static final Logger LOG = LoggerFactory.getLogger(FlatWriterRegistryBuilder.class);
-
- @Override
- protected Writer<? extends DataObject> getSubtreeHandler(final @Nonnull Set<InstanceIdentifier<?>> handledChildren,
- final @Nonnull Writer<? extends DataObject> writer) {
- return SubtreeWriter.createForWriter(handledChildren, writer);
- }
-
- /**
- * Create FlatWriterRegistry with writers ordered according to submitted relationships.
- */
- @Override
- public WriterRegistry build() {
- final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters = getMappedHandlers();
- LOG.debug("Building writer registry with writers: {}",
- mappedWriters.keySet().stream()
- .map(InstanceIdentifier::getTargetType)
- .map(Class::getSimpleName)
- .collect(Collectors.joining(", ")));
- LOG.trace("Building writer registry with writers: {}", mappedWriters);
- return new FlatWriterRegistry(mappedWriters);
- }
-
- @VisibleForTesting
- @Override
- protected ImmutableMap<InstanceIdentifier<?>, Writer<? extends DataObject>> getMappedHandlers() {
- return super.getMappedHandlers();
- }
-}
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/SubtreeWriter.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/SubtreeWriter.java
deleted file mode 100644
index bab1da16f..000000000
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/SubtreeWriter.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * 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.translate.util.write.registry;
-
-import static com.google.common.base.Preconditions.checkArgument;
-
-import com.google.common.collect.Iterables;
-import io.fd.honeycomb.translate.write.WriteContext;
-import io.fd.honeycomb.translate.write.WriteFailedException;
-import io.fd.honeycomb.translate.write.Writer;
-import java.util.HashSet;
-import java.util.Set;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-/**
- * Simple writer delegate for subtree writers (writers handling also children nodes) providing a list of all the
- * children nodes being handled.
- */
-final class SubtreeWriter<D extends DataObject> implements Writer<D> {
-
- private final Writer<D> delegate;
- private final Set<InstanceIdentifier<?>> handledChildTypes = new HashSet<>();
-
- private SubtreeWriter(final Writer<D> delegate, Set<InstanceIdentifier<?>> handledTypes) {
- this.delegate = delegate;
- for (InstanceIdentifier<?> handledType : handledTypes) {
- // Iid has to start with writer's handled root type
- checkArgument(delegate.getManagedDataObjectType().getTargetType().equals(
- handledType.getPathArguments().iterator().next().getType()),
- "Handled node from subtree has to be identified by an instance identifier starting from: %s."
- + "Instance identifier was: %s", getManagedDataObjectType().getTargetType(), handledType);
- checkArgument(Iterables.size(handledType.getPathArguments()) > 1,
- "Handled node from subtree identifier too short: %s", handledType);
- handledChildTypes.add(InstanceIdentifier.create(Iterables.concat(
- getManagedDataObjectType().getPathArguments(), Iterables.skip(handledType.getPathArguments(), 1))));
- }
- }
-
- /**
- * Return set of types also handled by this writer. All of the types are children of the type managed by this
- * writer excluding the type of this writer.
- */
- Set<InstanceIdentifier<?>> getHandledChildTypes() {
- return handledChildTypes;
- }
-
- @Override
- public void update(
- @Nonnull final InstanceIdentifier<? extends DataObject> id,
- @Nullable final DataObject dataBefore,
- @Nullable final DataObject dataAfter, @Nonnull final WriteContext ctx) throws WriteFailedException {
- delegate.update(id, dataBefore, dataAfter, ctx);
- }
-
- @Override
- @Nonnull
- public InstanceIdentifier<D> getManagedDataObjectType() {
- return delegate.getManagedDataObjectType();
- }
-
- /**
- * Wrap a writer as a subtree writer.
- */
- static Writer<?> createForWriter(@Nonnull final Set<InstanceIdentifier<?>> handledChildren,
- @Nonnull final Writer<? extends DataObject> writer) {
- return new SubtreeWriter<>(writer, handledChildren);
- }
-}