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.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  * Support for creating {@link TypeDefinition} instances defined by leaf and leaf-list statements.
  30  */
  31 @Beta
  32 public final class ConcreteTypes {
  33     private ConcreteTypes() {
  34         throw new UnsupportedOperationException();
  35     }
  36
  37     public static ConcreteTypeBuilder<?> concreteTypeBuilder(@Nonnull final TypeDefinition<?> baseType,
  38             @Nonnull final SchemaPath path) {
  39         if (baseType instanceof BinaryTypeDefinition) {
  40             return concreteBinaryBuilder((BinaryTypeDefinition) baseType, path);
  41         } else if (baseType instanceof BitsTypeDefinition) {
  42             return concreteBitsBuilder((BitsTypeDefinition) baseType, path);
  43         } else if (baseType instanceof BooleanTypeDefinition) {
  44             return concreteBooleanBuilder((BooleanTypeDefinition) baseType, path);
  45         } else if (baseType instanceof DecimalTypeDefinition) {
  46             return concreteDecimalBuilder((DecimalTypeDefinition) baseType, path);
  47         } else if (baseType instanceof EmptyTypeDefinition) {
  48             return concreteEmptyBuilder((EmptyTypeDefinition) baseType, path);
  49         } else if (baseType instanceof EnumTypeDefinition) {
  50             return concreteEnumerationBuilder((EnumTypeDefinition) baseType, path);
  51         } else if (baseType instanceof IdentityrefTypeDefinition) {
  52             return concreteIdentityrefBuilder((IdentityrefTypeDefinition) baseType, path);
  53         } else if (baseType instanceof InstanceIdentifierTypeDefinition) {
  54             return concreteInstanceIdentifierBuilder((InstanceIdentifierTypeDefinition) baseType, path);
  55         } else if (baseType instanceof IntegerTypeDefinition) {
  56             return concreteIntegerBuilder((IntegerTypeDefinition) baseType, path);
  57         } else if (baseType instanceof LeafrefTypeDefinition) {
  58             return concreteLeafrefBuilder((LeafrefTypeDefinition) baseType, path);
  59         } else if (baseType instanceof StringTypeDefinition) {
  60             return concreteStringBuilder((StringTypeDefinition) baseType, path);
  61         } else if (baseType instanceof UnionTypeDefinition) {
  62             return concreteUnionBuilder((UnionTypeDefinition) baseType, path);
  63         } else if (baseType instanceof UnsignedIntegerTypeDefinition) {
  64             return concreteUnsignedBuilder((UnsignedIntegerTypeDefinition) baseType, path);
  65         } else {
  66             throw new IllegalArgumentException("Unhandled type definition class " + baseType.getClass());
  67         }
  68     }
  69
  70     private static ConcreteTypeBuilder<BinaryTypeDefinition> concreteBinaryBuilder(
  71             @Nonnull final BinaryTypeDefinition baseType, @Nonnull final SchemaPath path) {
  72         return new ConcreteTypeBuilder<BinaryTypeDefinition>(baseType, path) {
  73             @Nonnull
  74             @Override
  75             public BinaryTypeDefinition buildType() {
  76                 return new DerivedBinaryType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
  77                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
  78             }
  79         };
  80     }
  81
  82     private static ConcreteTypeBuilder<BitsTypeDefinition> concreteBitsBuilder(final BitsTypeDefinition baseType,
  83             final SchemaPath path) {
  84         return new ConcreteTypeBuilder<BitsTypeDefinition>(baseType, path) {
  85             @Nonnull
  86             @Override
  87             public BitsTypeDefinition buildType() {
  88                 return new DerivedBitsType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
  89                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
  90             }
  91         };
  92     }
  93
  94     private static ConcreteTypeBuilder<BooleanTypeDefinition> concreteBooleanBuilder(
  95             @Nonnull final BooleanTypeDefinition baseType, @Nonnull final SchemaPath path) {
  96         return new ConcreteTypeBuilder<BooleanTypeDefinition>(baseType, path) {
  97             @Nonnull
  98             @Override
  99             public BooleanTypeDefinition buildType() {
 100                 return new DerivedBooleanType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 101                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 102             }
 103         };
 104     }
 105
 106     private static ConcreteTypeBuilder<DecimalTypeDefinition> concreteDecimalBuilder(
 107             final DecimalTypeDefinition baseType, final SchemaPath path) {
 108         return new ConcreteTypeBuilder<DecimalTypeDefinition>(baseType, path) {
 109             @Nonnull
 110             @Override
 111             public DecimalTypeDefinition buildType() {
 112                 return new DerivedDecimalType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 113                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 114             }
 115         };
 116     }
 117
 118     private static ConcreteTypeBuilder<EmptyTypeDefinition> concreteEmptyBuilder(final EmptyTypeDefinition baseType,
 119             final SchemaPath path) {
 120         return new ConcreteTypeBuilder<EmptyTypeDefinition>(baseType, path) {
 121             @Nonnull
 122             @Override
 123             public EmptyTypeDefinition buildType() {
 124                 return new DerivedEmptyType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 125                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 126             }
 127         };
 128     }
 129
 130     private static ConcreteTypeBuilder<EnumTypeDefinition> concreteEnumerationBuilder(
 131             final EnumTypeDefinition baseType, final SchemaPath path) {
 132         return new ConcreteTypeBuilder<EnumTypeDefinition>(baseType, path) {
 133             @Nonnull
 134             @Override
 135             public EnumTypeDefinition buildType() {
 136                 return new DerivedEnumerationType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 137                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 138             }
 139         };
 140     }
 141
 142     private static ConcreteTypeBuilder<IdentityrefTypeDefinition> concreteIdentityrefBuilder(
 143             final IdentityrefTypeDefinition baseType, final SchemaPath path) {
 144         return new ConcreteTypeBuilder<IdentityrefTypeDefinition>(baseType, path) {
 145             @Nonnull
 146             @Override
 147             public IdentityrefTypeDefinition buildType() {
 148                 return new DerivedIdentityrefType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 149                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 150             }
 151         };
 152     }
 153
 154     private static ConcreteTypeBuilder<InstanceIdentifierTypeDefinition> concreteInstanceIdentifierBuilder(
 155             final InstanceIdentifierTypeDefinition baseType, final SchemaPath path) {
 156         return new ConcreteTypeBuilder<InstanceIdentifierTypeDefinition>(baseType, path) {
 157             @Nonnull
 158             @Override
 159             public InstanceIdentifierTypeDefinition buildType() {
 160                 return new DerivedInstanceIdentifierType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 161                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes(), baseType.requireInstance());
 162             }
 163         };
 164     }
 165
 166     private static ConcreteTypeBuilder<IntegerTypeDefinition> concreteIntegerBuilder(
 167             final IntegerTypeDefinition baseType, final SchemaPath path) {
 168         return new ConcreteTypeBuilder<IntegerTypeDefinition>(baseType, path) {
 169             @Nonnull
 170             @Override
 171             public IntegerTypeDefinition buildType() {
 172                 return new DerivedIntegerType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 173                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 174             }
 175         };
 176     }
 177
 178     private static ConcreteTypeBuilder<LeafrefTypeDefinition> concreteLeafrefBuilder(
 179             final LeafrefTypeDefinition baseType, final SchemaPath path) {
 180         return new ConcreteTypeBuilder<LeafrefTypeDefinition>(baseType, path) {
 181             @Nonnull
 182             @Override
 183             public LeafrefTypeDefinition buildType() {
 184                 return new DerivedLeafrefType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 185                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 186             }
 187         };
 188     }
 189
 190     private static ConcreteTypeBuilder<StringTypeDefinition> concreteStringBuilder(final StringTypeDefinition baseType,
 191             final SchemaPath path) {
 192         return new ConcreteTypeBuilder<StringTypeDefinition>(baseType, path) {
 193             @Nonnull
 194             @Override
 195             public StringTypeDefinition buildType() {
 196                 return new DerivedStringType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 197                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 198             }
 199         };
 200     }
 201
 202     private static ConcreteTypeBuilder<UnionTypeDefinition> concreteUnionBuilder(final UnionTypeDefinition baseType,
 203             final SchemaPath path) {
 204         return new ConcreteTypeBuilder<UnionTypeDefinition>(baseType, path) {
 205             @Nonnull
 206             @Override
 207             public DerivedUnionType buildType() {
 208                 return new DerivedUnionType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 209                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 210             }
 211         };
 212     }
 213
 214     private static ConcreteTypeBuilder<UnsignedIntegerTypeDefinition> concreteUnsignedBuilder(
 215             final UnsignedIntegerTypeDefinition baseType, final SchemaPath path) {
 216         return new ConcreteTypeBuilder<UnsignedIntegerTypeDefinition>(baseType, path) {
 217             @Nonnull
 218             @Override
 219             public UnsignedIntegerTypeDefinition buildType() {
 220                 return new DerivedUnsignedType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
 221                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
 222             }
 223         };
 224     }
 225 }