yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/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.util.type;
   9
  10 import com.google.common.annotations.Beta;
  11 import javax.annotation.Nonnull;
  12 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  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.IntegerTypeDefinition;
  23 import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
  24 import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
  25 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
  26 import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
  27
  28 /**
  29  * YANG defines 'derived type' as a type created through a 'typedef' statement. These types are exposed in the
  30  * hierarchical namespace and can be looked up.
  31  *
  32  * A derived type can redefine the default value, description, status and reference of a particular type definition.
  33  * It can only refine the units attribute, as that attribute is tied to the semantics of the value. The default value,
  34  * and units attributes are inherited from the super (base or restricted) type, others are left undefined if not
  35  * explicitly set. Status defaults to current.
  36  */
  37 /*
  38  * FIXME: Create ConcreteTypes
  39  *        Leaf and leaf-list statements provide for a similar mechanism by which a particular type is changed, most
  40  *        notably with the ability to redefine the default type. The resulting types could conceivably be called
  41  *        'concrete types', as they cannot be referenced by another leaf or type definition. This aspect needs to be
  42  *        split out into a 'ConcreteTypes' class.
  43  *
  44  *        Builders should use the fly-weight pattern to minimize footprint for cases when leaves do not override any
  45  *        aspect of the base type.
  46  */
  47 @Beta
  48 public final class DerivedTypes {
  49     private DerivedTypes() {
  50         throw new UnsupportedOperationException();
  51     }
  52
  53     @SuppressWarnings("unchecked")
  54     public static <T extends TypeDefinition<T>> DerivedTypeBuilder<T> derivedTypeBuilder(@Nonnull final T baseType,
  55             @Nonnull final SchemaPath path) {
  56         if (baseType instanceof BinaryTypeDefinition) {
  57             return (DerivedTypeBuilder<T>) derivedBinaryBuilder((BinaryTypeDefinition) baseType, path);
  58         } else if (baseType instanceof BitsTypeDefinition) {
  59             return (DerivedTypeBuilder<T>) derivedBitsBuilder((BitsTypeDefinition) baseType, path);
  60         } else if (baseType instanceof BooleanTypeDefinition) {
  61             return (DerivedTypeBuilder<T>) derivedBooleanBuilder((BooleanTypeDefinition) baseType, path);
  62         } else if (baseType instanceof DecimalTypeDefinition) {
  63             return (DerivedTypeBuilder<T>) derivedDecimalBuilder((DecimalTypeDefinition) baseType, path);
  64         } else if (baseType instanceof EmptyTypeDefinition) {
  65             return (DerivedTypeBuilder<T>) derivedEmptyBuilder((EmptyTypeDefinition) baseType, path);
  66         } else if (baseType instanceof EnumTypeDefinition) {
  67             return (DerivedTypeBuilder<T>) derivedEnumerationBuilder((EnumTypeDefinition) baseType, path);
  68         } else if (baseType instanceof IdentityrefTypeDefinition) {
  69             return (DerivedTypeBuilder<T>) derivedIdentityrefBuilder((IdentityrefTypeDefinition) baseType, path);
  70         } else if (baseType instanceof InstanceIdentifierTypeDefinition) {
  71             return (DerivedTypeBuilder<T>) derivedInstanceIdentifierBuilder((InstanceIdentifierTypeDefinition) baseType, path);
  72         } else if (baseType instanceof IntegerTypeDefinition) {
  73             return (DerivedTypeBuilder<T>) derivedIntegerBuilder((IntegerTypeDefinition) baseType, path);
  74         } else if (baseType instanceof LeafrefTypeDefinition) {
  75             return (DerivedTypeBuilder<T>) derivedLeafrefBuilder((LeafrefTypeDefinition) baseType, path);
  76         } else if (baseType instanceof StringTypeDefinition) {
  77             return (DerivedTypeBuilder<T>) derivedStringBuilder((StringTypeDefinition) baseType, path);
  78         } else if (baseType instanceof UnionTypeDefinition) {
  79             return (DerivedTypeBuilder<T>) derivedUnionBuilder((UnionTypeDefinition) baseType, path);
  80         } else if (baseType instanceof UnsignedIntegerTypeDefinition) {
  81             return (DerivedTypeBuilder<T>) derivedUnsignedBuilder((UnsignedIntegerTypeDefinition) baseType, path);
  82         } else {
  83             throw new IllegalArgumentException("Unhandled type definition class " + baseType.getClass());
  84         }
  85     }
  86
  87     public static DerivedTypeBuilder<BinaryTypeDefinition> derivedBinaryBuilder(@Nonnull final BinaryTypeDefinition baseType, @Nonnull final SchemaPath path) {
  88         return new DerivedTypeBuilder<BinaryTypeDefinition>(baseType, path) {
  89             @Override
  90             public BinaryTypeDefinition build() {
  91                 return new DerivedBinaryType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
  92                     getStatus(), getUnits(), getUnknownSchemaNodes());
  93             }
  94         };
  95     }
  96
  97     public static DerivedTypeBuilder<BitsTypeDefinition> derivedBitsBuilder(final BitsTypeDefinition baseType, final SchemaPath path) {
  98         return new DerivedTypeBuilder<BitsTypeDefinition>(baseType, path) {
  99             @Override
 100             public BitsTypeDefinition build() {
 101                 return new DerivedBitsType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
 102                     getStatus(), getUnits(), getUnknownSchemaNodes());
 103             }
 104         };
 105     }
 106
 107     public static DerivedTypeBuilder<BooleanTypeDefinition> derivedBooleanBuilder(@Nonnull final BooleanTypeDefinition baseType, @Nonnull final SchemaPath path) {
 108         return new DerivedTypeBuilder<BooleanTypeDefinition>(baseType, path) {
 109             @Override
 110             public BooleanTypeDefinition build() {
 111                 return new DerivedBooleanType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
 112                     getStatus(), getUnits(), getUnknownSchemaNodes());
 113             }
 114         };
 115     }
 116
 117     public static DerivedTypeBuilder<DecimalTypeDefinition> derivedDecimalBuilder(final DecimalTypeDefinition baseType, final SchemaPath path) {
 118         return new DerivedTypeBuilder<DecimalTypeDefinition>(baseType, path) {
 119             @Override
 120             public DecimalTypeDefinition build() {
 121                 return new DerivedDecimalType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
 122                     getStatus(), getUnits(), getUnknownSchemaNodes());
 123             }
 124         };
 125     }
 126
 127     public static DerivedTypeBuilder<EmptyTypeDefinition> derivedEmptyBuilder(final EmptyTypeDefinition baseType, final SchemaPath path) {
 128         return new DerivedTypeBuilder<EmptyTypeDefinition>(baseType, path) {
 129             @Override
 130             public EmptyTypeDefinition build() {
 131                 return new DerivedEmptyType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
 132                     getStatus(), getUnits(), getUnknownSchemaNodes());
 133             }
 134         };
 135     }
 136
 137     public static DerivedTypeBuilder<EnumTypeDefinition> derivedEnumerationBuilder(final EnumTypeDefinition baseType, final SchemaPath path) {
 138         return new DerivedTypeBuilder<EnumTypeDefinition>(baseType, path) {
 139             @Override
 140             public EnumTypeDefinition build() {
 141                 return new DerivedEnumerationType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
 142                     getStatus(), getUnits(), getUnknownSchemaNodes());
 143             }
 144         };
 145     }
 146
 147     public static DerivedTypeBuilder<IdentityrefTypeDefinition> derivedIdentityrefBuilder(final IdentityrefTypeDefinition baseType, final SchemaPath path) {
 148         return new DerivedTypeBuilder<IdentityrefTypeDefinition>(baseType, path) {
 149             @Override
 150             public IdentityrefTypeDefinition build() {
 151                 return new DerivedIdentityrefType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
 152                     getStatus(), getUnits(), getUnknownSchemaNodes());
 153             }
 154         };
 155     }
 156
 157     public static DerivedTypeBuilder<InstanceIdentifierTypeDefinition> derivedInstanceIdentifierBuilder(final InstanceIdentifierTypeDefinition baseType, final SchemaPath path) {
 158         return new DerivedTypeBuilder<InstanceIdentifierTypeDefinition>(baseType, path) {
 159             @Override
 160             public InstanceIdentifierTypeDefinition build() {
 161                 return new DerivedInstanceIdentifierType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
 162                     getStatus(), getUnits(), getUnknownSchemaNodes(), baseType.requireInstance());
 163             }
 164         };
 165     }
 166
 167     public static DerivedTypeBuilder<IntegerTypeDefinition> derivedIntegerBuilder(final IntegerTypeDefinition baseType, final SchemaPath path) {
 168         return new DerivedTypeBuilder<IntegerTypeDefinition>(baseType, path) {
 169             @Override
 170             public IntegerTypeDefinition build() {
 171                 return new DerivedIntegerType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
 172                     getStatus(), getUnits(), getUnknownSchemaNodes());
 173             }
 174         };
 175     }
 176
 177     public static DerivedTypeBuilder<LeafrefTypeDefinition> derivedLeafrefBuilder(final LeafrefTypeDefinition baseType, final SchemaPath path) {
 178         return new DerivedTypeBuilder<LeafrefTypeDefinition>(baseType, path) {
 179             @Override
 180             public LeafrefTypeDefinition build() {
 181                 return new DerivedLeafrefType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
 182                     getStatus(), getUnits(), getUnknownSchemaNodes());
 183             }
 184         };
 185     }
 186
 187     public static DerivedTypeBuilder<StringTypeDefinition> derivedStringBuilder(final StringTypeDefinition baseType, final SchemaPath path) {
 188         return new DerivedTypeBuilder<StringTypeDefinition>(baseType, path) {
 189             @Override
 190             public StringTypeDefinition build() {
 191                 return new DerivedStringType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
 192                     getStatus(), getUnits(), getUnknownSchemaNodes());
 193             }
 194         };
 195     }
 196
 197     public static DerivedTypeBuilder<UnionTypeDefinition> derivedUnionBuilder(final UnionTypeDefinition baseType, final SchemaPath path) {
 198         return new DerivedTypeBuilder<UnionTypeDefinition>(baseType, path) {
 199             @Override
 200             public DerivedUnionType build() {
 201                 return new DerivedUnionType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
 202                     getStatus(), getUnits(), getUnknownSchemaNodes());
 203             }
 204         };
 205     }
 206
 207     public static DerivedTypeBuilder<UnsignedIntegerTypeDefinition> derivedUnsignedBuilder(final UnsignedIntegerTypeDefinition baseType, final SchemaPath path) {
 208         return new DerivedTypeBuilder<UnsignedIntegerTypeDefinition>(baseType, path) {
 209             @Override
 210             public UnsignedIntegerTypeDefinition build() {
 211                 return new DerivedUnsignedType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
 212                     getStatus(), getUnits(), getUnknownSchemaNodes());
 213             }
 214         };
 215     }
 216 }