opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/StoreUtils.java

   1 package org.opendaylight.controller.md.sal.dom.store.impl;
   2
   3 import java.util.Collections;
   4 import java.util.Map;
   5 import java.util.Set;
   6
   7 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
   8 import org.opendaylight.controller.md.sal.dom.store.impl.tree.StoreMetadataNode;
   9 import org.opendaylight.yangtools.concepts.Identifiable;
  10 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
  11 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier;
  12 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
  13 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
  14 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  15 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
  16
  17 import com.google.common.base.Function;
  18 import com.google.common.base.Strings;
  19 import com.google.common.collect.FluentIterable;
  20 import com.google.common.collect.ImmutableList;
  21 import com.google.common.collect.ImmutableMap;
  22 import com.google.common.primitives.UnsignedLong;
  23
  24 public final class StoreUtils {
  25
  26     private final static Function<Identifiable<Object>, Object> EXTRACT_IDENTIFIER = new Function<Identifiable<Object>, Object>() {
  27         @Override
  28         public Object apply(final Identifiable<Object> input) {
  29             return input.getIdentifier();
  30         }
  31     };
  32
  33     public static final UnsignedLong increase(final UnsignedLong original) {
  34         return original.plus(UnsignedLong.ONE);
  35     }
  36
  37     public static final InstanceIdentifier append(final InstanceIdentifier parent, final PathArgument arg) {
  38
  39         return new InstanceIdentifier(ImmutableList.<PathArgument> builder().addAll(parent.getPath()).add(arg).build());
  40     }
  41
  42     public static AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> initialChangeEvent(
  43             final InstanceIdentifier path, final StoreMetadataNode data) {
  44         return new InitialDataChangeEvent(path, data.getData());
  45     }
  46
  47     /*
  48      * Suppressing warnings here allows us to fool the compiler enough
  49      * such that we can reuse a single function for all applicable types
  50      * and present it in a type-safe manner to our users.
  51      */
  52     @SuppressWarnings({ "unchecked", "rawtypes" })
  53     public static <V> Function<Identifiable<V>, V> identifierExtractor() {
  54         return (Function) EXTRACT_IDENTIFIER;
  55     }
  56
  57     private static final class InitialDataChangeEvent implements
  58             AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> {
  59
  60         private final ImmutableMap<InstanceIdentifier, NormalizedNode<?, ?>> payload;
  61         private final NormalizedNode<?, ?> data;
  62
  63         public InitialDataChangeEvent(final InstanceIdentifier path, final NormalizedNode<?, ?> data) {
  64             payload = ImmutableMap.<InstanceIdentifier, NormalizedNode<?, ?>> of(path, data);
  65             this.data = data;
  66         }
  67
  68         @Override
  69         public Map<InstanceIdentifier, NormalizedNode<?, ?>> getCreatedData() {
  70             return payload;
  71         }
  72
  73         @Override
  74         public Map<InstanceIdentifier, ? extends NormalizedNode<?, ?>> getOriginalData() {
  75             return Collections.emptyMap();
  76         }
  77
  78         @Override
  79         public NormalizedNode<?, ?> getOriginalSubtree() {
  80             return null;
  81         }
  82
  83         @Override
  84         public Set<InstanceIdentifier> getRemovedPaths() {
  85             return Collections.emptySet();
  86         }
  87
  88         @Override
  89         public Map<InstanceIdentifier, NormalizedNode<?, ?>> getUpdatedData() {
  90             return payload;
  91         }
  92
  93         @Override
  94         public NormalizedNode<?, ?> getUpdatedSubtree() {
  95             return data;
  96         }
  97     }
  98
  99     public static <V> Set<V> toIdentifierSet(final Iterable<? extends Identifiable<V>> children) {
 100         return FluentIterable.from(children).transform(StoreUtils.<V> identifierExtractor()).toSet();
 101     }
 102
 103     public static String toStringTree(final StoreMetadataNode metaNode) {
 104         StringBuilder builder = new StringBuilder();
 105         toStringTree(builder, metaNode, 0);
 106         return builder.toString();
 107     }
 108
 109     private static void toStringTree(final StringBuilder builder, final StoreMetadataNode metaNode, final int offset) {
 110         String prefix = Strings.repeat(" ", offset);
 111         builder.append(prefix).append(toStringTree(metaNode.getIdentifier()));
 112         NormalizedNode<?, ?> dataNode = metaNode.getData();
 113         if (dataNode instanceof NormalizedNodeContainer<?, ?, ?>) {
 114             builder.append(" {\n");
 115             for (StoreMetadataNode child : metaNode.getChildren()) {
 116                 toStringTree(builder, child, offset + 4);
 117             }
 118             builder.append(prefix).append('}');
 119         } else {
 120             builder.append(' ').append(dataNode.getValue());
 121         }
 122         builder.append('\n');
 123     }
 124
 125     private static String toStringTree(final PathArgument identifier) {
 126         if (identifier instanceof NodeIdentifierWithPredicates) {
 127             StringBuilder builder = new StringBuilder();
 128             builder.append(identifier.getNodeType().getLocalName());
 129             builder.append(((NodeIdentifierWithPredicates) identifier).getKeyValues().values());
 130             return builder.toString();
 131         } else if (identifier instanceof AugmentationIdentifier) {
 132             return "augmentation";
 133         }
 134         return identifier.getNodeType().getLocalName();
 135     }
 136 }