Remove duplicate documentation

[mdsal.git] / binding / mdsal-binding-generator / src / main / java / org / opendaylight / mdsal / binding / generator / BindingGeneratorUtil.java

diff --git a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/BindingGeneratorUtil.java b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/BindingGeneratorUtil.java
index 669c69bd2bc2660f7af226b6109b6a5bbdd3abff..2d4a8e2b57a9dad8b0f8431e950e6edd6ce7fb02 100644 (file)
--- a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/BindingGeneratorUtil.java
+++ b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/BindingGeneratorUtil.java
@@ -10,8 +10,6 @@ package org.opendaylight.mdsal.binding.generator;
 import com.google.common.annotations.Beta;
 import com.google.common.base.CharMatcher;
 import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableList.Builder;
-import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
 import java.util.regex.Pattern;
@@ -40,28 +38,6 @@ public final class BindingGeneratorUtil {
     private static final CharMatcher LT_MATCHER = CharMatcher.is('<');
     private static final Pattern UNICODE_CHAR_PATTERN = Pattern.compile("\\\\+u");
 
-    private static final Restrictions EMPTY_RESTRICTIONS = new Restrictions() {
-        @Override
-        public Optional<LengthConstraint> getLengthConstraint() {
-            return Optional.empty();
-        }
-
-        @Override
-        public List<PatternConstraint> getPatternConstraints() {
-            return Collections.emptyList();
-        }
-
-        @Override
-        public Optional<RangeConstraint<?>> getRangeConstraint() {
-            return Optional.empty();
-        }
-
-        @Override
-        public boolean isEmpty() {
-            return true;
-        }
-    };
-
     private BindingGeneratorUtil() {
         // Hidden on purpose
     }
@@ -77,43 +53,19 @@ public final class BindingGeneratorUtil {
             //
             // FIXME: looking at the generated code it looks as though we need to pass the restrictions without
             //        comparison
-            if (type instanceof DecimalTypeDefinition) {
-                final DecimalTypeDefinition decimal = (DecimalTypeDefinition) type;
+            if (type instanceof DecimalTypeDefinition decimal) {
                 final DecimalTypeBuilder tmpBuilder = BaseTypes.decimalTypeBuilder(decimal.getQName());
                 tmpBuilder.setFractionDigits(decimal.getFractionDigits());
                 final DecimalTypeDefinition tmp = tmpBuilder.build();
 
                 if (!tmp.getRangeConstraint().equals(decimal.getRangeConstraint())) {
-                    return new Restrictions() {
-                        @Override
-                        public boolean isEmpty() {
-                            return false;
-                        }
-
-                        @Override
-                        public Optional<? extends RangeConstraint<?>> getRangeConstraint() {
-                            return decimal.getRangeConstraint();
-                        }
-
-                        @Override
-                        public List<PatternConstraint> getPatternConstraints() {
-                            return ImmutableList.of();
-                        }
-
-                        @Override
-                        public Optional<LengthConstraint> getLengthConstraint() {
-                            return Optional.empty();
-                        }
-                    };
+                    return Restrictions.of(decimal.getRangeConstraint().orElse(null));
                 }
             }
 
-            return EMPTY_RESTRICTIONS;
+            return Restrictions.empty();
         }
 
-        final Optional<LengthConstraint> length;
-        final List<PatternConstraint> pattern;
-        final Optional<? extends RangeConstraint<?>> range;
 
         /*
          * Take care of extended types.
@@ -128,77 +80,39 @@ public final class BindingGeneratorUtil {
          *
          * FIXME: this probably not the best solution and needs further analysis.
          */
-        if (type instanceof BinaryTypeDefinition) {
-            final BinaryTypeDefinition binary = (BinaryTypeDefinition)type;
+        if (type instanceof BinaryTypeDefinition binary) {
             final BinaryTypeDefinition base = binary.getBaseType();
+            final Optional<LengthConstraint> length;
             if (base != null && base.getBaseType() != null) {
                 length = currentOrEmpty(binary.getLengthConstraint(), base.getLengthConstraint());
             } else {
                 length = binary.getLengthConstraint();
             }
-
-            pattern = ImmutableList.of();
-            range = Optional.empty();
-        } else if (type instanceof DecimalTypeDefinition) {
-            length = Optional.empty();
-            pattern = ImmutableList.of();
-
-            final DecimalTypeDefinition decimal = (DecimalTypeDefinition)type;
+            return Restrictions.of(length.orElse(null));
+        } else if (type instanceof DecimalTypeDefinition decimal) {
             final DecimalTypeDefinition base = decimal.getBaseType();
+            final Optional<? extends RangeConstraint<?>> range;
             if (base != null && base.getBaseType() != null) {
                 range = currentOrEmpty(decimal.getRangeConstraint(), base.getRangeConstraint());
             } else {
                 range = decimal.getRangeConstraint();
             }
+            return Restrictions.of(range.orElse(null));
         } else if (type instanceof RangeRestrictedTypeDefinition) {
             // Integer-like types
-            length = Optional.empty();
-            pattern = ImmutableList.of();
-            range = extractRangeConstraint((RangeRestrictedTypeDefinition<?, ?>)type);
-        } else if (type instanceof StringTypeDefinition) {
-            final StringTypeDefinition string = (StringTypeDefinition)type;
+            return Restrictions.of(extractRangeConstraint((RangeRestrictedTypeDefinition<?, ?>) type).orElse(null));
+        } else if (type instanceof StringTypeDefinition string) {
             final StringTypeDefinition base = string.getBaseType();
+            final Optional<LengthConstraint> length;
             if (base != null && base.getBaseType() != null) {
                 length = currentOrEmpty(string.getLengthConstraint(), base.getLengthConstraint());
             } else {
                 length = string.getLengthConstraint();
             }
-
-            pattern = uniquePatterns(string);
-            range = Optional.empty();
+            return Restrictions.of(uniquePatterns(string), length.orElse(null));
         } else {
-            length = Optional.empty();
-            pattern = ImmutableList.of();
-            range = Optional.empty();
-        }
-
-        // Now, this may have ended up being empty, too...
-        if (!length.isPresent() && pattern.isEmpty() && !range.isPresent()) {
-            return EMPTY_RESTRICTIONS;
+            return Restrictions.empty();
         }
-
-        // Nope, not empty allocate a holder
-        return new Restrictions() {
-            @Override
-            public Optional<? extends RangeConstraint<?>> getRangeConstraint() {
-                return range;
-            }
-
-            @Override
-            public List<PatternConstraint> getPatternConstraints() {
-                return pattern;
-            }
-
-            @Override
-            public Optional<LengthConstraint> getLengthConstraint() {
-                return length;
-            }
-
-            @Override
-            public boolean isEmpty() {
-                return false;
-            }
-        };
     }
 
     private static <T extends RangeRestrictedTypeDefinition<?, ?>> Optional<? extends RangeConstraint<?>>
@@ -231,7 +145,7 @@ public final class BindingGeneratorUtil {
             return constraints;
         }
 
-        final Builder<PatternConstraint> builder = ImmutableList.builder();
+        final var builder = ImmutableList.<PatternConstraint>builder();
         boolean filtered = false;
         for (final PatternConstraint c : constraints) {
             if (containsConstraint(type.getBaseType(), c)) {