model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/type/DerivedTypes.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 org.eclipse.jdt.annotation.NonNull;
  12 import org.opendaylight.yangtools.yang.common.QName;
  13 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  14 import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
  15 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
  16 import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition;
  17 import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
  18 import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition;
  19 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
  20 import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
  21 import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
  22 import org.opendaylight.yangtools.yang.model.api.type.Int16TypeDefinition;
  23 import org.opendaylight.yangtools.yang.model.api.type.Int32TypeDefinition;
  24 import org.opendaylight.yangtools.yang.model.api.type.Int64TypeDefinition;
  25 import org.opendaylight.yangtools.yang.model.api.type.Int8TypeDefinition;
  26 import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
  27 import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
  28 import org.opendaylight.yangtools.yang.model.api.type.Uint16TypeDefinition;
  29 import org.opendaylight.yangtools.yang.model.api.type.Uint32TypeDefinition;
  30 import org.opendaylight.yangtools.yang.model.api.type.Uint64TypeDefinition;
  31 import org.opendaylight.yangtools.yang.model.api.type.Uint8TypeDefinition;
  32 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
  33
  34 /**
  35  * YANG defines 'derived type' as a type created through a 'typedef' statement. These types are exposed in the
  36  * hierarchical namespace and can be looked up.
  37  *
  38  * <p>
  39  * A derived type can redefine the default value, description, status and reference of a particular type definition.
  40  * It can only refine the units attribute, as that attribute is tied to the semantics of the value. The default value,
  41  * and units attributes are inherited from the super (base or restricted) type, others are left undefined if not
  42  * explicitly set. Status defaults to current.
  43  */
  44 @Beta
  45 public final class DerivedTypes {
  46     private DerivedTypes() {
  47         // Hidden on purpose
  48     }
  49
  50     public static @NonNull DerivedTypeBuilder<?> derivedTypeBuilder(final @NonNull TypeDefinition<?> baseType,
  51             final @NonNull QName qname) {
  52         if (baseType instanceof BinaryTypeDefinition) {
  53             return derivedBinaryBuilder((BinaryTypeDefinition) baseType, qname);
  54         } else if (baseType instanceof BitsTypeDefinition) {
  55             return derivedBitsBuilder((BitsTypeDefinition) baseType, qname);
  56         } else if (baseType instanceof BooleanTypeDefinition) {
  57             return derivedBooleanBuilder((BooleanTypeDefinition) baseType, qname);
  58         } else if (baseType instanceof DecimalTypeDefinition) {
  59             return derivedDecimalBuilder((DecimalTypeDefinition) baseType, qname);
  60         } else if (baseType instanceof EmptyTypeDefinition) {
  61             return derivedEmptyBuilder((EmptyTypeDefinition) baseType, qname);
  62         } else if (baseType instanceof EnumTypeDefinition) {
  63             return derivedEnumerationBuilder((EnumTypeDefinition) baseType, qname);
  64         } else if (baseType instanceof IdentityrefTypeDefinition) {
  65             return derivedIdentityrefBuilder((IdentityrefTypeDefinition) baseType, qname);
  66         } else if (baseType instanceof InstanceIdentifierTypeDefinition) {
  67             return derivedInstanceIdentifierBuilder((InstanceIdentifierTypeDefinition) baseType, qname);
  68         } else if (baseType instanceof Int8TypeDefinition) {
  69             return derivedInt8Builder((Int8TypeDefinition) baseType, qname);
  70         } else if (baseType instanceof Int16TypeDefinition) {
  71             return derivedInt16Builder((Int16TypeDefinition) baseType, qname);
  72         } else if (baseType instanceof Int32TypeDefinition) {
  73             return derivedInt32Builder((Int32TypeDefinition) baseType, qname);
  74         } else if (baseType instanceof Int64TypeDefinition) {
  75             return derivedInt64Builder((Int64TypeDefinition) baseType, qname);
  76         } else if (baseType instanceof LeafrefTypeDefinition) {
  77             return derivedLeafrefBuilder((LeafrefTypeDefinition) baseType, qname);
  78         } else if (baseType instanceof StringTypeDefinition) {
  79             return derivedStringBuilder((StringTypeDefinition) baseType, qname);
  80         } else if (baseType instanceof UnionTypeDefinition) {
  81             return derivedUnionBuilder((UnionTypeDefinition) baseType, qname);
  82         } else if (baseType instanceof Uint8TypeDefinition) {
  83             return derivedUint8Builder((Uint8TypeDefinition) baseType, qname);
  84         } else if (baseType instanceof Uint16TypeDefinition) {
  85             return derivedUint16Builder((Uint16TypeDefinition) baseType, qname);
  86         } else if (baseType instanceof Uint32TypeDefinition) {
  87             return derivedUint32Builder((Uint32TypeDefinition) baseType, qname);
  88         } else if (baseType instanceof Uint64TypeDefinition) {
  89             return derivedUint64Builder((Uint64TypeDefinition) baseType, qname);
  90         } else {
  91             throw new IllegalArgumentException("Unhandled type definition class " + baseType.getClass());
  92         }
  93     }
  94
  95     public static @NonNull DerivedTypeBuilder<BinaryTypeDefinition> derivedBinaryBuilder(
  96             final @NonNull BinaryTypeDefinition baseType, final @NonNull QName qname) {
  97         return new DerivedTypeBuilder<>(baseType, qname) {
  98             @Override
  99             public BinaryTypeDefinition build() {
 100                 return new DerivedBinaryType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 101                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 102             }
 103         };
 104     }
 105
 106     public static @NonNull DerivedTypeBuilder<BitsTypeDefinition> derivedBitsBuilder(final BitsTypeDefinition baseType,
 107             final QName qname) {
 108         return new DerivedTypeBuilder<>(baseType, qname) {
 109             @Override
 110             public BitsTypeDefinition build() {
 111                 return new DerivedBitsType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 112                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 113             }
 114         };
 115     }
 116
 117     public static @NonNull DerivedTypeBuilder<BooleanTypeDefinition> derivedBooleanBuilder(
 118             final @NonNull BooleanTypeDefinition baseType, final @NonNull QName qname) {
 119         return new DerivedTypeBuilder<>(baseType, qname) {
 120             @Override
 121             public BooleanTypeDefinition build() {
 122                 return new DerivedBooleanType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 123                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 124             }
 125         };
 126     }
 127
 128     private static @NonNull DerivedTypeBuilder<DecimalTypeDefinition> derivedDecimalBuilder(
 129             final DecimalTypeDefinition baseType, final QName qname) {
 130         return new DerivedTypeBuilder<>(baseType, qname) {
 131             @Override
 132             public DecimalTypeDefinition build() {
 133                 return new DerivedDecimalType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 134                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 135             }
 136         };
 137     }
 138
 139     public static @NonNull DerivedTypeBuilder<EmptyTypeDefinition> derivedEmptyBuilder(
 140             final EmptyTypeDefinition baseType, final QName qname) {
 141         return new DerivedTypeBuilder<>(baseType, qname) {
 142             @Override
 143             public EmptyTypeDefinition build() {
 144                 return new DerivedEmptyType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 145                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 146             }
 147         };
 148     }
 149
 150     private static @NonNull DerivedTypeBuilder<EnumTypeDefinition> derivedEnumerationBuilder(
 151             final EnumTypeDefinition baseType, final QName qname) {
 152         return new DerivedTypeBuilder<>(baseType, qname) {
 153             @Override
 154             public EnumTypeDefinition build() {
 155                 return new DerivedEnumerationType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 156                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 157             }
 158         };
 159     }
 160
 161     public static @NonNull DerivedTypeBuilder<IdentityrefTypeDefinition> derivedIdentityrefBuilder(
 162             final IdentityrefTypeDefinition baseType, final QName qname) {
 163         return new DerivedTypeBuilder<>(baseType, qname) {
 164             @Override
 165             public IdentityrefTypeDefinition build() {
 166                 return new DerivedIdentityrefType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 167                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 168             }
 169         };
 170     }
 171
 172     public static @NonNull DerivedTypeBuilder<InstanceIdentifierTypeDefinition> derivedInstanceIdentifierBuilder(
 173             final InstanceIdentifierTypeDefinition baseType, final QName qname) {
 174         return new DerivedTypeBuilder<>(baseType, qname) {
 175             @Override
 176             public InstanceIdentifierTypeDefinition build() {
 177                 return new DerivedInstanceIdentifierType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 178                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes(), baseType.requireInstance());
 179             }
 180         };
 181     }
 182
 183     private static @NonNull DerivedTypeBuilder<Int8TypeDefinition> derivedInt8Builder(final Int8TypeDefinition baseType,
 184             final QName qname) {
 185         return new DerivedTypeBuilder<>(baseType, qname) {
 186             @Override
 187             public Int8TypeDefinition build() {
 188                 return new DerivedInt8Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 189                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 190             }
 191         };
 192     }
 193
 194     public static @NonNull DerivedTypeBuilder<Int16TypeDefinition> derivedInt16Builder(
 195             final Int16TypeDefinition baseType, final QName qname) {
 196         return new DerivedTypeBuilder<>(baseType, qname) {
 197             @Override
 198             public Int16TypeDefinition build() {
 199                 return new DerivedInt16Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 200                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 201             }
 202         };
 203     }
 204
 205     public static @NonNull DerivedTypeBuilder<Int32TypeDefinition> derivedInt32Builder(
 206             final Int32TypeDefinition baseType, final QName qname) {
 207         return new DerivedTypeBuilder<>(baseType, qname) {
 208             @Override
 209             public Int32TypeDefinition build() {
 210                 return new DerivedInt32Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 211                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 212             }
 213         };
 214     }
 215
 216     private static @NonNull DerivedTypeBuilder<Int64TypeDefinition> derivedInt64Builder(
 217             final Int64TypeDefinition baseType, final QName qname) {
 218         return new DerivedTypeBuilder<>(baseType, qname) {
 219             @Override
 220             public Int64TypeDefinition build() {
 221                 return new DerivedInt64Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 222                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 223             }
 224         };
 225     }
 226
 227     public static @NonNull DerivedTypeBuilder<LeafrefTypeDefinition> derivedLeafrefBuilder(
 228             final LeafrefTypeDefinition baseType, final QName qname) {
 229         return new DerivedTypeBuilder<>(baseType, qname) {
 230             @Override
 231             public LeafrefTypeDefinition build() {
 232                 return new DerivedLeafrefType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 233                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 234             }
 235         };
 236     }
 237
 238     private static @NonNull DerivedTypeBuilder<StringTypeDefinition> derivedStringBuilder(
 239             final StringTypeDefinition baseType, final QName qname) {
 240         return new DerivedTypeBuilder<>(baseType, qname) {
 241             @Override
 242             public StringTypeDefinition build() {
 243                 return new DerivedStringType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 244                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 245             }
 246         };
 247     }
 248
 249     public static @NonNull DerivedTypeBuilder<UnionTypeDefinition> derivedUnionBuilder(
 250             final UnionTypeDefinition baseType, final QName qname) {
 251         return new DerivedTypeBuilder<>(baseType, qname) {
 252             @Override
 253             public DerivedUnionType build() {
 254                 return new DerivedUnionType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 255                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 256             }
 257         };
 258     }
 259
 260     private static @NonNull DerivedTypeBuilder<Uint8TypeDefinition> derivedUint8Builder(
 261             final Uint8TypeDefinition baseType, final QName qname) {
 262         return new DerivedTypeBuilder<>(baseType, qname) {
 263             @Override
 264             public Uint8TypeDefinition build() {
 265                 return new DerivedUint8Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 266                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 267             }
 268         };
 269     }
 270
 271     private static @NonNull DerivedTypeBuilder<Uint16TypeDefinition> derivedUint16Builder(
 272             final Uint16TypeDefinition baseType, final QName qname) {
 273         return new DerivedTypeBuilder<>(baseType, qname) {
 274             @Override
 275             public Uint16TypeDefinition build() {
 276                 return new DerivedUint16Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 277                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 278             }
 279         };
 280     }
 281
 282     public static @NonNull DerivedTypeBuilder<Uint32TypeDefinition> derivedUint32Builder(
 283             final Uint32TypeDefinition baseType, final QName qname) {
 284         return new DerivedTypeBuilder<>(baseType, qname) {
 285             @Override
 286             public Uint32TypeDefinition build() {
 287                 return new DerivedUint32Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 288                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 289             }
 290         };
 291     }
 292
 293     public static @NonNull DerivedTypeBuilder<Uint64TypeDefinition> derivedUint64Builder(
 294             final Uint64TypeDefinition baseType, final QName qname) {
 295         return new DerivedTypeBuilder<>(baseType, qname) {
 296             @Override
 297             public Uint64TypeDefinition build() {
 298                 return new DerivedUint64Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 299                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 300             }
 301         };
 302     }
 303 }