model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/type/ConcreteTypes.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.NonNullByDefault;
  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.stmt.DefaultEffectiveStatement;
  15 import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement;
  16 import org.opendaylight.yangtools.yang.model.api.stmt.LeafEffectiveStatement;
  17 import org.opendaylight.yangtools.yang.model.api.stmt.LeafListEffectiveStatement;
  18 import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement;
  19 import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
  20 import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
  21 import org.opendaylight.yangtools.yang.model.api.stmt.UnitsEffectiveStatement;
  22 import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
  23 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
  24 import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition;
  25 import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
  26 import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition;
  27 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
  28 import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
  29 import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
  30 import org.opendaylight.yangtools.yang.model.api.type.Int16TypeDefinition;
  31 import org.opendaylight.yangtools.yang.model.api.type.Int32TypeDefinition;
  32 import org.opendaylight.yangtools.yang.model.api.type.Int64TypeDefinition;
  33 import org.opendaylight.yangtools.yang.model.api.type.Int8TypeDefinition;
  34 import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
  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  * Support for creating {@link TypeDefinition} instances defined by leaf and leaf-list statements.
  44  */
  45 @Beta
  46 @NonNullByDefault
  47 public final class ConcreteTypes {
  48     private ConcreteTypes() {
  49         // Hidden on purpose
  50     }
  51
  52     public static ConcreteTypeBuilder<?> concreteTypeBuilder(final TypeDefinition<?> baseType, final QName qname) {
  53         if (baseType instanceof BinaryTypeDefinition) {
  54             return concreteBinaryBuilder((BinaryTypeDefinition) baseType, qname);
  55         } else if (baseType instanceof BitsTypeDefinition) {
  56             return concreteBitsBuilder((BitsTypeDefinition) baseType, qname);
  57         } else if (baseType instanceof BooleanTypeDefinition) {
  58             return concreteBooleanBuilder((BooleanTypeDefinition) baseType, qname);
  59         } else if (baseType instanceof DecimalTypeDefinition) {
  60             return concreteDecimalBuilder((DecimalTypeDefinition) baseType, qname);
  61         } else if (baseType instanceof EmptyTypeDefinition) {
  62             return concreteEmptyBuilder((EmptyTypeDefinition) baseType, qname);
  63         } else if (baseType instanceof EnumTypeDefinition) {
  64             return concreteEnumerationBuilder((EnumTypeDefinition) baseType, qname);
  65         } else if (baseType instanceof IdentityrefTypeDefinition) {
  66             return concreteIdentityrefBuilder((IdentityrefTypeDefinition) baseType, qname);
  67         } else if (baseType instanceof InstanceIdentifierTypeDefinition) {
  68             return concreteInstanceIdentifierBuilder((InstanceIdentifierTypeDefinition) baseType, qname);
  69         } else if (baseType instanceof Int8TypeDefinition) {
  70             return concreteInt8Builder((Int8TypeDefinition) baseType, qname);
  71         } else if (baseType instanceof Int16TypeDefinition) {
  72             return concreteInt16Builder((Int16TypeDefinition) baseType, qname);
  73         } else if (baseType instanceof Int32TypeDefinition) {
  74             return concreteInt32Builder((Int32TypeDefinition) baseType, qname);
  75         } else if (baseType instanceof Int64TypeDefinition) {
  76             return concreteInt64Builder((Int64TypeDefinition) baseType, qname);
  77         } else if (baseType instanceof LeafrefTypeDefinition) {
  78             return concreteLeafrefBuilder((LeafrefTypeDefinition) baseType, qname);
  79         } else if (baseType instanceof StringTypeDefinition) {
  80             return concreteStringBuilder((StringTypeDefinition) baseType, qname);
  81         } else if (baseType instanceof UnionTypeDefinition) {
  82             return concreteUnionBuilder((UnionTypeDefinition) baseType, qname);
  83         } else if (baseType instanceof Uint8TypeDefinition) {
  84             return concreteUint8Builder((Uint8TypeDefinition) baseType, qname);
  85         } else if (baseType instanceof Uint16TypeDefinition) {
  86             return concreteUint16Builder((Uint16TypeDefinition) baseType, qname);
  87         } else if (baseType instanceof Uint32TypeDefinition) {
  88             return concreteUint32Builder((Uint32TypeDefinition) baseType, qname);
  89         } else if (baseType instanceof Uint64TypeDefinition) {
  90             return concreteUint64Builder((Uint64TypeDefinition) baseType, qname);
  91         } else {
  92             throw new IllegalArgumentException("Unhandled type definition class " + baseType.getClass());
  93         }
  94     }
  95
  96     public static TypeDefinition<?> typeOf(final LeafEffectiveStatement leaf) {
  97         final var typeStmt = leaf.findFirstEffectiveSubstatement(TypeEffectiveStatement.class).orElseThrow();
  98         final var builder = concreteTypeBuilder(typeStmt.getTypeDefinition(), leaf.argument());
  99         for (var stmt : leaf.effectiveSubstatements()) {
 100             if (stmt instanceof DefaultEffectiveStatement) {
 101                 builder.setDefaultValue(((DefaultEffectiveStatement)stmt).argument());
 102             } else if (stmt instanceof DescriptionEffectiveStatement) {
 103                 builder.setDescription(((DescriptionEffectiveStatement)stmt).argument());
 104             } else if (stmt instanceof ReferenceEffectiveStatement) {
 105                 builder.setReference(((ReferenceEffectiveStatement)stmt).argument());
 106             } else if (stmt instanceof StatusEffectiveStatement) {
 107                 builder.setStatus(((StatusEffectiveStatement)stmt).argument());
 108             } else if (stmt instanceof UnitsEffectiveStatement) {
 109                 builder.setUnits(((UnitsEffectiveStatement)stmt).argument());
 110             }
 111         }
 112         return builder.build();
 113     }
 114
 115     public static TypeDefinition<?> typeOf(final LeafListEffectiveStatement leafList) {
 116         final var typeStmt = leafList.findFirstEffectiveSubstatement(TypeEffectiveStatement.class).get();
 117         final var builder = concreteTypeBuilder(typeStmt.getTypeDefinition(), leafList.argument());
 118         for (var stmt : leafList.effectiveSubstatements()) {
 119             // NOTE: 'default' is omitted here on purpose
 120             if (stmt instanceof DescriptionEffectiveStatement) {
 121                 builder.setDescription(((DescriptionEffectiveStatement)stmt).argument());
 122             } else if (stmt instanceof ReferenceEffectiveStatement) {
 123                 builder.setReference(((ReferenceEffectiveStatement)stmt).argument());
 124             } else if (stmt instanceof StatusEffectiveStatement) {
 125                 builder.setStatus(((StatusEffectiveStatement)stmt).argument());
 126             } else if (stmt instanceof UnitsEffectiveStatement) {
 127                 builder.setUnits(((UnitsEffectiveStatement)stmt).argument());
 128             }
 129         }
 130         return builder.build();
 131     }
 132
 133     private static ConcreteTypeBuilder<BinaryTypeDefinition> concreteBinaryBuilder(
 134             final BinaryTypeDefinition baseType, final QName qname) {
 135         return new ConcreteTypeBuilder<>(baseType, qname) {
 136             @Override
 137             public BinaryTypeDefinition buildType() {
 138                 return new DerivedBinaryType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 139                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 140             }
 141         };
 142     }
 143
 144     private static ConcreteTypeBuilder<BitsTypeDefinition> concreteBitsBuilder(final BitsTypeDefinition baseType,
 145             final QName qname) {
 146         return new ConcreteTypeBuilder<>(baseType, qname) {
 147             @Override
 148             public BitsTypeDefinition buildType() {
 149                 return new DerivedBitsType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 150                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 151             }
 152         };
 153     }
 154
 155     private static ConcreteTypeBuilder<BooleanTypeDefinition> concreteBooleanBuilder(
 156             final BooleanTypeDefinition baseType, final QName qname) {
 157         return new ConcreteTypeBuilder<>(baseType, qname) {
 158             @Override
 159             public BooleanTypeDefinition buildType() {
 160                 return new DerivedBooleanType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 161                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 162             }
 163         };
 164     }
 165
 166     private static ConcreteTypeBuilder<DecimalTypeDefinition> concreteDecimalBuilder(
 167             final DecimalTypeDefinition baseType, final QName qname) {
 168         return new ConcreteTypeBuilder<>(baseType, qname) {
 169             @Override
 170             public DecimalTypeDefinition buildType() {
 171                 return new DerivedDecimalType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 172                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 173             }
 174         };
 175     }
 176
 177     private static ConcreteTypeBuilder<EmptyTypeDefinition> concreteEmptyBuilder(final EmptyTypeDefinition baseType,
 178             final QName qname) {
 179         return new ConcreteTypeBuilder<>(baseType, qname) {
 180             @Override
 181             public EmptyTypeDefinition buildType() {
 182                 return new DerivedEmptyType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 183                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 184             }
 185         };
 186     }
 187
 188     private static ConcreteTypeBuilder<EnumTypeDefinition> concreteEnumerationBuilder(
 189             final EnumTypeDefinition baseType, final QName qname) {
 190         return new ConcreteTypeBuilder<>(baseType, qname) {
 191             @Override
 192             public EnumTypeDefinition buildType() {
 193                 return new DerivedEnumerationType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 194                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 195             }
 196         };
 197     }
 198
 199     private static ConcreteTypeBuilder<IdentityrefTypeDefinition> concreteIdentityrefBuilder(
 200             final IdentityrefTypeDefinition baseType, final QName qname) {
 201         return new ConcreteTypeBuilder<>(baseType, qname) {
 202             @Override
 203             public IdentityrefTypeDefinition buildType() {
 204                 return new DerivedIdentityrefType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 205                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 206             }
 207         };
 208     }
 209
 210     private static ConcreteTypeBuilder<InstanceIdentifierTypeDefinition> concreteInstanceIdentifierBuilder(
 211             final InstanceIdentifierTypeDefinition baseType, final QName qname) {
 212         return new ConcreteTypeBuilder<>(baseType, qname) {
 213             @Override
 214             public InstanceIdentifierTypeDefinition buildType() {
 215                 return new DerivedInstanceIdentifierType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 216                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes(), baseType.requireInstance());
 217             }
 218         };
 219     }
 220
 221     private static ConcreteTypeBuilder<Int8TypeDefinition> concreteInt8Builder(
 222             final Int8TypeDefinition baseType, final QName qname) {
 223         return new ConcreteTypeBuilder<>(baseType, qname) {
 224             @Override
 225             public Int8TypeDefinition buildType() {
 226                 return new DerivedInt8Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 227                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 228             }
 229         };
 230     }
 231
 232     private static ConcreteTypeBuilder<Int16TypeDefinition> concreteInt16Builder(
 233             final Int16TypeDefinition baseType, final QName qname) {
 234         return new ConcreteTypeBuilder<>(baseType, qname) {
 235             @Override
 236             public Int16TypeDefinition buildType() {
 237                 return new DerivedInt16Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 238                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 239             }
 240         };
 241     }
 242
 243     private static ConcreteTypeBuilder<Int32TypeDefinition> concreteInt32Builder(
 244             final Int32TypeDefinition baseType, final QName qname) {
 245         return new ConcreteTypeBuilder<>(baseType, qname) {
 246             @Override
 247             public Int32TypeDefinition buildType() {
 248                 return new DerivedInt32Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 249                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 250             }
 251         };
 252     }
 253
 254     private static ConcreteTypeBuilder<Int64TypeDefinition> concreteInt64Builder(
 255             final Int64TypeDefinition baseType, final QName qname) {
 256         return new ConcreteTypeBuilder<>(baseType, qname) {
 257             @Override
 258             public Int64TypeDefinition buildType() {
 259                 return new DerivedInt64Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 260                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 261             }
 262         };
 263     }
 264
 265     private static ConcreteTypeBuilder<LeafrefTypeDefinition> concreteLeafrefBuilder(
 266             final LeafrefTypeDefinition baseType, final QName qname) {
 267         return new ConcreteTypeBuilder<>(baseType, qname) {
 268             @Override
 269             public LeafrefTypeDefinition buildType() {
 270                 return new DerivedLeafrefType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 271                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 272             }
 273         };
 274     }
 275
 276     private static ConcreteTypeBuilder<StringTypeDefinition> concreteStringBuilder(final StringTypeDefinition baseType,
 277             final QName qname) {
 278         return new ConcreteTypeBuilder<>(baseType, qname) {
 279             @Override
 280             public StringTypeDefinition buildType() {
 281                 return new DerivedStringType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 282                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 283             }
 284         };
 285     }
 286
 287     private static ConcreteTypeBuilder<UnionTypeDefinition> concreteUnionBuilder(final UnionTypeDefinition baseType,
 288             final QName qname) {
 289         return new ConcreteTypeBuilder<>(baseType, qname) {
 290             @Override
 291             public DerivedUnionType buildType() {
 292                 return new DerivedUnionType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 293                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 294             }
 295         };
 296     }
 297
 298     private static ConcreteTypeBuilder<Uint8TypeDefinition> concreteUint8Builder(
 299             final Uint8TypeDefinition baseType, final QName qname) {
 300         return new ConcreteTypeBuilder<>(baseType, qname) {
 301             @Override
 302             public Uint8TypeDefinition buildType() {
 303                 return new DerivedUint8Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 304                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 305             }
 306         };
 307     }
 308
 309     private static ConcreteTypeBuilder<Uint16TypeDefinition> concreteUint16Builder(
 310             final Uint16TypeDefinition baseType, final QName qname) {
 311         return new ConcreteTypeBuilder<>(baseType, qname) {
 312             @Override
 313             public Uint16TypeDefinition buildType() {
 314                 return new DerivedUint16Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 315                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 316             }
 317         };
 318     }
 319
 320     private static ConcreteTypeBuilder<Uint32TypeDefinition> concreteUint32Builder(
 321             final Uint32TypeDefinition baseType, final QName qname) {
 322         return new ConcreteTypeBuilder<>(baseType, qname) {
 323             @Override
 324             public Uint32TypeDefinition buildType() {
 325                 return new DerivedUint32Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 326                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 327             }
 328         };
 329     }
 330
 331     private static ConcreteTypeBuilder<Uint64TypeDefinition> concreteUint64Builder(
 332             final Uint64TypeDefinition baseType, final QName qname) {
 333         return new ConcreteTypeBuilder<>(baseType, qname) {
 334             @Override
 335             public Uint64TypeDefinition buildType() {
 336                 return new DerivedUint64Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
 337                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 338             }
 339         };
 340     }
 341 }