import org.opendaylight.yangtools.yang.model.api.TypeDefinition; //导入依赖的package包/类
/**
 * De-serializes a string.
 * @param typeDefinition - Type Definition
 * @param input - Input
 * @return De-serialized JSON string
 */
private Object deserialize(final TypeDefinition<?> typeDefinition, String input) {
    TypeDefinition<?> type = resolveBaseTypeFrom(typeDefinition);

    try {
        if ((type instanceof IdentityrefTypeDefinition) || (type instanceof InstanceIdentifierTypeDefinition)) {
            return null;
        } else {
            final TypeDefinitionAwareCodec<Object, ? extends TypeDefinition<?>> typeAwarecodec = TypeDefinitionAwareCodec
                    .from(type);
            if (typeAwarecodec != null) {
                return typeAwarecodec.deserialize(input);
            } else {
                return null;
            }
        }
    } catch (final ClassCastException e) {
        LOG.error(
                "ClassCastException was thrown when codec is invoked with parameter " + String.valueOf(input),
                e);
        return null;
    }
}
 

import org.opendaylight.yangtools.yang.model.api.TypeDefinition; //导入依赖的package包/类
@Override
public OpenType<?> getOpenType() {
    final TypeDefinition<?> baseTypeDefinition = getBaseType(this.typeProviderWrapper, this.typeDefinition);
    final Type baseType = this.typeProviderWrapper.getType(baseTypeDefinition, baseTypeDefinition);

    if (isArray()) {
        return getArrayType();
    } else if (isEnum()) {
        return getEnumType(baseTypeDefinition);
    } else if (isUnion()) {
        return getCompositeTypeForUnion(baseTypeDefinition);
    } else if (isDerivedType(baseType, getType())) {
        return getCompositeType(baseType, baseTypeDefinition);
    } else if (isIdentityRef()) {
        return getCompositeTypeForIdentity();
    }

    return getSimpleType(getType());
}
 

import org.opendaylight.yangtools.yang.model.api.TypeDefinition; //导入依赖的package包/类
private OpenType<?> getCompositeType(final Type baseType, final TypeDefinition<?> baseTypeDefinition) {

        final SimpleType<?> innerItemType = SimpleTypeResolver.getSimpleType(baseType);
        final String innerItemName = this.typeProviderWrapper.getJMXParamForBaseType(baseTypeDefinition);

        final String[] itemNames = new String[]{innerItemName};
        final String description = getNullableDescription() == null ? getAttributeYangName() : getNullableDescription();

        final OpenType<?>[] itemTypes = new OpenType[]{innerItemType};
        try {
            return new CompositeType(getUpperCaseCammelCase(), description, itemNames, itemNames, itemTypes);
        } catch (final OpenDataException e) {
            throw new RuntimeException("Unable to create " + CompositeType.class + " with inner element of type "
                    + itemTypes, e);
        }
    }
 

import org.opendaylight.yangtools.yang.model.api.TypeDefinition; //导入依赖的package包/类
@Override
@SuppressWarnings("checkstyle:illegalCatch")
public final String serialize(final Object data) {
    for (final TypeDefinition<?> type : typeDefinition.getTypes()) {
        Codec<String, Object> codec = codecFor(type);
        if (codec == null) {
            LOG.debug("no codec found for {}", type);
            continue;
        }
        try {
            return codec.serialize(data);
        } catch (final Exception e) {
            LOG.debug("Data {} did not match for {}", data, type, e);
            // invalid - try the next union type.
        }
    }
    throw new IllegalArgumentException("Invalid data \"" + data + "\" for union type.");
}
 

import org.opendaylight.yangtools.yang.model.api.TypeDefinition; //导入依赖的package包/类
private T createComplexUnion(final TypedDataSchemaNode schema, final UnionTypeDefinition union) {
    final List<TypeDefinition<?>> types = union.getTypes();
    final List<T> codecs = new ArrayList<>(types.size());

    for (TypeDefinition<?> type : types) {
        T codec = cache.lookupSimple(type);
        if (codec == null) {
            codec = getSimpleCodecFor(type);
            if (codec == null) {
                codec = createComplexCodecFor(schema, type);
            }
        }

        codecs.add(verifyNotNull(codec, "Schema %s subtype %s has no codec", schema, type));
    }

    return unionCodec(union, codecs);
}
 

import org.opendaylight.yangtools.yang.model.api.TypeDefinition; //导入依赖的package包/类
private LeafSchemaNode findSchemaNodeWithLeafrefType(final DataNodeContainer module, final String nodeName) {
    for (final DataSchemaNode childNode : module.getChildNodes()) {
        if (childNode instanceof DataNodeContainer) {
            LeafSchemaNode leafrefFromRecursion = findSchemaNodeWithLeafrefType((DataNodeContainer) childNode,
                    nodeName);
            if (leafrefFromRecursion != null) {
                return leafrefFromRecursion;
            }
        } else if (childNode.getQName().getLocalName().equals(nodeName) && childNode instanceof LeafSchemaNode) {
            final TypeDefinition<?> leafSchemaNodeType = ((LeafSchemaNode) childNode).getType();
            if (leafSchemaNodeType instanceof LeafrefTypeDefinition) {
                return (LeafSchemaNode) childNode;
            }
        }
    }
    return null;
}
 

import org.opendaylight.yangtools.yang.model.api.TypeDefinition; //导入依赖的package包/类
@Test
public void testOrderingTypedef() throws Exception {
    final Set<TypeDefinition<?>> typedefs = bar.getTypeDefinitions();
    final String[] expectedOrder = { "int32-ext1", "int32-ext2", "string-ext1", "string-ext2", "string-ext3",
        "string-ext4", "invalid-string-pattern", "multiple-pattern-string", "my-decimal-type", "my-union",
        "my-union-ext", "nested-union2"
    };
    final String[] actualOrder = new String[typedefs.size()];

    int offset = 0;
    for (final TypeDefinition<?> type : typedefs) {
        actualOrder[offset] = type.getQName().getLocalName();
        offset++;
    }
    assertArrayEquals(expectedOrder, actualOrder);
}
 

import org.opendaylight.yangtools.yang.model.api.TypeDefinition; //导入依赖的package包/类
@Test
public void testAddedByUsesLeafTypeQName() throws Exception {
    final SchemaContext loadModules = TestUtils.loadModules(getClass().getResource("/added-by-uses-leaf-test")
            .toURI());
    assertEquals(2, loadModules.getModules().size());
    foo = TestUtils.findModule(loadModules, "foo").get();
    final Module imp = TestUtils.findModule(loadModules, "import-module").get();

    final LeafSchemaNode leaf = (LeafSchemaNode) ((ContainerSchemaNode) foo.getDataChildByName(QName.create(
            foo.getQNameModule(), "my-container")))
            .getDataChildByName(QName.create(foo.getQNameModule(), "my-leaf"));

    TypeDefinition<?> impType = null;
    final Set<TypeDefinition<?>> typeDefinitions = imp.getTypeDefinitions();
    for (final TypeDefinition<?> typeDefinition : typeDefinitions) {
        if (typeDefinition.getQName().getLocalName().equals("imp-type")) {
            impType = typeDefinition;
            break;
        }
    }

    assertNotNull(impType);
    assertEquals(leaf.getType().getQName(), impType.getQName());
}
 

import org.opendaylight.yangtools.yang.model.api.TypeDefinition; //导入依赖的package包/类
private static void verifySingleQuotesExpression(final SchemaContext schemaContext) {
    final DataSchemaNode dataNodeBar = schemaContext.getDataChildByName(QName.create("foo", "2016-07-11", "bar"));
    assertTrue(dataNodeBar instanceof ContainerSchemaNode);
    final ContainerSchemaNode bar = (ContainerSchemaNode) dataNodeBar;
    final RevisionAwareXPath whenCondition = bar.getWhenCondition().get();
    assertEquals("/foo != 'bar'", whenCondition.toString());

    final Set<TypeDefinition<?>> typeDefinitions = schemaContext.getTypeDefinitions();
    assertEquals(1, typeDefinitions.size());
    final TypeDefinition<?> type = typeDefinitions.iterator().next();
    assertTrue(type instanceof StringTypeDefinition);
    final List<PatternConstraint> patternConstraints = ((StringTypeDefinition) type).getPatternConstraints();
    assertEquals(1, patternConstraints.size());
    final PatternConstraint pattern = patternConstraints.iterator().next();
    assertEquals("^'.*'$", pattern.getJavaPatternString());
    assertTrue(Pattern.compile(pattern.getJavaPatternString()).matcher("'enclosed string in quotes'").matches());
}
 

import org.opendaylight.yangtools.yang.model.api.TypeDefinition; //导入依赖的package包/类
@Test
public void test() throws Exception {
    final SchemaContext schema = StmtTestUtils.parseYangSources("/bugs/bug2872");
    assertNotNull(schema);

    final QNameModule bug2872module = QNameModule.create(URI.create("bug2872"), Revision.of("2016-06-08"));
    final QName foo = QName.create(bug2872module, "bar");

    final DataSchemaNode dataSchemaNode = schema.getDataChildByName(foo);
    assertTrue(dataSchemaNode instanceof LeafSchemaNode);
    final LeafSchemaNode myLeaf = (LeafSchemaNode) dataSchemaNode;

    final TypeDefinition<?> type = myLeaf.getType();
    assertTrue(type instanceof EnumTypeDefinition);
    final EnumTypeDefinition myEnum = (EnumTypeDefinition) type;

    final List<EnumTypeDefinition.EnumPair> values = myEnum.getValues();
    assertEquals(2, values.size());

    final List<String> valueNames = new ArrayList<>();
    for (EnumTypeDefinition.EnumPair pair : values) {
        valueNames.add(pair.getName());
    }
    assertTrue(valueNames.contains("value-one"));
    assertTrue(valueNames.contains("value-two"));
}
 

import org.opendaylight.yangtools.yang.model.api.TypeDefinition; //导入依赖的package包/类
@Test
public void testDomainName() {
    Module tested = TestUtils.findModule(context, "ietf-inet-types").get();
    Set<TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
    StringTypeDefinition type = (StringTypeDefinition) TestUtils.findTypedef(typedefs, "domain-name");
    assertNotNull(type.getBaseType());
    List<PatternConstraint> patterns = type.getPatternConstraints();
    assertEquals(1, patterns.size());
    String expectedPattern = "^((([a-zA-Z0-9_]([a-zA-Z0-9\\-_]){0,61})?[a-zA-Z0-9]\\.)*"
            + "([a-zA-Z0-9_]([a-zA-Z0-9\\-_]){0,61})?[a-zA-Z0-9]\\.?)" + "|\\.$";
    assertEquals(expectedPattern, patterns.get(0).getJavaPatternString());

    LengthConstraint lengths = type.getLengthConstraint().get();
    assertEquals(1, lengths.getAllowedRanges().asRanges().size());
    Range<Integer> length = lengths.getAllowedRanges().span();
    assertEquals(Integer.valueOf(1), length.lowerEndpoint());
    assertEquals(Integer.valueOf(253), length.upperEndpoint());
}
 

import org.opendaylight.yangtools.yang.model.api.TypeDefinition; //导入依赖的package包/类
private T createComplexCodecFor(final TypedDataSchemaNode schema, final TypeDefinition<?> type) {
    if (type instanceof UnionTypeDefinition) {
        return createComplexUnion(schema, (UnionTypeDefinition) type);
    } else if (type instanceof LeafrefTypeDefinition) {
        final TypeDefinition<?> target = SchemaContextUtil.getBaseTypeForLeafRef((LeafrefTypeDefinition) type,
            schemaContext, schema);
        verifyNotNull(target, "Unable to find base type for leafref node %s type %s.", schema.getPath(),
                target);

        final T ret = getSimpleCodecFor(target);
        return ret != null ? ret : createComplexCodecFor(schema, target);
    } else if (type instanceof IdentityrefTypeDefinition) {
        return identityRefCodec((IdentityrefTypeDefinition) type, schema.getQName().getModule());
    } else {
        throw new IllegalArgumentException("Unsupported type " + type);
    }
}
 

import org.opendaylight.yangtools.yang.model.api.TypeDefinition; //导入依赖的package包/类
@Test
public void testTypePath() throws ParseException {
    final Set<TypeDefinition<?>> types = bar.getTypeDefinitions();

    // int32-ext1
    final Int32TypeDefinition int32ext1 = (Int32TypeDefinition) TestUtils.findTypedef(types, "int32-ext1");
    final QName int32TypedefQName = QName.create(BAR, "int32-ext1");
    assertEquals(int32TypedefQName, int32ext1.getQName());

    final SchemaPath typeSchemaPath = int32ext1.getPath();
    final Iterable<QName> typePath = typeSchemaPath.getPathFromRoot();
    final Iterator<QName> typePathIt = typePath.iterator();
    assertEquals(int32TypedefQName, typePathIt.next());
    assertFalse(typePathIt.hasNext());

    // int32-ext1/int32
    final Int32TypeDefinition int32 = int32ext1.getBaseType();
    assertEquals(BaseTypes.int32Type(), int32);
}
 

import org.opendaylight.yangtools.yang.model.api.TypeDefinition; //导入依赖的package包/类
@Test
public void testRestrictedTypeParentSchemaPathInDeviate() throws Exception {
    final SchemaContext schemaContext = StmtTestUtils.parseYangSources("/bugs/bug7440");
    assertNotNull(schemaContext);

    final Revision revision = Revision.of("2016-12-23");
    final Module foo = schemaContext.findModule("foo", revision).get();
    final Module bar = schemaContext.findModule("bar", revision).get();

    final Set<Deviation> deviations = foo.getDeviations();
    assertEquals(1, deviations.size());
    final Deviation deviation = deviations.iterator().next();

    final List<DeviateDefinition> deviates = deviation.getDeviates();
    assertEquals(1, deviates.size());
    final DeviateDefinition deviateReplace = deviates.iterator().next();

    final SchemaPath deviatedTypePath = SchemaPath.create(true, QName.create(bar.getQNameModule(), "test-leaf"),
            QName.create(bar.getQNameModule(), "uint32"));

    final TypeDefinition<?> deviatedType = deviateReplace.getDeviatedType();
    assertEquals(deviatedTypePath, deviatedType.getPath());
}
 

import org.opendaylight.yangtools.yang.model.api.TypeDefinition; //导入依赖的package包/类
/**
 * Returns base type for {@code typeDefinition} which belongs to module specified via {@code qname}. This handle
 * the case when leafref type isn't specified as type substatement of leaf or leaf-list but is defined in other
 * module as typedef which is then imported to referenced module.
 *
 * <p>
 * Because {@code typeDefinition} is definied via typedef statement, only absolute path is meaningful.
 */
public static TypeDefinition<?> getBaseTypeForLeafRef(final LeafrefTypeDefinition typeDefinition,
        final SchemaContext schemaContext, final QName qname) {
    final RevisionAwareXPath pathStatement = typeDefinition.getPathStatement();
    final RevisionAwareXPath strippedPathStatement = new RevisionAwareXPathImpl(
        stripConditionsFromXPathString(pathStatement), pathStatement.isAbsolute());
    if (!strippedPathStatement.isAbsolute()) {
        return null;
    }

    final Optional<Module> parentModule = schemaContext.findModule(qname.getModule());
    Preconditions.checkArgument(parentModule.isPresent(), "Failed to find parent module for %s", qname);

    final DataSchemaNode dataSchemaNode = (DataSchemaNode) SchemaContextUtil.findDataSchemaNode(schemaContext,
        parentModule.get(), strippedPathStatement);
    final TypeDefinition<?> targetTypeDefinition = typeDefinition(dataSchemaNode);
    if (targetTypeDefinition instanceof LeafrefTypeDefinition) {
        return getBaseTypeForLeafRef((LeafrefTypeDefinition) targetTypeDefinition, schemaContext, dataSchemaNode);
    }

    return targetTypeDefinition;
}
 

import org.opendaylight.yangtools.yang.model.api.TypeDefinition; //导入依赖的package包/类
private static Module findParentModuleOfReferencingType(final SchemaContext schemaContext,
        final SchemaNode schemaNode) {
    Preconditions.checkArgument(schemaContext != null, "Schema Context reference cannot be NULL!");
    Preconditions.checkArgument(schemaNode instanceof TypedDataSchemaNode, "Unsupported node %s", schemaNode);

    TypeDefinition<?> nodeType = ((TypedDataSchemaNode) schemaNode).getType();
    if (nodeType.getBaseType() != null) {
        while (nodeType.getBaseType() != null) {
            nodeType = nodeType.getBaseType();
        }

        return schemaContext.findModule(nodeType.getQName().getModule()).orElse(null);
    }

    return SchemaContextUtil.findParentModule(schemaContext, schemaNode);
}
 

import org.opendaylight.yangtools.yang.model.api.TypeDefinition; //导入依赖的package包/类
/**
 * Adds a Key Value to the map for a specific uri value.
 * @param map - current QName to Object mapping
 * @param node - DataSchemaNode
 * @param uriValue - uri value to add
 * @throws Exception if error occurs during Uri decoding.
 */
private void addKeyValue(final HashMap<QName, Object> map, final DataSchemaNode node, final String uriValue)
        throws Exception {
    Preconditions.checkNotNull(uriValue);
    Preconditions.checkArgument((node instanceof LeafSchemaNode));

    final String urlDecoded = urlPathArgDecode(uriValue);
    TypeDefinition<?> typedef = ((LeafSchemaNode) node).getType();
    final TypeDefinition<?> baseType = resolveBaseTypeFrom(typedef);
    if (baseType instanceof LeafrefTypeDefinition) {
        typedef = SchemaContextUtil.getBaseTypeForLeafRef((LeafrefTypeDefinition) baseType, globalSchema, node);
    }

    Object decoded = deserialize(typedef, urlDecoded);
    String additionalInfo = "";
    if (decoded == null) {
        if ((baseType instanceof IdentityrefTypeDefinition)) {
            decoded = toQName(urlDecoded);
            additionalInfo = "For key which is of type identityref it should be in format module_name:identity_name.";
        }
    }

    if (decoded == null) {
        throw new Exception(uriValue + " from URI can't be resolved. " + additionalInfo);
    }

    map.put(node.getQName(), decoded);
}
 

import org.opendaylight.yangtools.yang.model.api.TypeDefinition; //导入依赖的package包/类
/**
 * Resolves the Base Type of a TypeDefinition
 * @param type - TypeDefinition
 * @return Base type for the TypeDefinition
 */
private TypeDefinition<?> resolveBaseTypeFrom(final TypeDefinition<?> type) {
    TypeDefinition<?> superType = type;
    while (superType.getBaseType() != null) {
        superType = superType.getBaseType();
    }
    return superType;
}
 

import org.opendaylight.yangtools.yang.model.api.TypeDefinition; //导入依赖的package包/类
/**
 * Returns the most base type
 */
private TypeDefinition<?> getBaseType(final TypeProviderWrapper typeProviderWrapper, TypeDefinition<?> baseType) {
    while(baseType.getBaseType()!=null) {
        baseType = baseType.getBaseType();
    }
    return baseType;
}
 

import org.opendaylight.yangtools.yang.model.api.TypeDefinition; //导入依赖的package包/类
private OpenType<?> getEnumType(final TypeDefinition<?> baseType) {
    final String fullyQualifiedName = this.typeProviderWrapper.getType(this.node, getTypeDefinition()).getFullyQualifiedName();
    final String[] items = {"instance"};
    final String description = getNullableDescription() == null ? getAttributeYangName() : getNullableDescription();

    try {
        return new CompositeType(fullyQualifiedName, description, items, items, new OpenType[]{SimpleType.STRING});
    } catch (final OpenDataException e) {
        throw new RuntimeException("Unable to create enum type" + fullyQualifiedName + " as open type", e);
    }
}