model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/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.ri.type;
   9
  10 import com.google.common.annotations.Beta;
  11 import java.math.BigDecimal;
  12 import org.eclipse.jdt.annotation.NonNull;
  13 import org.eclipse.jdt.annotation.Nullable;
  14 import org.opendaylight.yangtools.yang.common.QName;
  15 import org.opendaylight.yangtools.yang.common.Uint16;
  16 import org.opendaylight.yangtools.yang.common.Uint32;
  17 import org.opendaylight.yangtools.yang.common.Uint64;
  18 import org.opendaylight.yangtools.yang.common.Uint8;
  19 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  20 import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
  21 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
  22 import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition;
  23 import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
  24 import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition;
  25 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
  26 import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
  27 import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
  28 import org.opendaylight.yangtools.yang.model.api.type.Int16TypeDefinition;
  29 import org.opendaylight.yangtools.yang.model.api.type.Int32TypeDefinition;
  30 import org.opendaylight.yangtools.yang.model.api.type.Int64TypeDefinition;
  31 import org.opendaylight.yangtools.yang.model.api.type.Int8TypeDefinition;
  32 import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
  33 import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
  34 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
  35 import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
  36 import org.opendaylight.yangtools.yang.model.api.type.Uint16TypeDefinition;
  37 import org.opendaylight.yangtools.yang.model.api.type.Uint32TypeDefinition;
  38 import org.opendaylight.yangtools.yang.model.api.type.Uint64TypeDefinition;
  39 import org.opendaylight.yangtools.yang.model.api.type.Uint8TypeDefinition;
  40 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
  41
  42 /**
  43  * Restricted types are a refinement of the restrictions applied to a particular type. YANG defines restrictions only
  44  * on a subset of the base types, but conceptually any such definition can hold unknown nodes.
  45  *
  46  * <p>
  47  * 1) Restrictable
  48  *    binary (length)
  49  *    int{8,16,32,64} (range)
  50  *    string (length, patterns)
  51  *    uint{8,16,32,64} (range)
  52  *    decimal64 (range)
  53  *    instance-identifier (require-instance)
  54  *
  55  * <p>
  56  * 2) Non-restrictable
  57  *    boolean
  58  *    bits
  59  *    empty (ignores default on derivation)
  60  *    enumeration
  61  *    identityref
  62  *    leafref
  63  *    union
  64  *
  65  * <p>
  66  * This class holds methods which allow creation of restricted types using {@link TypeBuilder} and its subclasses. Each
  67  * restricted type is logically anchored at a {@link SchemaPath}, but can be substituted by its base type if it does
  68  * not contribute any additional restrictions. TypeBuilder instances take this into account, and result in the base type
  69  * being returned from the builder when the base type and restricted type are semantically equal.
  70  *
  71  * <p>
  72  * Restricted types inherit the default value, description, reference, status and units from the base type, if that type
  73  * defines them.
  74  */
  75 @Beta
  76 public final class RestrictedTypes {
  77     private RestrictedTypes() {
  78         // Hidden on purpose
  79     }
  80
  81     public static @NonNull LengthRestrictedTypeBuilder<BinaryTypeDefinition> newBinaryBuilder(
  82             final @NonNull BinaryTypeDefinition baseType, final @NonNull QName qname) {
  83         return new LengthRestrictedTypeBuilder<>(baseType, qname) {
  84             @Override
  85             BinaryTypeDefinition buildType(final @Nullable LengthConstraint constraint) {
  86                 return new RestrictedBinaryType(getBaseType(), getQName(), getUnknownSchemaNodes(), constraint);
  87             }
  88
  89             @Override
  90             LengthConstraint typeLengthConstraints() {
  91                 /**
  92                  * Length constraint imposed on YANG binary type by our implementation. byte[].length is an integer,
  93                  * capping our ability to support arbitrary binary data.
  94                  */
  95                 return JavaLengthConstraints.INTEGER_SIZE_CONSTRAINTS;
  96             }
  97         };
  98     }
  99
 100     public static @NonNull BitsTypeBuilder newBitsBuilder(final BitsTypeDefinition baseType, final QName qname) {
 101         return new BitsTypeBuilder(baseType, qname);
 102     }
 103
 104     public static @NonNull TypeBuilder<BooleanTypeDefinition> newBooleanBuilder(
 105             final @NonNull BooleanTypeDefinition baseType, final @NonNull QName qname) {
 106         return new AbstractRestrictedTypeBuilder<>(baseType, qname) {
 107             @Override
 108             BooleanTypeDefinition buildType() {
 109                 return new RestrictedBooleanType(getBaseType(), getQName(), getUnknownSchemaNodes());
 110             }
 111         };
 112     }
 113
 114     public static @NonNull RangeRestrictedTypeBuilder<DecimalTypeDefinition, BigDecimal> newDecima64Builder(
 115             final DecimalTypeDefinition baseType, final QName qname) {
 116         return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
 117             @Override
 118             DecimalTypeDefinition buildType(final RangeConstraint<BigDecimal> rangeConstraint) {
 119                 return new RestrictedDecimalType(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
 120             }
 121         };
 122     }
 123
 124     public static @NonNull TypeBuilder<EmptyTypeDefinition> newEmptyBuilder(final EmptyTypeDefinition baseType,
 125             final QName qname) {
 126         return new AbstractRestrictedTypeBuilder<>(baseType, qname) {
 127             @Override
 128             EmptyTypeDefinition buildType() {
 129                 return new RestrictedEmptyType(getBaseType(), getQName(), getUnknownSchemaNodes());
 130             }
 131         };
 132     }
 133
 134     public static @NonNull EnumerationTypeBuilder newEnumerationBuilder(final EnumTypeDefinition baseType,
 135             final QName qname) {
 136         return new EnumerationTypeBuilder(baseType, qname);
 137     }
 138
 139     public static @NonNull TypeBuilder<IdentityrefTypeDefinition> newIdentityrefBuilder(
 140             final IdentityrefTypeDefinition baseType, final QName qname) {
 141         return new AbstractRestrictedTypeBuilder<>(baseType, qname) {
 142             @Override
 143             IdentityrefTypeDefinition buildType() {
 144                 return new RestrictedIdentityrefType(getBaseType(), getQName(), getUnknownSchemaNodes());
 145             }
 146         };
 147     }
 148
 149     public static @NonNull InstanceIdentifierTypeBuilder newInstanceIdentifierBuilder(
 150             final InstanceIdentifierTypeDefinition baseType, final QName qname) {
 151         return new InstanceIdentifierTypeBuilder(baseType, qname);
 152     }
 153
 154     public static @NonNull RequireInstanceRestrictedTypeBuilder<LeafrefTypeDefinition> newLeafrefBuilder(
 155             final LeafrefTypeDefinition baseType, final QName qname) {
 156         return new RequireInstanceRestrictedTypeBuilder<>(baseType, qname) {
 157             @Override
 158             LeafrefTypeDefinition buildType() {
 159                 final LeafrefTypeDefinition base = getBaseType();
 160                 if (getRequireInstance() == base.requireInstance()) {
 161                     return base;
 162                 }
 163                 return new RestrictedLeafrefType(getBaseType(), getQName(), getUnknownSchemaNodes(),
 164                         getRequireInstance());
 165             }
 166         };
 167     }
 168
 169     public static @NonNull RangeRestrictedTypeBuilder<Int8TypeDefinition, Byte> newInt8Builder(
 170             final Int8TypeDefinition baseType, final QName qname) {
 171         return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
 172             @Override
 173             Int8TypeDefinition buildType(final RangeConstraint<Byte> rangeConstraint) {
 174                 return new RestrictedInt8Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
 175             }
 176         };
 177     }
 178
 179     public static @NonNull RangeRestrictedTypeBuilder<Int16TypeDefinition, Short> newInt16Builder(
 180             final Int16TypeDefinition baseType, final QName qname) {
 181         return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
 182             @Override
 183             Int16TypeDefinition buildType(final RangeConstraint<Short> rangeConstraint) {
 184                 return new RestrictedInt16Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
 185             }
 186         };
 187     }
 188
 189     public static @NonNull RangeRestrictedTypeBuilder<Int32TypeDefinition, Integer> newInt32Builder(
 190             final Int32TypeDefinition baseType, final QName qname) {
 191         return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
 192             @Override
 193             Int32TypeDefinition buildType(final RangeConstraint<Integer> rangeConstraint) {
 194                 return new RestrictedInt32Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
 195             }
 196         };
 197     }
 198
 199     public static @NonNull RangeRestrictedTypeBuilder<Int64TypeDefinition, Long> newInt64Builder(
 200             final Int64TypeDefinition baseType, final QName qname) {
 201         return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
 202             @Override
 203             Int64TypeDefinition buildType(final RangeConstraint<Long> rangeConstraint) {
 204                 return new RestrictedInt64Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
 205             }
 206         };
 207     }
 208
 209     public static @NonNull StringTypeBuilder newStringBuilder(final StringTypeDefinition baseType, final QName qname) {
 210         return new StringTypeBuilder(baseType, qname);
 211     }
 212
 213     public static @NonNull TypeBuilder<UnionTypeDefinition> newUnionBuilder(final UnionTypeDefinition baseType,
 214             final QName qname) {
 215         return new AbstractRestrictedTypeBuilder<>(baseType, qname) {
 216             @Override
 217             UnionTypeDefinition buildType() {
 218                 return new RestrictedUnionType(getBaseType(), getQName(), getUnknownSchemaNodes());
 219             }
 220         };
 221     }
 222
 223     public static @NonNull RangeRestrictedTypeBuilder<Uint8TypeDefinition, Uint8> newUint8Builder(
 224             final Uint8TypeDefinition baseType, final QName qname) {
 225         return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
 226             @Override
 227             Uint8TypeDefinition buildType(final RangeConstraint<@NonNull Uint8> rangeConstraint) {
 228                 return new RestrictedUint8Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
 229             }
 230         };
 231     }
 232
 233     public static @NonNull RangeRestrictedTypeBuilder<Uint16TypeDefinition, Uint16> newUint16Builder(
 234             final Uint16TypeDefinition baseType, final QName qname) {
 235         return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
 236             @Override
 237             Uint16TypeDefinition buildType(final RangeConstraint<@NonNull Uint16> rangeConstraint) {
 238                 return new RestrictedUint16Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
 239             }
 240         };
 241     }
 242
 243     public static @NonNull RangeRestrictedTypeBuilder<Uint32TypeDefinition, Uint32> newUint32Builder(
 244             final Uint32TypeDefinition baseType, final QName qname) {
 245         return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
 246             @Override
 247             Uint32TypeDefinition buildType(final RangeConstraint<@NonNull Uint32> rangeConstraint) {
 248                 return new RestrictedUint32Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
 249             }
 250         };
 251     }
 252
 253     public static @NonNull RangeRestrictedTypeBuilder<Uint64TypeDefinition, Uint64> newUint64Builder(
 254             final Uint64TypeDefinition baseType, final QName qname) {
 255         return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
 256             @Override
 257             Uint64TypeDefinition buildType(final RangeConstraint<@NonNull Uint64> rangeConstraint) {
 258                 return new RestrictedUint64Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
 259             }
 260         };
 261     }
 262 }