yang/yang-data-util/src/main/java/org/opendaylight/yangtools/yang/data/util/OperationAsContainer.java

   1 /*
   2  * Copyright (c) 2016 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.data.util;
   9
  10 import static java.util.Objects.requireNonNull;
  11
  12 import com.google.common.annotations.Beta;
  13 import com.google.common.collect.ForwardingObject;
  14 import com.google.common.collect.ImmutableSet;
  15 import java.util.ArrayList;
  16 import java.util.Collection;
  17 import java.util.List;
  18 import java.util.Optional;
  19 import java.util.Set;
  20 import org.eclipse.jdt.annotation.NonNull;
  21 import org.opendaylight.yangtools.yang.common.QName;
  22 import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
  23 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
  24 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  25 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  26 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
  27 import org.opendaylight.yangtools.yang.model.api.MustDefinition;
  28 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
  29 import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
  30 import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
  31 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  32 import org.opendaylight.yangtools.yang.model.api.Status;
  33 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  34 import org.opendaylight.yangtools.yang.model.api.UsesNode;
  35
  36 @Beta
  37 public class OperationAsContainer extends ForwardingObject implements ContainerSchemaNode, OperationDefinition {
  38     private final @NonNull OperationDefinition delegate;
  39
  40     OperationAsContainer(final OperationDefinition parentNode) {
  41         delegate = requireNonNull(parentNode);
  42     }
  43
  44     public static @NonNull OperationAsContainer of(final OperationDefinition delegate) {
  45         return new OperationAsContainer(delegate);
  46     }
  47
  48     @Override
  49     protected final @NonNull OperationDefinition delegate() {
  50         return delegate;
  51     }
  52
  53     @Override
  54     public final Optional<String> getDescription() {
  55         return delegate.getDescription();
  56     }
  57
  58     @Override
  59     public final Optional<String> getReference() {
  60         return delegate.getReference();
  61     }
  62
  63     @Override
  64     public final Set<TypeDefinition<?>> getTypeDefinitions() {
  65         return delegate.getTypeDefinitions();
  66     }
  67
  68     @Override
  69     public final Set<GroupingDefinition> getGroupings() {
  70         return delegate.getGroupings();
  71     }
  72
  73     @Override
  74     public final Status getStatus() {
  75         return delegate.getStatus();
  76     }
  77
  78     @Override
  79     public final ContainerSchemaNode getInput() {
  80         return delegate.getInput();
  81     }
  82
  83     @Override
  84     public final ContainerSchemaNode getOutput() {
  85         return delegate.getOutput();
  86     }
  87
  88     @Override
  89     public final QName getQName() {
  90         return delegate.getQName();
  91     }
  92
  93     @Override
  94     public final SchemaPath getPath() {
  95         return delegate.getPath();
  96     }
  97
  98     @Override
  99     public final Optional<DataSchemaNode> findDataChildByName(final QName name) {
 100         if (!name.getModule().equals(getQName().getModule())) {
 101             return Optional.empty();
 102         }
 103
 104         switch (name.getLocalName()) {
 105             case "input":
 106                 return Optional.of(delegate.getInput());
 107             case "output":
 108                 return Optional.of(delegate.getOutput());
 109             default:
 110                 return Optional.empty();
 111         }
 112     }
 113
 114     @Override
 115     public Set<UsesNode> getUses() {
 116         return ImmutableSet.of();
 117     }
 118
 119     @Override
 120     public final Set<AugmentationSchemaNode> getAvailableAugmentations() {
 121         return ImmutableSet.of();
 122     }
 123
 124     @Override
 125     public final boolean isPresenceContainer() {
 126         return false;
 127     }
 128
 129     @Override
 130     public final Collection<DataSchemaNode> getChildNodes() {
 131         final List<DataSchemaNode> ret = new ArrayList<>();
 132         final ContainerSchemaNode input = getInput();
 133         final ContainerSchemaNode output = getOutput();
 134         if (input != null) {
 135             ret.add(input);
 136         }
 137         if (output != null) {
 138             ret.add(output);
 139         }
 140         return ret;
 141     }
 142
 143     @Deprecated
 144     @Override
 145     public final boolean isAugmenting() {
 146         return false;
 147     }
 148
 149     @Deprecated
 150     @Override
 151     public final boolean isAddedByUses() {
 152         return false;
 153     }
 154
 155     @Override
 156     public final boolean isConfiguration() {
 157         return false;
 158     }
 159
 160     @Override
 161     public final Set<ActionDefinition> getActions() {
 162         return ImmutableSet.of();
 163     }
 164
 165     @Override
 166     public Optional<ActionDefinition> findAction(final QName qname) {
 167         requireNonNull(qname);
 168         return Optional.empty();
 169     }
 170
 171     @Override
 172     public final Set<NotificationDefinition> getNotifications() {
 173         return ImmutableSet.of();
 174     }
 175
 176     @Override
 177     public Optional<NotificationDefinition> findNotification(final QName qname) {
 178         requireNonNull(qname);
 179         return Optional.empty();
 180     }
 181
 182     @Override
 183     public final Collection<MustDefinition> getMustConstraints() {
 184         return ImmutableSet.of();
 185     }
 186
 187     @Override
 188     public final Optional<RevisionAwareXPath> getWhenCondition() {
 189         return Optional.empty();
 190     }
 191 }