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=18e58d41a5d14a8d52c2f4b993c1850feaeb1807;hb=9c98b9b0ea9d0f6ec26e64e8683cb3f1648d10d9;hp=e897f6a55cdafc034a2bb443f4dba7a30eb44607;hpb=511e9bb850e2d30b2081b1e7dc03815504874e02;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 e897f6a55c..18e58d41a5 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,27 +7,46 @@ */ package org.opendaylight.yangtools.yang.model.util; +import com.google.common.base.Optional; +import com.google.common.base.Preconditions; +import com.google.common.base.Strings; +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.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.common.QNameModule; +import org.opendaylight.yangtools.yang.common.YangConstants; +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"); + /** + * @deprecated Use {@link YangConstants#RFC6020_YANG_NAMESPACE} instead. To be removed in Boron release. + */ + @Deprecated + public static final URI BASE_TYPES_NAMESPACE = YangConstants.RFC6020_YANG_NAMESPACE; + /** + * @deprecated Use {@link YangConstants#RFC6020_YANG_MODULE} instead. To be removed in Boron release. + */ + @Deprecated + public static final QNameModule BASE_TYPES_MODULE = YangConstants.RFC6020_YANG_MODULE; + 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"); @@ -38,6 +57,29 @@ public final class BaseTypes { 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 BUILT_IN_TYPES = ImmutableSet.builder() + .add(BINARY_QNAME) + .add(BITS_QNAME) + .add(BOOLEAN_QNAME) + .add(DECIMAL64_QNAME) + .add(EMPTY_QNAME) + .add(ENUMERATION_QNAME) + .add(IDENTITYREF_QNAME) + .add(INSTANCE_IDENTIFIER_QNAME) + .add(INT8_QNAME) + .add(INT16_QNAME) + .add(INT32_QNAME) + .add(INT64_QNAME) + .add(LEAFREF_QNAME) + .add(STRING_QNAME) + .add(UINT8_QNAME) + .add(UINT16_QNAME) + .add(UINT32_QNAME) + .add(UINT64_QNAME) + .add(UNION_QNAME) + .build(); /** * Construct QName for Built-in base Yang type. The namespace for built-in @@ -48,44 +90,94 @@ public final class BaseTypes { * @return built-in base yang type QName. */ public static QName constructQName(final String typeName) { - return new QName(BASE_TYPES_NAMESPACE, typeName); + return QName.create(YangConstants.RFC6020_YANG_MODULE, typeName).intern(); } /** - * Creates Schema Path from Qname. + * Returns true if supplied type is representation of built-in YANG type as + * per RFC 6020. * - * @param typeName - * yang type QName - * @return Schema Path from Qname. + * See package documentation for description of base types. + * + * @param type + * @return true if type is built-in YANG Types. */ - public static SchemaPath schemaPath(final QName typeName) { - List pathList = Collections.singletonList(typeName); - return new SchemaPath(pathList, true); + public static boolean isYangBuildInType(final String type) { + if (Strings.isNullOrEmpty(type)) { + return false; + } + return BUILT_IN_TYPES.contains(QName.create(YangConstants.RFC6020_YANG_MODULE, type)); } /** - * Creates Schema Path from List of partial paths defined as Strings, module - * Namespace and module latest Revision Date. + * 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 actualPath - * List of partial paths - * @param namespace - * Module Namespace - * @param revision - * Revision Date - * @return Schema Path + * @param type + * @return true if type is built-in YANG Types. */ - 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."); + public static boolean isYangBuildInType(final TypeDefinition type) { + if(type == null) { + return false; } - final List pathList = new ArrayList(); - for (final String path : actualPath) { - final QName qname = new QName(namespace, revision, path); - if (qname != null) { - pathList.add(qname); + return BUILT_IN_TYPES.contains(type.getQName()); + } + + /** + * 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 + * + * @deprecated Use parser-specific lookup tables. + */ + @Deprecated + public static Optional> defaultBaseTypeFor(final String typeName) { + return Optional.> fromNullable(defaultBaseTypeForImpl(typeName)); + } + + @Deprecated + 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 new SchemaPath(pathList, true); + return null; } + }