yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedTypes.java

   1 /*
   2  * Copyright (c) 2015 Pantheon Technologies s.r.o. 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.model.util.type;
   9
  10 import com.google.common.annotations.Beta;
  11 import java.util.List;
  12 import javax.annotation.Nonnull;
  13 import org.eclipse.jdt.annotation.Nullable;
  14 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  15 import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
  16 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
  17 import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition;
  18 import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
  19 import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition;
  20 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
  21 import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
  22 import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
  23 import org.opendaylight.yangtools.yang.model.api.type.IntegerTypeDefinition;
  24 import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
  25 import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
  26 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
  27 import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
  28 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
  29 import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
  30
  31 /**
  32  * Restricted types are a refinement of the restrictions applied to a particular type. YANG defines restrictions only
  33  * on a subset of the base types, but conceptually any such definition can hold unknown nodes.
  34  *
  35  * <p>
  36  * 1) Restrictable
  37  *    binary (length)
  38  *    int{8,16,32,64} (range)
  39  *    string (length, patterns)
  40  *    uint{8,16,32,64} (range)
  41  *    decimal64 (range)
  42  *    instance-identifier (require-instance)
  43  *
  44  * <p>
  45  * 2) Non-restrictable
  46  *    boolean
  47  *    bits
  48  *    empty (ignores default on derivation)
  49  *    enumeration
  50  *    identityref
  51  *    leafref
  52  *    union
  53  *
  54  * <p>
  55  * This class holds methods which allow creation of restricted types using {@link TypeBuilder} and its subclasses. Each
  56  * restricted type is logically anchored at a {@link SchemaPath}, but can be substituted by its base type if it does
  57  * not contribute any additional restrictions. TypeBuilder instances take this into account, and result in the base type
  58  * being returned from the builder when the base type and restricted type are semantically equal.
  59  *
  60  * <p>
  61  * Restricted types inherit the default value, description, reference, status and units from the base type, if that type
  62  * defines them.
  63  */
  64 @Beta
  65 public final class RestrictedTypes {
  66     private RestrictedTypes() {
  67         throw new UnsupportedOperationException();
  68     }
  69
  70     public static LengthRestrictedTypeBuilder<BinaryTypeDefinition> newBinaryBuilder(
  71             @Nonnull final BinaryTypeDefinition baseType, @Nonnull final SchemaPath path) {
  72         return new LengthRestrictedTypeBuilder<BinaryTypeDefinition>(baseType, path) {
  73             @Override
  74             BinaryTypeDefinition buildType(final @Nullable LengthConstraint lengthConstraint) {
  75                 return new RestrictedBinaryType(getBaseType(), getPath(), getUnknownSchemaNodes(), lengthConstraint);
  76             }
  77
  78             @Override
  79             LengthConstraint typeLengthConstraints() {
  80                 /**
  81                  * Length constraint imposed on YANG binary type by our implementation. byte[].length is an integer,
  82                  * capping our ability to support arbitrary binary data.
  83                  */
  84                 return JavaLengthConstraints.INTEGER_SIZE_CONSTRAINTS;
  85             }
  86         };
  87     }
  88
  89     public static BitsTypeBuilder newBitsBuilder(final BitsTypeDefinition baseType, final SchemaPath path) {
  90         return new BitsTypeBuilder(baseType, path);
  91     }
  92
  93     public static TypeBuilder<BooleanTypeDefinition> newBooleanBuilder(@Nonnull final BooleanTypeDefinition baseType,
  94             @Nonnull final SchemaPath path) {
  95         return new AbstractRestrictedTypeBuilder<BooleanTypeDefinition>(baseType, path) {
  96             @Override
  97             BooleanTypeDefinition buildType() {
  98                 return new RestrictedBooleanType(getBaseType(), getPath(), getUnknownSchemaNodes());
  99             }
 100         };
 101     }
 102
 103     public static RangeRestrictedTypeBuilder<DecimalTypeDefinition> newDecima64Builder(
 104             final DecimalTypeDefinition baseType, final SchemaPath path) {
 105         return new RangeRestrictedTypeBuilderWithBase<DecimalTypeDefinition>(baseType, path) {
 106             @Override
 107             DecimalTypeDefinition buildType(final List<RangeConstraint> rangeConstraints) {
 108                 return new RestrictedDecimalType(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraints);
 109             }
 110         };
 111     }
 112
 113     public static TypeBuilder<EmptyTypeDefinition> newEmptyBuilder(final EmptyTypeDefinition baseType,
 114             final SchemaPath path) {
 115         return new AbstractRestrictedTypeBuilder<EmptyTypeDefinition>(baseType, path) {
 116             @Override
 117             EmptyTypeDefinition buildType() {
 118                 return new RestrictedEmptyType(getBaseType(), getPath(), getUnknownSchemaNodes());
 119             }
 120         };
 121     }
 122
 123     public static EnumerationTypeBuilder newEnumerationBuilder(final EnumTypeDefinition baseType,
 124             final SchemaPath path) {
 125         return new EnumerationTypeBuilder(baseType, path);
 126     }
 127
 128     public static TypeBuilder<IdentityrefTypeDefinition> newIdentityrefBuilder(final IdentityrefTypeDefinition baseType,
 129             final SchemaPath path) {
 130         return new AbstractRestrictedTypeBuilder<IdentityrefTypeDefinition>(baseType, path) {
 131             @Override
 132             IdentityrefTypeDefinition buildType() {
 133                 return new RestrictedIdentityrefType(getBaseType(), getPath(), getUnknownSchemaNodes());
 134             }
 135         };
 136     }
 137
 138     public static InstanceIdentifierTypeBuilder newInstanceIdentifierBuilder(
 139             final InstanceIdentifierTypeDefinition baseType, final SchemaPath path) {
 140         return new InstanceIdentifierTypeBuilder(baseType, path);
 141     }
 142
 143     public static RequireInstanceRestrictedTypeBuilder<LeafrefTypeDefinition> newLeafrefBuilder(
 144             final LeafrefTypeDefinition baseType, final SchemaPath path) {
 145         return new RequireInstanceRestrictedTypeBuilder<LeafrefTypeDefinition>(baseType, path) {
 146             @Override
 147             LeafrefTypeDefinition buildType() {
 148                 if (getRequireInstance() == getBaseType().requireInstance()) {
 149                     return getBaseType();
 150                 }
 151                 return new RestrictedLeafrefType(getBaseType(), getPath(), getUnknownSchemaNodes(),
 152                         getRequireInstance());
 153             }
 154         };
 155     }
 156
 157     public static RangeRestrictedTypeBuilder<IntegerTypeDefinition> newIntegerBuilder(
 158             final IntegerTypeDefinition baseType, final SchemaPath path) {
 159         return new RangeRestrictedTypeBuilderWithBase<IntegerTypeDefinition>(baseType, path) {
 160             @Override
 161             IntegerTypeDefinition buildType(final List<RangeConstraint> rangeConstraints) {
 162                 return new RestrictedIntegerType(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraints);
 163             }
 164         };
 165     }
 166
 167     public static StringTypeBuilder newStringBuilder(final StringTypeDefinition baseType, final SchemaPath path) {
 168         return new StringTypeBuilder(baseType, path);
 169     }
 170
 171     public static TypeBuilder<UnionTypeDefinition> newUnionBuilder(final UnionTypeDefinition baseType,
 172             final SchemaPath path) {
 173         return new AbstractRestrictedTypeBuilder<UnionTypeDefinition>(baseType, path) {
 174             @Override
 175             UnionTypeDefinition buildType() {
 176                 return new RestrictedUnionType(getBaseType(), getPath(), getUnknownSchemaNodes());
 177             }
 178         };
 179     }
 180
 181     public static RangeRestrictedTypeBuilder<UnsignedIntegerTypeDefinition> newUnsignedBuilder(
 182             final UnsignedIntegerTypeDefinition baseType, final SchemaPath path) {
 183         return new RangeRestrictedTypeBuilderWithBase<UnsignedIntegerTypeDefinition>(baseType, path) {
 184             @Override
 185             UnsignedIntegerTypeDefinition buildType(final List<RangeConstraint> rangeConstraints) {
 186                 return new RestrictedUnsignedType(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraints);
 187             }
 188         };
 189     }
 190 }