yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/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.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.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  * Support for creating {@link TypeDefinition} instances defined by leaf and leaf-list statements.
  36  */
  37 @Beta
  38 public final class ConcreteTypes {
  39     private ConcreteTypes() {
  40         throw new UnsupportedOperationException();
  41     }
  42
  43     public static ConcreteTypeBuilder<?> concreteTypeBuilder(@Nonnull final TypeDefinition<?> baseType,
  44             @Nonnull final SchemaPath path) {
  45         if (baseType instanceof BinaryTypeDefinition) {
  46             return concreteBinaryBuilder((BinaryTypeDefinition) baseType, path);
  47         } else if (baseType instanceof BitsTypeDefinition) {
  48             return concreteBitsBuilder((BitsTypeDefinition) baseType, path);
  49         } else if (baseType instanceof BooleanTypeDefinition) {
  50             return concreteBooleanBuilder((BooleanTypeDefinition) baseType, path);
  51         } else if (baseType instanceof DecimalTypeDefinition) {
  52             return concreteDecimalBuilder((DecimalTypeDefinition) baseType, path);
  53         } else if (baseType instanceof EmptyTypeDefinition) {
  54             return concreteEmptyBuilder((EmptyTypeDefinition) baseType, path);
  55         } else if (baseType instanceof EnumTypeDefinition) {
  56             return concreteEnumerationBuilder((EnumTypeDefinition) baseType, path);
  57         } else if (baseType instanceof IdentityrefTypeDefinition) {
  58             return concreteIdentityrefBuilder((IdentityrefTypeDefinition) baseType, path);
  59         } else if (baseType instanceof InstanceIdentifierTypeDefinition) {
  60             return concreteInstanceIdentifierBuilder((InstanceIdentifierTypeDefinition) baseType, path);
  61         } else if (baseType instanceof Int8TypeDefinition) {
  62             return concreteInt8Builder((Int8TypeDefinition) baseType, path);
  63         } else if (baseType instanceof Int16TypeDefinition) {
  64             return concreteInt16Builder((Int16TypeDefinition) baseType, path);
  65         } else if (baseType instanceof Int32TypeDefinition) {
  66             return concreteInt32Builder((Int32TypeDefinition) baseType, path);
  67         } else if (baseType instanceof Int64TypeDefinition) {
  68             return concreteInt64Builder((Int64TypeDefinition) baseType, path);
  69         } else if (baseType instanceof LeafrefTypeDefinition) {
  70             return concreteLeafrefBuilder((LeafrefTypeDefinition) baseType, path);
  71         } else if (baseType instanceof StringTypeDefinition) {
  72             return concreteStringBuilder((StringTypeDefinition) baseType, path);
  73         } else if (baseType instanceof UnionTypeDefinition) {
  74             return concreteUnionBuilder((UnionTypeDefinition) baseType, path);
  75         } else if (baseType instanceof Uint8TypeDefinition) {
  76             return concreteUint8Builder((Uint8TypeDefinition) baseType, path);
  77         } else if (baseType instanceof Uint16TypeDefinition) {
  78             return concreteUint16Builder((Uint16TypeDefinition) baseType, path);
  79         } else if (baseType instanceof Uint32TypeDefinition) {
  80             return concreteUint32Builder((Uint32TypeDefinition) baseType, path);
  81         } else if (baseType instanceof Uint64TypeDefinition) {
  82             return concreteUint64Builder((Uint64TypeDefinition) baseType, path);
  83         } else {
  84             throw new IllegalArgumentException("Unhandled type definition class " + baseType.getClass());
  85         }
  86     }
  87
  88     private static ConcreteTypeBuilder<BinaryTypeDefinition> concreteBinaryBuilder(
  89             @Nonnull final BinaryTypeDefinition baseType, @Nonnull final SchemaPath path) {
  90         return new ConcreteTypeBuilder<BinaryTypeDefinition>(baseType, path) {
  91             @Nonnull
  92             @Override
  93             public BinaryTypeDefinition buildType() {
  94                 return new DerivedBinaryType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
  95                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
  96             }
  97         };
  98     }
  99
 100     private static ConcreteTypeBuilder<BitsTypeDefinition> concreteBitsBuilder(final BitsTypeDefinition baseType,
 101             final SchemaPath path) {
 102         return new ConcreteTypeBuilder<BitsTypeDefinition>(baseType, path) {
 103             @Nonnull
 104             @Override
 105             public BitsTypeDefinition buildType() {
 106                 return new DerivedBitsType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 107                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 108             }
 109         };
 110     }
 111
 112     private static ConcreteTypeBuilder<BooleanTypeDefinition> concreteBooleanBuilder(
 113             @Nonnull final BooleanTypeDefinition baseType, @Nonnull final SchemaPath path) {
 114         return new ConcreteTypeBuilder<BooleanTypeDefinition>(baseType, path) {
 115             @Nonnull
 116             @Override
 117             public BooleanTypeDefinition buildType() {
 118                 return new DerivedBooleanType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 119                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 120             }
 121         };
 122     }
 123
 124     private static ConcreteTypeBuilder<DecimalTypeDefinition> concreteDecimalBuilder(
 125             final DecimalTypeDefinition baseType, final SchemaPath path) {
 126         return new ConcreteTypeBuilder<DecimalTypeDefinition>(baseType, path) {
 127             @Nonnull
 128             @Override
 129             public DecimalTypeDefinition buildType() {
 130                 return new DerivedDecimalType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 131                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 132             }
 133         };
 134     }
 135
 136     private static ConcreteTypeBuilder<EmptyTypeDefinition> concreteEmptyBuilder(final EmptyTypeDefinition baseType,
 137             final SchemaPath path) {
 138         return new ConcreteTypeBuilder<EmptyTypeDefinition>(baseType, path) {
 139             @Nonnull
 140             @Override
 141             public EmptyTypeDefinition buildType() {
 142                 return new DerivedEmptyType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 143                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 144             }
 145         };
 146     }
 147
 148     private static ConcreteTypeBuilder<EnumTypeDefinition> concreteEnumerationBuilder(
 149             final EnumTypeDefinition baseType, final SchemaPath path) {
 150         return new ConcreteTypeBuilder<EnumTypeDefinition>(baseType, path) {
 151             @Nonnull
 152             @Override
 153             public EnumTypeDefinition buildType() {
 154                 return new DerivedEnumerationType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 155                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 156             }
 157         };
 158     }
 159
 160     private static ConcreteTypeBuilder<IdentityrefTypeDefinition> concreteIdentityrefBuilder(
 161             final IdentityrefTypeDefinition baseType, final SchemaPath path) {
 162         return new ConcreteTypeBuilder<IdentityrefTypeDefinition>(baseType, path) {
 163             @Nonnull
 164             @Override
 165             public IdentityrefTypeDefinition buildType() {
 166                 return new DerivedIdentityrefType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 167                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 168             }
 169         };
 170     }
 171
 172     private static ConcreteTypeBuilder<InstanceIdentifierTypeDefinition> concreteInstanceIdentifierBuilder(
 173             final InstanceIdentifierTypeDefinition baseType, final SchemaPath path) {
 174         return new ConcreteTypeBuilder<InstanceIdentifierTypeDefinition>(baseType, path) {
 175             @Nonnull
 176             @Override
 177             public InstanceIdentifierTypeDefinition buildType() {
 178                 return new DerivedInstanceIdentifierType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 179                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes(), baseType.requireInstance());
 180             }
 181         };
 182     }
 183
 184     private static ConcreteTypeBuilder<Int8TypeDefinition> concreteInt8Builder(
 185             final Int8TypeDefinition baseType, final SchemaPath path) {
 186         return new ConcreteTypeBuilder<Int8TypeDefinition>(baseType, path) {
 187             @Nonnull
 188             @Override
 189             public Int8TypeDefinition buildType() {
 190                 return new DerivedInt8Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 191                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 192             }
 193         };
 194     }
 195
 196     private static ConcreteTypeBuilder<Int16TypeDefinition> concreteInt16Builder(
 197             final Int16TypeDefinition baseType, final SchemaPath path) {
 198         return new ConcreteTypeBuilder<Int16TypeDefinition>(baseType, path) {
 199             @Nonnull
 200             @Override
 201             public Int16TypeDefinition buildType() {
 202                 return new DerivedInt16Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 203                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 204             }
 205         };
 206     }
 207
 208     private static ConcreteTypeBuilder<Int32TypeDefinition> concreteInt32Builder(
 209             final Int32TypeDefinition baseType, final SchemaPath path) {
 210         return new ConcreteTypeBuilder<Int32TypeDefinition>(baseType, path) {
 211             @Nonnull
 212             @Override
 213             public Int32TypeDefinition buildType() {
 214                 return new DerivedInt32Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 215                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 216             }
 217         };
 218     }
 219
 220     private static ConcreteTypeBuilder<Int64TypeDefinition> concreteInt64Builder(
 221             final Int64TypeDefinition baseType, final SchemaPath path) {
 222         return new ConcreteTypeBuilder<Int64TypeDefinition>(baseType, path) {
 223             @Nonnull
 224             @Override
 225             public Int64TypeDefinition buildType() {
 226                 return new DerivedInt64Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 227                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 228             }
 229         };
 230     }
 231
 232     private static ConcreteTypeBuilder<LeafrefTypeDefinition> concreteLeafrefBuilder(
 233             final LeafrefTypeDefinition baseType, final SchemaPath path) {
 234         return new ConcreteTypeBuilder<LeafrefTypeDefinition>(baseType, path) {
 235             @Nonnull
 236             @Override
 237             public LeafrefTypeDefinition buildType() {
 238                 return new DerivedLeafrefType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 239                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 240             }
 241         };
 242     }
 243
 244     private static ConcreteTypeBuilder<StringTypeDefinition> concreteStringBuilder(final StringTypeDefinition baseType,
 245             final SchemaPath path) {
 246         return new ConcreteTypeBuilder<StringTypeDefinition>(baseType, path) {
 247             @Nonnull
 248             @Override
 249             public StringTypeDefinition buildType() {
 250                 return new DerivedStringType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 251                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 252             }
 253         };
 254     }
 255
 256     private static ConcreteTypeBuilder<UnionTypeDefinition> concreteUnionBuilder(final UnionTypeDefinition baseType,
 257             final SchemaPath path) {
 258         return new ConcreteTypeBuilder<UnionTypeDefinition>(baseType, path) {
 259             @Nonnull
 260             @Override
 261             public DerivedUnionType buildType() {
 262                 return new DerivedUnionType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 263                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 264             }
 265         };
 266     }
 267
 268     private static ConcreteTypeBuilder<Uint8TypeDefinition> concreteUint8Builder(
 269             final Uint8TypeDefinition baseType, final SchemaPath path) {
 270         return new ConcreteTypeBuilder<Uint8TypeDefinition>(baseType, path) {
 271             @Nonnull
 272             @Override
 273             public Uint8TypeDefinition buildType() {
 274                 return new DerivedUint8Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 275                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 276             }
 277         };
 278     }
 279
 280     private static ConcreteTypeBuilder<Uint16TypeDefinition> concreteUint16Builder(
 281             final Uint16TypeDefinition baseType, final SchemaPath path) {
 282         return new ConcreteTypeBuilder<Uint16TypeDefinition>(baseType, path) {
 283             @Nonnull
 284             @Override
 285             public Uint16TypeDefinition buildType() {
 286                 return new DerivedUint16Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 287                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 288             }
 289         };
 290     }
 291
 292     private static ConcreteTypeBuilder<Uint32TypeDefinition> concreteUint32Builder(
 293             final Uint32TypeDefinition baseType, final SchemaPath path) {
 294         return new ConcreteTypeBuilder<Uint32TypeDefinition>(baseType, path) {
 295             @Nonnull
 296             @Override
 297             public Uint32TypeDefinition buildType() {
 298                 return new DerivedUint32Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 299                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 300             }
 301         };
 302     }
 303
 304     private static ConcreteTypeBuilder<Uint64TypeDefinition> concreteUint64Builder(
 305             final Uint64TypeDefinition baseType, final SchemaPath path) {
 306         return new ConcreteTypeBuilder<Uint64TypeDefinition>(baseType, path) {
 307             @Nonnull
 308             @Override
 309             public Uint64TypeDefinition buildType() {
 310                 return new DerivedUint64Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 311                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 312             }
 313         };
 314     }
 315 }