Refactor mdsal-binding-generator artifacts

[mdsal.git] / binding / mdsal-binding-model-api / src / main / java / org / opendaylight / mdsal / binding / model / api / YangSourceDefinition.java

diff --git a/binding/mdsal-binding-model-api/src/main/java/org/opendaylight/mdsal/binding/model/api/YangSourceDefinition.java b/binding/mdsal-binding-model-api/src/main/java/org/opendaylight/mdsal/binding/model/api/YangSourceDefinition.java
new file mode 100644 (file)
index 0000000..943f170
--- /dev/null
+++ b/binding/mdsal-binding-model-api/src/main/java/org/opendaylight/mdsal/binding/model/api/YangSourceDefinition.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2018 Pantheon Technologies, s.r.o. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.model.api;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.annotations.Beta;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.SchemaNode;
+import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
+
+/**
+ * DTO capturing the YANG source definition which lead to a {@link GeneratedType} being emitted.
+ */
+@Beta
+@NonNullByDefault
+public abstract class YangSourceDefinition {
+    public static final class Multiple extends YangSourceDefinition {
+        private final List<? extends SchemaNode> nodes;
+
+        Multiple(final ModuleEffectiveStatement module, final Collection<? extends SchemaNode> nodes) {
+            super(module);
+            this.nodes = ImmutableList.copyOf(nodes);
+        }
+
+        /**
+         * Return the defining SchemaNodes. Each node is guaranteed to implement {@link EffectiveStatement} and have
+         * a corresponding declared statement.
+         *
+         * @return defining SchemaNodes, guaranteed to be non-empty
+         */
+        public List<? extends SchemaNode> getNodes() {
+            return nodes.stream().filter(node -> node instanceof EffectiveStatement
+                && ((EffectiveStatement<?, ?>) node).getDeclared() != null).collect(Collectors.toList());
+        }
+    }
+
+    public static final class Single extends YangSourceDefinition {
+        private final DocumentedNode node;
+
+        Single(final ModuleEffectiveStatement module, final DocumentedNode node) {
+            super(module);
+            this.node = requireNonNull(node);
+        }
+
+        /**
+         * Return the defining DocumentedNode. The node is guaranteed to implement {@link EffectiveStatement} and have
+         * a corresponding declared statement.
+         *
+         * @return defining SchemaNodes, guaranteed to be non-empty
+         */
+        public DocumentedNode getNode() {
+            return node;
+        }
+    }
+
+    private final ModuleEffectiveStatement module;
+
+    private YangSourceDefinition(final ModuleEffectiveStatement module) {
+        this.module = requireNonNull(module);
+    }
+
+    public static Optional<YangSourceDefinition> of(final Module module) {
+        final ModuleEffectiveStatement effective = module.asEffectiveStatement();
+        final ModuleStatement declared = effective.getDeclared();
+        if (declared != null) {
+            return Optional.of(new Single(effective, module));
+        }
+        return Optional.empty();
+    }
+
+    public static Optional<YangSourceDefinition> of(final Module module, final SchemaNode node) {
+        return of(module.asEffectiveStatement(), node);
+    }
+
+    public static Optional<YangSourceDefinition> of(final ModuleEffectiveStatement module, final SchemaNode node) {
+        if (node instanceof EffectiveStatement) {
+            final DeclaredStatement<?> declared = ((EffectiveStatement<?, ?>) node).getDeclared();
+            if (declared != null) {
+                return Optional.of(new Single(module, node));
+            }
+        }
+        return Optional.empty();
+    }
+
+    public static Optional<YangSourceDefinition> of(final Module module, final Collection<? extends SchemaNode> nodes) {
+        checkArgument(!nodes.isEmpty());
+
+        final boolean anyDeclared = nodes.stream().anyMatch(
+            node -> node instanceof EffectiveStatement && ((EffectiveStatement<?, ?>) node).getDeclared() != null);
+        if (anyDeclared) {
+            return Optional.of(new Multiple(module.asEffectiveStatement(), nodes));
+        }
+        return Optional.empty();
+    }
+
+    /**
+     * Return the defining YANG module.
+     *
+     * @return Defining YANG module.
+     */
+    public final ModuleEffectiveStatement getModule() {
+        return module;
+    }
+}