import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition; //导入依赖的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.type.IdentityrefTypeDefinition; //导入依赖的package包/类
@VisibleForTesting
static void write(@Nonnull final XMLStreamWriter writer, @Nonnull final IdentityrefTypeDefinition type,
                  @Nonnull final Object value, final QNameModule parent) throws XMLStreamException {
    if (value instanceof QName) {
        final QName qname = (QName) value;

        //in case parent is present and same as element namespace write value without namespace
        if (qname.getNamespace().equals(parent.getNamespace())) {
            writer.writeCharacters(qname.getLocalName());
        } else {
            final String ns = qname.getNamespace().toString();
            final String prefix = "x";
            writer.writeNamespace(prefix, ns);
            writer.writeCharacters(prefix + ':' + qname.getLocalName());
        }

    } else {
        LOG.debug("Value of {}:{} is not a QName but {}", type.getQName().getNamespace(),
                type.getQName().getLocalName(), value.getClass());
        writer.writeCharacters(String.valueOf(value));
    }
}
 

import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition; //导入依赖的package包/类
@Test
public void testIdentityrefWithMultipleBaseIdentities() throws Exception {
    final SchemaContext schemaContext = StmtTestUtils.parseYangSource("/rfc7950/identityref-stmt/foo.yang");
    assertNotNull(schemaContext);

    final Module foo = schemaContext.findModule("foo", Revision.of("2017-01-11")).get();
    final Set<IdentitySchemaNode> identities = foo.getIdentities();
    assertEquals(3, identities.size());

    final LeafSchemaNode idrefLeaf = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
            "idref-leaf"));
    assertNotNull(idrefLeaf);

    final IdentityrefTypeDefinition idrefType = (IdentityrefTypeDefinition) idrefLeaf.getType();
    final Set<IdentitySchemaNode> referencedIdentities = idrefType.getIdentities();
    assertEquals(3, referencedIdentities.size());
    assertEquals(identities, referencedIdentities);
    assertEquals("id-a", idrefType.getIdentities().iterator().next().getQName().getLocalName());
}
 

import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition; //导入依赖的package包/类
@Test
public void testIdentityRef() {
    currentLeaf = (LeafSchemaNode) types
            .getDataChildByName(QName.create(types.getQNameModule(), "leaf-identityref"));
    assertNotNull(currentLeaf.getType());
    final IdentityrefTypeDefinition identityRefEff = ((IdentityRefSpecificationEffectiveStatement)
            ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
            .getTypeDefinition();

    assertEquals(Optional.empty(), identityRefEff.getDefaultValue());
    assertEquals("identityref", identityRefEff.getQName().getLocalName());
    assertEquals("identityref", identityRefEff.getPath().getLastComponent().getLocalName());
    assertNull(identityRefEff.getBaseType());
    assertNotNull(identityRefEff.getUnknownSchemaNodes());
    assertEquals(Status.CURRENT, identityRefEff.getStatus());
    assertEquals("test-identity", identityRefEff.getIdentities().iterator().next().getQName().getLocalName());
    assertFalse(identityRefEff.getDescription().isPresent());
    assertFalse(identityRefEff.getReference().isPresent());
    assertNotNull(identityRefEff.toString());

    // FIXME: the model is wrong, but we accept units in 'type' statement
    assertEquals(Optional.empty(), identityRefEff.getUnits());
}
 

import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition; //导入依赖的package包/类
@Test
public void identityrefTypeTest() {
    final IdentityrefTypeBuilder identityrefTypeBuilder1 = BaseTypes.identityrefTypeBuilder(SCHEMA_PATH);
    final IdentitySchemaNode identitySchemaNode = mock(IdentitySchemaNode.class);
    identityrefTypeBuilder1.addIdentity(identitySchemaNode);
    final IdentityrefTypeDefinition identityrefTypeDefinition1 = identityrefTypeBuilder1.build();
    final IdentityrefTypeBuilder identityrefTypeBuilder2 = BaseTypes.identityrefTypeBuilder(SCHEMA_PATH);
    identityrefTypeBuilder2.addIdentity(identitySchemaNode);
    final IdentityrefTypeDefinition identityrefTypeDefinition2 = identityrefTypeBuilder2.build();
    hashCodeEqualsToStringTest(identityrefTypeDefinition1, identityrefTypeDefinition2);

    final DerivedIdentityrefType derivedIdentityrefType1 = (DerivedIdentityrefType)DerivedTypes.derivedTypeBuilder(
            identityrefTypeDefinition1, SCHEMA_PATH).build();
    final DerivedIdentityrefType derivedIdentityrefType2 = (DerivedIdentityrefType)DerivedTypes.derivedTypeBuilder(
            identityrefTypeDefinition2, SCHEMA_PATH).build();
    hashCodeEqualsToStringTest(derivedIdentityrefType1, derivedIdentityrefType2);
    concreteBuilderTest(identityrefTypeDefinition1, derivedIdentityrefType1);

    restrictedBuilderTest(RestrictedTypes.newIdentityrefBuilder(derivedIdentityrefType1, SCHEMA_PATH),
            RestrictedTypes.newIdentityrefBuilder(derivedIdentityrefType2, SCHEMA_PATH));
}
 

import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition; //导入依赖的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.type.IdentityrefTypeDefinition; //导入依赖的package包/类
private Type returnTypeForIdentityref(IdentityrefTypeDefinition idref) {
    QName baseIdQName = idref.getIdentity();
    Module module = schemaContext.findModuleByNamespace(baseIdQName.getNamespace());
    IdentitySchemaNode identity = null;
    for (IdentitySchemaNode id : module.getIdentities()) {
        if (id.getQName().equals(baseIdQName)) {
            identity = id;
        }
    }
    if (identity == null) {
        throw new IllegalArgumentException("Target identity '" + baseIdQName + "' do not exists");
    }

    final String basePackageName = moduleNamespaceToPackageName(module);
    final String packageName = packageNameForGeneratedType(basePackageName, identity.getPath());
    final String genTypeName = parseToClassName(identity.getQName().getLocalName());

    Type baseType = Types.typeForClass(Class.class);
    Type paramType = Types.wildcardTypeFor(packageName, genTypeName);
    Type returnType = Types.parameterizedTypeFor(baseType, paramType);
    return returnType;
}
 

import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition; //导入依赖的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.type.IdentityrefTypeDefinition; //导入依赖的package包/类
private void emitTypeBodyNodes(final TypeDefinition<?> typeDef) {
    if (typeDef instanceof DecimalTypeDefinition) {
        emitDecimal64Specification((DecimalTypeDefinition) typeDef);
    } else if (typeDef instanceof RangeRestrictedTypeDefinition) {
        emitRangeRestrictedSpecification((RangeRestrictedTypeDefinition<?, ?>) typeDef);
    } else if (typeDef instanceof StringTypeDefinition) {
        emitStringRestrictions((StringTypeDefinition) typeDef);
    } else if (typeDef instanceof EnumTypeDefinition) {
        emitEnumSpecification((EnumTypeDefinition) typeDef);
    } else if (typeDef instanceof LeafrefTypeDefinition) {
        emitLeafrefSpecification((LeafrefTypeDefinition) typeDef);
    } else if (typeDef instanceof IdentityrefTypeDefinition) {
        emitIdentityrefSpecification((IdentityrefTypeDefinition) typeDef);
    } else if (typeDef instanceof InstanceIdentifierTypeDefinition) {
        emitInstanceIdentifierSpecification((InstanceIdentifierTypeDefinition) typeDef);
    } else if (typeDef instanceof BitsTypeDefinition) {
        emitBitsSpecification((BitsTypeDefinition) typeDef);
    } else if (typeDef instanceof UnionTypeDefinition) {
        emitUnionSpecification((UnionTypeDefinition) typeDef);
    } else if (typeDef instanceof BinaryTypeDefinition) {
        ((BinaryTypeDefinition) typeDef).getLengthConstraint().ifPresent(this::emitLength);
    } else if (typeDef instanceof BooleanTypeDefinition || typeDef instanceof EmptyTypeDefinition) {
        // NOOP
    } else {
        throw new IllegalArgumentException("Not supported type " + typeDef.getClass());
    }
}
 

import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition; //导入依赖的package包/类
/**
 * Write a value into a XML stream writer. This method assumes the start and end of element is
 * emitted by the caller.
 *
 * @param writer XML Stream writer
 * @param type data type. In case of leaf ref this should be the type of leaf being referenced
 * @param value data value
 * @param parent optional parameter of a module QName owning the leaf definition
 * @throws XMLStreamException if an encoding problem occurs
 */
private void writeValue(@Nonnull final XMLStreamWriter writer, @Nonnull final TypeDefinition<?> type,
        final Object value, final QNameModule parent) throws XMLStreamException {
    if (value == null) {
        LOG.debug("Value of {}:{} is null, not encoding it", type.getQName().getNamespace(),
                type.getQName().getLocalName());
        return;
    }

    if (type instanceof IdentityrefTypeDefinition) {
        write(writer, (IdentityrefTypeDefinition) type, value, parent);
    } else if (type instanceof InstanceIdentifierTypeDefinition) {
        write(writer, (InstanceIdentifierTypeDefinition) type, value);
    } else {
        final TypeDefinitionAwareCodec<Object, ?> codec = TypeDefinitionAwareCodec.from(type);
        String text;
        if (codec != null) {
            try {
                text = codec.serialize(value);
            } catch (ClassCastException e) {
                LOG.warn("Provided node value {} did not have type {} required by mapping. Using stream instead.",
                        value, type, e);
                text = String.valueOf(value);
            }
        } else {
            LOG.warn("Failed to find codec for {}, falling back to using stream", type);
            text = String.valueOf(value);
        }
        writer.writeCharacters(text);
    }
}
 

import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition; //导入依赖的package包/类
@Test
public void testIdentityref() {
    Module tested = TestUtils.findModule(context, "custom-types-test").get();
    Set<TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
    TypeDefinition<?> testedType = TestUtils.findTypedef(typedefs, "service-type-ref");
    IdentityrefTypeDefinition baseType = (IdentityrefTypeDefinition) testedType.getBaseType();
    QName identity = baseType.getIdentities().iterator().next().getQName();
    assertEquals(URI.create("urn:custom.types.demo"), identity.getNamespace());
    assertEquals(Revision.ofNullable("2012-04-16"), identity.getRevision());
    assertEquals("service-type", identity.getLocalName());

    LeafSchemaNode type = (LeafSchemaNode) tested.getDataChildByName(QName.create(tested.getQNameModule(), "type"));
    assertNotNull(type);
}
 

import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition; //导入依赖的package包/类
public static DerivedTypeBuilder<IdentityrefTypeDefinition> derivedIdentityrefBuilder(
        final IdentityrefTypeDefinition baseType, final SchemaPath path) {
    return new DerivedTypeBuilder<IdentityrefTypeDefinition>(baseType, path) {
        @Override
        public IdentityrefTypeDefinition build() {
            return new DerivedIdentityrefType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
                    getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
        }
    };
}
 

import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition; //导入依赖的package包/类
public static TypeBuilder<IdentityrefTypeDefinition> newIdentityrefBuilder(final IdentityrefTypeDefinition baseType,
        final SchemaPath path) {
    return new AbstractRestrictedTypeBuilder<IdentityrefTypeDefinition>(baseType, path) {
        @Override
        IdentityrefTypeDefinition buildType() {
            return new RestrictedIdentityrefType(getBaseType(), getPath(), getUnknownSchemaNodes());
        }
    };
}
 

import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition; //导入依赖的package包/类
private static ConcreteTypeBuilder<IdentityrefTypeDefinition> concreteIdentityrefBuilder(
        final IdentityrefTypeDefinition baseType, final SchemaPath path) {
    return new ConcreteTypeBuilder<IdentityrefTypeDefinition>(baseType, path) {
        @Nonnull
        @Override
        public IdentityrefTypeDefinition buildType() {
            return new DerivedIdentityrefType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
                    getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
        }
    };
}
 

import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition; //导入依赖的package包/类
/**
 * Return a {@link LeafInterner} for a particular schema. Interner instances must not be reused for leaves of
 * different types, otherwise they may produce unexpected results.
 *
 * @param schema The leaf node's schema
 * @return An interner instance
 */
@Nonnull public static <T extends LeafNode<?>> Interner<T> forSchema(@Nullable final LeafSchemaNode schema) {
    if (schema != null) {
        final TypeDefinition<?> type = schema.getType();
        if (type instanceof BooleanTypeDefinition || type instanceof EnumTypeDefinition
                || type instanceof IdentityrefTypeDefinition) {
            return LeafInterner::intern;
        }
    }

    return Objects::requireNonNull;
}
 

import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition; //导入依赖的package包/类
private static boolean isSimpleUnion(final UnionTypeDefinition union) {
    for (TypeDefinition<?> t : union.getTypes()) {
        if (t instanceof IdentityrefTypeDefinition || t instanceof LeafrefTypeDefinition
                || t instanceof UnionTypeDefinition && !isSimpleUnion((UnionTypeDefinition) t)) {
            LOG.debug("Type {} has non-simple subtype", t);
            return false;
        }
    }

    LOG.debug("Type {} is simple", union);
    return true;
}
 

import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition; //导入依赖的package包/类
/**
 * Return a {@link LeafsetEntryInterner} for a particular schema. Interner instances must be used only for leafset
 * entries for that particular schema, otherwise they may produce unexpected results.
 *
 * @param schema Schema of the parent leaf set
 * @return An interner instance, or null if the leafset's type should not be interned.
 */
@Nullable public static LeafsetEntryInterner forSchema(@Nullable final LeafListSchemaNode schema) {
    if (schema != null) {
        final TypeDefinition<?> type = schema.getType();
        if (type instanceof BooleanTypeDefinition || type instanceof EnumTypeDefinition
                || type instanceof IdentityrefTypeDefinition) {
            return INSTANCE;
        }
    }
    return null;
}
 

import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition; //导入依赖的package包/类
public Type generatedTypeForExtendedDefinitionType(final TypeDefinition<?> typeDefinition) {
    Type returnType = null;
    if (typeDefinition == null) {
        throw new IllegalArgumentException("Type Definition cannot be NULL!");
    }
    if (typeDefinition.getQName() == null) {
        throw new IllegalArgumentException(
                "Type Definition cannot have non specified QName (QName cannot be NULL!)");
    }
    if (typeDefinition.getQName() == null) {
        throw new IllegalArgumentException("Type Definitions Local Name cannot be NULL!");
    }

    final String typedefName = typeDefinition.getQName().getLocalName();
    if (typeDefinition instanceof ExtendedType) {
        final TypeDefinition<?> baseTypeDef = baseTypeDefForExtendedType(typeDefinition);

        if (!(baseTypeDef instanceof LeafrefTypeDefinition) && !(baseTypeDef instanceof IdentityrefTypeDefinition)) {
            final Module module = findParentModuleForTypeDefinition(schemaContext, typeDefinition);

            if (module != null) {
                final Map<String, Type> genTOs = genTypeDefsContextMap.get(module.getName());
                if (genTOs != null) {
                    returnType = genTOs.get(typedefName);
                }
            }
        }
    }
    return returnType;
}
 

import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition; //导入依赖的package包/类
public boolean isIdentityRef() {
    return this.typeDefinition instanceof IdentityrefTypeDefinition;
}
 

import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition; //导入依赖的package包/类
@Override
protected JSONCodec<?> identityRefCodec(final IdentityrefTypeDefinition type, final QNameModule module) {
    return new IdentityrefJSONCodec(getSchemaContext(), module);
}