X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-model-util%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fmodel%2Futil%2FBaseTypes.java;h=dccd07221db1baa4cc2e9867b4e5b85044b9292c;hb=f17468a85e7733d50cbc17f08ea537e626c33e26;hp=54709aeabbc491d03d447ad84a93f02d65e94d8c;hpb=b56b6b6c5c705a2a39d1c6835c22a067de0f6966;p=yangtools.git diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/BaseTypes.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/BaseTypes.java index 54709aeabb..dccd07221d 100644 --- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/BaseTypes.java +++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/BaseTypes.java @@ -7,66 +7,104 @@ */ package org.opendaylight.yangtools.yang.model.util; +import com.google.common.base.Optional; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableSet; + import java.net.URI; import java.util.ArrayList; -import java.util.Collections; import java.util.Date; import java.util.List; +import java.util.Set; import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.common.QNameModule; import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.model.api.TypeDefinition; +/** + * Utility methods and constants to work with built-in YANG types + * + * + */ public final class BaseTypes { private BaseTypes() { } public static final URI BASE_TYPES_NAMESPACE = URI.create("urn:ietf:params:xml:ns:yang:1"); - public static QName BINARY_QNAME = constructQName("binary"); - public static QName BITS_QNAME = constructQName("bits"); - public static QName BOOLEAN_QNAME = constructQName("boolean"); - public static QName DECIMAL64_QNAME = constructQName("decimal64"); - public static QName EMPTY_QNAME = constructQName("empty"); - public static QName ENUMERATION_QNAME = constructQName("enumeration"); - public static QName INT8_QNAME = constructQName("int8"); - public static QName INT16_QNAME = constructQName("int16"); - public static QName INT32_QNAME = constructQName("int32"); - public static QName INT64_QNAME = constructQName("int64"); - public static QName LEAFREF_QNAME = constructQName("leafref"); - public static QName STRING_QNAME = constructQName("string"); - public static QName UINT8_QNAME = constructQName("uint8"); - public static QName UINT16_QNAME = constructQName("uint16"); - public static QName UINT32_QNAME = constructQName("uint32"); - public static QName UINT64_QNAME = constructQName("uint64"); + public static final QNameModule BASE_TYPES_MODULE = QNameModule.create(BASE_TYPES_NAMESPACE, null); + + public static final QName BINARY_QNAME = constructQName("binary"); + public static final QName BITS_QNAME = constructQName("bits"); + public static final QName BOOLEAN_QNAME = constructQName("boolean"); + public static final QName DECIMAL64_QNAME = constructQName("decimal64"); + public static final QName EMPTY_QNAME = constructQName("empty"); + public static final QName ENUMERATION_QNAME = constructQName("enumeration"); + public static final QName IDENTITYREF_QNAME = constructQName("identityref"); + public static final QName INSTANCE_IDENTIFIER_QNAME = constructQName("instance-identifier"); + public static final QName INT8_QNAME = constructQName("int8"); + public static final QName INT16_QNAME = constructQName("int16"); + public static final QName INT32_QNAME = constructQName("int32"); + public static final QName INT64_QNAME = constructQName("int64"); + public static final QName LEAFREF_QNAME = constructQName("leafref"); + public static final QName STRING_QNAME = constructQName("string"); + public static final QName UINT8_QNAME = constructQName("uint8"); + public static final QName UINT16_QNAME = constructQName("uint16"); + public static final QName UINT32_QNAME = constructQName("uint32"); + public static final QName UINT64_QNAME = constructQName("uint64"); + public static final QName UNION_QNAME = constructQName("union"); + + private static final Set BUILD_IN_TYPES = ImmutableSet. builder().add(BINARY_QNAME.getLocalName()) // + .add(BITS_QNAME.getLocalName()) // + .add(BOOLEAN_QNAME.getLocalName()) // + .add(DECIMAL64_QNAME.getLocalName()) // + .add(EMPTY_QNAME.getLocalName()) // + .add(ENUMERATION_QNAME.getLocalName()) // + .add(IDENTITYREF_QNAME.getLocalName()) // + .add(INSTANCE_IDENTIFIER_QNAME.getLocalName()) // + .add(INT8_QNAME.getLocalName()) // + .add(INT16_QNAME.getLocalName()) // + .add(INT32_QNAME.getLocalName()) // + .add(INT64_QNAME.getLocalName()) // + .add(LEAFREF_QNAME.getLocalName()) // + .add(STRING_QNAME.getLocalName()) // + .add(UINT8_QNAME.getLocalName()) // + .add(UINT16_QNAME.getLocalName()) // + .add(UINT32_QNAME.getLocalName()) // + .add(UINT64_QNAME.getLocalName()) // + .add(UNION_QNAME.getLocalName()) // + .build(); /** * Construct QName for Built-in base Yang type. The namespace for built-in * base yang types is defined as: urn:ietf:params:xml:ns:yang:1 - * + * * @param typeName * yang type name * @return built-in base yang type QName. */ public static QName constructQName(final String typeName) { - return new QName(BASE_TYPES_NAMESPACE, typeName); + return QName.create(BASE_TYPES_MODULE, "", typeName); } /** - * Creates Schema Path from Qname. - * + * Creates Schema Path from {@link QName}. + * * @param typeName * yang type QName * @return Schema Path from Qname. + * @deprecated Use {@link SchemaPath#create(boolean, QName...)} instead. */ + @Deprecated public static SchemaPath schemaPath(final QName typeName) { - List pathList = Collections.singletonList(typeName); - return new SchemaPath(pathList, true); + return SchemaPath.create(true, typeName); } /** * Creates Schema Path from List of partial paths defined as Strings, module * Namespace and module latest Revision Date. - * + * * @param actualPath * List of partial paths * @param namespace @@ -74,18 +112,88 @@ public final class BaseTypes { * @param revision * Revision Date * @return Schema Path + * + * @deprecated Use {@link SchemaPath#create(Iterable, boolean)} with QNames + * manually constructed. */ + @Deprecated public static SchemaPath schemaPath(final List actualPath, final URI namespace, final Date revision) { if (actualPath == null) { throw new IllegalArgumentException("The actual path List MUST be specified."); } final List pathList = new ArrayList(); for (final String path : actualPath) { - final QName qname = new QName(namespace, revision, path); + final QName qname = QName.create(namespace, revision, path); if (qname != null) { pathList.add(qname); } } - return new SchemaPath(pathList, true); + return SchemaPath.create(pathList, true); + } + + /** + * Returns true if supplied type is representation of built-in YANG type as + * per RFC 6020. + * + * See package documentation for description of base types. + * + * @param type + * @return true if type is built-in YANG Types. + */ + public static boolean isYangBuildInType(final String type) { + return BUILD_IN_TYPES.contains(type); + } + + /** + * Returns default instance of built-in for supplied type + * + * See package documentation for description of base build-in types + * with default instance. + * + * @param typeName + * @return Returns default instance or {@link Optional#absent()} if default + * instance does not exists + * + */ + public static Optional> defaultBaseTypeFor(final String typeName) { + return Optional.> fromNullable(defaultBaseTypeForImpl(typeName)); + } + + private static TypeDefinition defaultBaseTypeForImpl(final String typeName) { + Preconditions.checkNotNull(typeName, "typeName must not be null."); + + if (typeName.startsWith("int")) { + if ("int8".equals(typeName)) { + return Int8.getInstance(); + } else if ("int16".equals(typeName)) { + return Int16.getInstance(); + } else if ("int32".equals(typeName)) { + return Int32.getInstance(); + } else if ("int64".equals(typeName)) { + return Int64.getInstance(); + } + } else if (typeName.startsWith("uint")) { + if ("uint8".equals(typeName)) { + return Uint8.getInstance(); + } else if ("uint16".equals(typeName)) { + return Uint16.getInstance(); + } else if ("uint32".equals(typeName)) { + return Uint32.getInstance(); + } else if ("uint64".equals(typeName)) { + return Uint64.getInstance(); + } + } else if ("string".equals(typeName)) { + return StringType.getInstance(); + } else if ("binary".equals(typeName)) { + return BinaryType.getInstance(); + } else if ("boolean".equals(typeName)) { + return BooleanType.getInstance(); + } else if ("empty".equals(typeName)) { + return EmptyType.getInstance(); + } else if ("instance-identifier".equals(typeName)) { + return InstanceIdentifierType.getInstance(); + } + return null; } + }