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
  28         @Override
  29         public Object apply(final Identifiable<Object> input) {
  30             return input.getIdentifier();
  31         }
  32     };
  33
  34     public static final UnsignedLong increase(final UnsignedLong original) {
  35         return original.plus(UnsignedLong.ONE);
  36     }
  37
  38     public static final InstanceIdentifier append(final InstanceIdentifier parent, final PathArgument arg) {
  39
  40         return new InstanceIdentifier(ImmutableList.<PathArgument> builder().addAll(parent.getPath()).add(arg).build());
  41     }
  42
  43     public static AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> initialChangeEvent(
  44             final InstanceIdentifier path, final StoreMetadataNode data) {
  45         return new InitialDataChangeEvent(path, data.getData());
  46     }
  47
  48     @SuppressWarnings({ "unchecked", "rawtypes" })
  49     public static <V> Function<Identifiable<V>, V> identifierExtractor() {
  50         return (Function) EXTRACT_IDENTIFIER;
  51     }
  52
  53     private static final class InitialDataChangeEvent implements
  54             AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> {
  55
  56         private final ImmutableMap<InstanceIdentifier, NormalizedNode<?, ?>> payload;
  57         private final NormalizedNode<?, ?> data;
  58
  59         public InitialDataChangeEvent(final InstanceIdentifier path, final NormalizedNode<?, ?> data) {
  60             payload = ImmutableMap.<InstanceIdentifier, NormalizedNode<?, ?>> of(path, data);
  61             this.data = data;
  62         }
  63
  64         @Override
  65         public Map<InstanceIdentifier, NormalizedNode<?, ?>> getCreatedData() {
  66             return payload;
  67         }
  68
  69         @Override
  70         public Map<InstanceIdentifier, ? extends NormalizedNode<?, ?>> getOriginalData() {
  71             return Collections.emptyMap();
  72         }
  73
  74         @Override
  75         public NormalizedNode<?, ?> getOriginalSubtree() {
  76             return null;
  77         }
  78
  79         @Override
  80         public Set<InstanceIdentifier> getRemovedPaths() {
  81             return Collections.emptySet();
  82         }
  83
  84         @Override
  85         public Map<InstanceIdentifier, NormalizedNode<?, ?>> getUpdatedData() {
  86             return payload;
  87         }
  88
  89         @Override
  90         public NormalizedNode<?, ?> getUpdatedSubtree() {
  91             return data;
  92         }
  93
  94     }
  95
  96     public static <V> Set<V> toIdentifierSet(final Iterable<? extends Identifiable<V>> children) {
  97         return FluentIterable.from(children).transform(StoreUtils.<V> identifierExtractor()).toSet();
  98     }
  99
 100     public static String toStringTree(final StoreMetadataNode metaNode) {
 101         StringBuilder builder = new StringBuilder();
 102         toStringTree(builder, metaNode, 0);
 103         return builder.toString();
 104
 105     }
 106
 107     private static void toStringTree(final StringBuilder builder, final StoreMetadataNode metaNode, final int offset) {
 108         String prefix = Strings.repeat(" ", offset);
 109         builder.append(prefix).append(toStringTree(metaNode.getIdentifier()));
 110         NormalizedNode<?, ?> dataNode = metaNode.getData();
 111         if (dataNode instanceof NormalizedNodeContainer<?, ?, ?>) {
 112             builder.append(" {").append("\n");
 113             for (StoreMetadataNode child : metaNode.getChildren()) {
 114                 toStringTree(builder, child, offset + 4);
 115             }
 116             builder.append(prefix).append("}");
 117         } else {
 118             builder.append(" ").append(dataNode.getValue());
 119         }
 120         builder.append("\n");
 121     }
 122
 123     private static String toStringTree(final PathArgument identifier) {
 124         if (identifier instanceof NodeIdentifierWithPredicates) {
 125             StringBuilder builder = new StringBuilder();
 126             builder.append(identifier.getNodeType().getLocalName());
 127             builder.append(((NodeIdentifierWithPredicates) identifier).getKeyValues().values());
 128             return builder.toString();
 129         } else if (identifier instanceof AugmentationIdentifier) {
 130             return "augmentation";
 131         }
 132         return identifier.getNodeType().getLocalName();
 133     }
 134 }