yang/yang-binding/src/main/java/org/opendaylight/yangtools/yang/binding/InstanceIdentifierBuilderImpl.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.yangtools.yang.binding;
   9
  10 import org.opendaylight.yangtools.util.HashCodeBuilder;
  11 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem;
  12 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.Item;
  13 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
  14
  15 import com.google.common.base.Preconditions;
  16 import com.google.common.collect.ImmutableList;
  17 import com.google.common.collect.Iterables;
  18
  19 final class InstanceIdentifierBuilderImpl<T extends DataObject> implements InstanceIdentifier.InstanceIdentifierBuilder<T> {
  20     private final ImmutableList.Builder<PathArgument> pathBuilder = ImmutableList.builder();
  21     private final HashCodeBuilder<PathArgument> hashBuilder;
  22     private final Iterable<? extends PathArgument> basePath;
  23     private boolean wildcard = false;
  24     private PathArgument arg = null;
  25
  26     InstanceIdentifierBuilderImpl() {
  27         this.hashBuilder = new HashCodeBuilder<>();
  28         this.basePath = null;
  29     }
  30
  31     InstanceIdentifierBuilderImpl(final PathArgument item, final Iterable<? extends PathArgument> pathArguments, final int hash, final boolean wildcard) {
  32         this.hashBuilder = new HashCodeBuilder<>(hash);
  33         this.basePath = pathArguments;
  34         this.wildcard = wildcard;
  35         this.arg = item;
  36     }
  37
  38     @Override
  39     public int hashCode() {
  40         return hashBuilder.build();
  41     }
  42
  43     @SuppressWarnings("unchecked")
  44     <N extends DataObject> InstanceIdentifierBuilderImpl<N> addNode(final Class<N> container) {
  45         arg = new Item<N>(container);
  46         hashBuilder.addArgument(arg);
  47         pathBuilder.add(arg);
  48
  49         if (Identifiable.class.isAssignableFrom(container)) {
  50             wildcard = true;
  51         }
  52
  53         return (InstanceIdentifierBuilderImpl<N>) this;
  54     }
  55
  56     @SuppressWarnings("unchecked")
  57     <N extends DataObject & Identifiable<K> , K extends Identifier<N>> InstanceIdentifierBuilderImpl<N> addNode(final Class<N> listItem, final K listKey) {
  58         arg = new IdentifiableItem<N, K>(listItem, listKey);
  59         hashBuilder.addArgument(arg);
  60         pathBuilder.add(arg);
  61         return (InstanceIdentifierBuilderImpl<N>) this;
  62     }
  63
  64     @Override
  65     public <N extends ChildOf<? super T>> InstanceIdentifierBuilderImpl<N> child(final Class<N> container) {
  66         return addNode(container);
  67     }
  68
  69     @Override
  70     public <N extends Identifiable<K> & ChildOf<? super T>, K extends Identifier<N>> InstanceIdentifierBuilderImpl<N> child(final Class<N> listItem, final K listKey) {
  71         return addNode(listItem, listKey);
  72     }
  73
  74     /**
  75      * Build an identifier which refers to a specific augmentation of the current InstanceIdentifier referenced by
  76      * the builder
  77      *
  78      * @param container
  79      * @param <N>
  80      * @return
  81      */
  82     @Override
  83     public <N extends DataObject & Augmentation<? super T>> InstanceIdentifierBuilderImpl<N> augmentation(final Class<N> container) {
  84         return addNode(container);
  85     }
  86
  87     @Override
  88     public InstanceIdentifier<T> build() {
  89         Preconditions.checkState(arg != null, "No path arguments present");
  90
  91         final Iterable<PathArgument> pathArguments;
  92         if (basePath == null) {
  93             pathArguments = pathBuilder.build();
  94         } else {
  95             pathArguments = Iterables.concat(basePath, pathBuilder.build());
  96         }
  97
  98         @SuppressWarnings("unchecked")
  99         final InstanceIdentifier<T> ret = (InstanceIdentifier<T>) InstanceIdentifier.trustedCreate(arg, pathArguments, hashBuilder.build(), wildcard);
 100         return ret;
 101     }
 102
 103     /*
 104      * @deprecated Use #build() instead.
 105      */
 106     @Deprecated
 107     public InstanceIdentifier<T> toInstance() {
 108         return build();
 109     }
 110 }