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