Java EffectiveStatement类代码示例

import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; //导入依赖的package包/类
@Override
public void onStatementDefinitionDeclared(
        final Mutable<QName, ExtensionStatement, EffectiveStatement<QName, ExtensionStatement>> stmt) {
    super.onStatementDefinitionDeclared(stmt);

    QName stmtName = stmt.getStatementArgument();
    if (OpenConfigStatements.OPENCONFIG_VERSION.getStatementName().isEqualWithoutRevision(stmtName)) {
        stmtName = stmtName.withoutRevision();
    }

    stmt.addContext(ExtensionNamespace.class, stmtName, stmt);

    final StmtContext<QName, ?, ?> argument = StmtContextUtils.findFirstDeclaredSubstatement(stmt,
        ArgumentStatement.class);
    final StmtContext<Boolean, ?, ?> yinElement = StmtContextUtils.findFirstDeclaredSubstatement(stmt,
        YinElementStatement.class);

    stmt.addToNs(StatementDefinitionNamespace.class, stmt.getStatementArgument(),
        new ModelDefinedStatementSupport(new ModelDefinedStatementDefinition(stmt.getStatementArgument(),
            argument != null ? argument.getStatementArgument() : null,
                    yinElement != null ? yinElement.getStatementArgument() : false)));
}
 

import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; //导入依赖的package包/类
BitEffectiveStatementImpl(final StmtContext<QName, BitStatement, ?> ctx) {
    super(ctx);

    qname = ctx.getStatementArgument();
    schemaPath = ctx.getSchemaPath().get();

    final List<UnknownSchemaNode> unknownSchemaNodesInit = new ArrayList<>();
    Long declaredPositionInit = null;
    for (final EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements()) {
        if (effectiveStatement instanceof PositionEffectiveStatement) {
            declaredPositionInit = ((PositionEffectiveStatement) effectiveStatement).argument();
        }
        if (effectiveStatement instanceof UnknownSchemaNode) {
            unknownSchemaNodesInit.add((UnknownSchemaNode) effectiveStatement);
        }
    }

    declaredPosition = declaredPositionInit;
    unknownSchemaNodes = ImmutableList.copyOf(unknownSchemaNodesInit);
}
 

import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; //导入依赖的package包/类
@Override
public final void onLinkageDeclared(
        final Mutable<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> stmt) {
    final SourceIdentifier submoduleIdentifier = RevisionSourceIdentifier.create(stmt.getStatementArgument(),
        StmtContextUtils.getLatestRevision(stmt.declaredSubstatements()));

    final StmtContext<?, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>>
        possibleDuplicateSubmodule = stmt.getFromNamespace(SubmoduleNamespace.class, submoduleIdentifier);
    if (possibleDuplicateSubmodule != null && possibleDuplicateSubmodule != stmt) {
        throw new SourceException(stmt.getStatementSourceReference(), "Submodule name collision: %s. At %s",
                stmt.getStatementArgument(), possibleDuplicateSubmodule.getStatementSourceReference());
    }

    stmt.addContext(SubmoduleNamespace.class, submoduleIdentifier, stmt);

    final String belongsToModuleName = firstAttributeOf(stmt.declaredSubstatements(), BelongsToStatement.class);
    final StmtContext<?, ?, ?> prefixSubStmtCtx = findFirstDeclaredSubstatement(stmt, 0,
            BelongsToStatement.class, PrefixStatement.class);
    SourceException.throwIfNull(prefixSubStmtCtx, stmt.getStatementSourceReference(),
            "Prefix of belongsTo statement is missing in submodule [%s]", stmt.getStatementArgument());

    final String prefix = (String) prefixSubStmtCtx.getStatementArgument();

    stmt.addToNs(BelongsToPrefixToModuleName.class, prefix, belongsToModuleName);
}
 

import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; //导入依赖的package包/类
@SuppressWarnings("checkstyle:illegalCatch")
private EffectiveSchemaContext transformEffective() throws ReactorException {
    checkState(finishedPhase == ModelProcessingPhase.EFFECTIVE_MODEL);
    final List<DeclaredStatement<?>> rootStatements = new ArrayList<>(sources.size());
    final List<EffectiveStatement<?, ?>> rootEffectiveStatements = new ArrayList<>(sources.size());

    try {
        for (final SourceSpecificContext source : sources) {
            final RootStatementContext<?, ?, ?> root = source.getRoot();
            try {
                rootStatements.add(root.buildDeclared());
                rootEffectiveStatements.add(root.buildEffective());
            } catch (final RuntimeException ex) {
                throw propagateException(source, ex);
            }
        }
    } finally {
        RecursiveObjectLeaker.cleanup();
    }

    sealMutableStatements();
    return EffectiveSchemaContext.create(rootStatements, rootEffectiveStatements);
}
 

import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; //导入依赖的package包/类
EnumEffectiveStatementImpl(final StmtContext<String, EnumStatement, ?> ctx) {
    super(ctx);

    name = ctx.rawStatementArgument();

    final List<UnknownSchemaNode> unknownSchemaNodesInit = new ArrayList<>();
    Integer declaredValueInit = null;
    for (final EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements()) {
        if (effectiveStatement instanceof ValueEffectiveStatement) {
            declaredValueInit = ((ValueEffectiveStatement) effectiveStatement).argument();
        }
        if (effectiveStatement instanceof UnknownSchemaNode) {
            unknownSchemaNodesInit.add((UnknownSchemaNode) effectiveStatement);
        }
    }

    declaredValue = declaredValueInit;
    unknownSchemaNodes = ImmutableList.copyOf(unknownSchemaNodesInit);
}
 

import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; //导入依赖的package包/类
DeviationEffectiveStatementImpl(final StmtContext<SchemaNodeIdentifier, DeviationStatement, ?> ctx) {
    super(ctx);
    this.targetPath = ctx.getStatementArgument().asSchemaPath();

    this.deviateDefinitions = ImmutableList.copyOf(allSubstatementsOfType(DeviateDefinition.class));

    description = findFirstEffectiveSubstatementArgument(DescriptionEffectiveStatement.class).orElse(null);
    reference = findFirstEffectiveSubstatementArgument(ReferenceEffectiveStatement.class).orElse(null);

    List<UnknownSchemaNode> unknownSchemaNodesInit = new ArrayList<>();
    for (final EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements()) {
        if (effectiveStatement instanceof UnknownSchemaNode) {
            unknownSchemaNodesInit.add((UnknownSchemaNode) effectiveStatement);
        }
    }
    unknownSchemaNodes = ImmutableList.copyOf(unknownSchemaNodesInit);
}
 

import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; //导入依赖的package包/类
@Override
public final void onPreLinkageDeclared(final Mutable<String, ModuleStatement,
        EffectiveStatement<String, ModuleStatement>> stmt) {
    final String moduleName = stmt.getStatementArgument();

    final URI moduleNs = firstAttributeOf(stmt.declaredSubstatements(), NamespaceStatement.class);
    SourceException.throwIfNull(moduleNs, stmt.getStatementSourceReference(),
        "Namespace of the module [%s] is missing", stmt.getStatementArgument());
    stmt.addToNs(ModuleNameToNamespace.class, moduleName, moduleNs);

    final String modulePrefix = firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class);
    SourceException.throwIfNull(modulePrefix, stmt.getStatementSourceReference(),
        "Prefix of the module [%s] is missing", stmt.getStatementArgument());
    stmt.addToNs(ImpPrefixToNamespace.class, modulePrefix, moduleNs);

    stmt.addContext(PreLinkageModuleNamespace.class, moduleName, stmt);

    final Optional<Revision> revisionDate = StmtContextUtils.getLatestRevision(stmt.declaredSubstatements());
    final QNameModule qNameModule = QNameModule.create(moduleNs, revisionDate.orElse(null)).intern();

    stmt.addToNs(ModuleCtxToModuleQName.class, stmt, qNameModule);
    stmt.setRootIdentifier(RevisionSourceIdentifier.create(stmt.getStatementArgument(), revisionDate));
}
 

import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; //导入依赖的package包/类
InstanceIdentifierTypeEffectiveStatementImpl(
        final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
        final InstanceIdentifierTypeDefinition baseType) {
    super(ctx);

    final InstanceIdentifierTypeBuilder builder =
            RestrictedTypes.newInstanceIdentifierBuilder(baseType,
                AbstractTypeStatementSupport.typeEffectiveSchemaPath(ctx));

    for (EffectiveStatement<?, ?> stmt : effectiveSubstatements()) {
        if (stmt instanceof RequireInstanceEffectiveStatement) {
            builder.setRequireInstance(((RequireInstanceEffectiveStatement)stmt).argument());
        }
        if (stmt instanceof UnknownSchemaNode) {
            builder.addUnknownSchemaNode((UnknownSchemaNode)stmt);
        }
    }

    typeDefinition = builder.build();
}
 

import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; //导入依赖的package包/类
private static boolean isAnyDefaultValueMarkedWithIfFeature(final TypeEffectiveStatement<?> typeStmt,
        final Set<String> defaultValues) {
    final Iterator<? extends EffectiveStatement<?, ?>> iter = typeStmt.effectiveSubstatements().iterator();
    while (iter.hasNext() && !defaultValues.isEmpty()) {
        final EffectiveStatement<?, ?> effectiveSubstatement = iter.next();
        if (YangStmtMapping.BIT.equals(effectiveSubstatement.statementDefinition())) {
            final QName bitQName = (QName) effectiveSubstatement.argument();
            if (defaultValues.remove(bitQName.getLocalName()) && containsIfFeature(effectiveSubstatement)) {
                return true;
            }
        } else if (YangStmtMapping.ENUM.equals(effectiveSubstatement.statementDefinition())
                && defaultValues.remove(effectiveSubstatement.argument())
                && containsIfFeature(effectiveSubstatement)) {
            return true;
        } else if (effectiveSubstatement instanceof TypeEffectiveStatement && isAnyDefaultValueMarkedWithIfFeature(
                (TypeEffectiveStatement<?>) effectiveSubstatement, defaultValues)) {
            return true;
        }
    }

    return false;
}
 

import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; //导入依赖的package包/类
/**
 * Create a new substatement at the specified offset.
 *
 * @param offset Substatement offset
 * @param def definition context
 * @param ref source reference
 * @param argument statement argument
 * @return A new substatement
 */
@SuppressWarnings("checkstyle:methodTypeParameterName")
public final <CA, CD extends DeclaredStatement<CA>, CE extends EffectiveStatement<CA, CD>>
        StatementContextBase<CA, CD, CE> createSubstatement(final int offset,
                final StatementDefinitionContext<CA, CD, CE> def, final StatementSourceReference ref,
                final String argument) {
    final ModelProcessingPhase inProgressPhase = getRoot().getSourceContext().getInProgressPhase();
    Preconditions.checkState(inProgressPhase != ModelProcessingPhase.EFFECTIVE_MODEL,
            "Declared statement cannot be added in effective phase at: %s", getStatementSourceReference());

    final Optional<StatementSupport<?, ?, ?>> implicitParent = definition.getImplicitParentFor(def.getPublicView());
    if (implicitParent.isPresent()) {
        return createImplicitParent(offset, implicitParent.get(), ref, argument).createSubstatement(offset, def,
                ref, argument);
    }

    final StatementContextBase<CA, CD, CE> ret = new SubstatementContext<>(this, def, ref, argument);
    substatements = substatements.put(offset, ret);
    def.onStatementAdded(ret);
    return ret;
}
 

import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; //导入依赖的package包/类
@Override
public AnyxmlEffectiveStatement createEffective(
        final StmtContext<QName, AnyxmlStatement, AnyxmlEffectiveStatement> ctx) {
    final AnyxmlEffectiveStatement delegateStatement = delegate().createEffective(ctx);
    final Map<StatementDefinition, Mutable<SchemaNodeIdentifier, AnyxmlSchemaLocationStatement,
        EffectiveStatement<SchemaNodeIdentifier, AnyxmlSchemaLocationStatement>>> schemaLocations =
            ctx.getAllFromCurrentStmtCtxNamespace(AnyxmlSchemaLocationNamespace.class);
    if (schemaLocations != null && !schemaLocations.isEmpty()) {
        final SchemaNodeIdentifier anyXmlSchemaNodeIdentifier = schemaLocations.values().iterator().next()
                .getStatementArgument();
        final Optional<ContainerSchemaNode> anyXmlSchema = getAnyXmlSchema(ctx, anyXmlSchemaNodeIdentifier);
        if (anyXmlSchema.isPresent()) {
            return new YangModeledAnyxmlEffectiveStatementImpl(delegateStatement, anyXmlSchema.get());
        }
    }

    return delegateStatement;
}
 

import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; //导入依赖的package包/类
@Override
public void onStatementDefinitionDeclared(
        final Mutable<QName, BaseStatement, EffectiveStatement<QName, BaseStatement>> baseStmtCtx) {
    final Mutable<?, ?, ?> baseParentCtx = baseStmtCtx.getParentContext();
    if (StmtContextUtils.producesDeclared(baseParentCtx, IdentityStatement.class)) {

        final QName baseIdentityQName = baseStmtCtx.getStatementArgument();
        final ModelActionBuilder baseIdentityAction = baseStmtCtx.newInferenceAction(
            ModelProcessingPhase.STATEMENT_DEFINITION);
        final Prerequisite<StmtContext<?, ?, ?>> requiresPrereq = baseIdentityAction.requiresCtx(baseStmtCtx,
            IdentityNamespace.class, baseIdentityQName, ModelProcessingPhase.STATEMENT_DEFINITION);
        final Prerequisite<StmtContext.Mutable<?, ?, ?>> mutatesPrereq = baseIdentityAction.mutatesCtx(
            baseParentCtx, ModelProcessingPhase.STATEMENT_DEFINITION);

        baseIdentityAction.apply(new InferenceAction() {
            @Override
            public void apply(final InferenceContext ctx) {
                List<StmtContext<?, ?, ?>> derivedIdentities = baseStmtCtx.getFromNamespace(
                    DerivedIdentitiesNamespace.class, baseStmtCtx.getStatementArgument());
                if (derivedIdentities == null) {
                    derivedIdentities = new ArrayList<>(1);
                    baseStmtCtx.addToNs(DerivedIdentitiesNamespace.class, baseIdentityQName, derivedIdentities);
                }
                derivedIdentities.add(baseParentCtx);
            }

            @Override
            public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
                throw new InferenceException(baseStmtCtx.getStatementSourceReference(),
                    "Unable to resolve identity %s and base identity %s",
                    baseParentCtx.getStatementArgument(), baseStmtCtx.getStatementArgument());
            }
        });
    }
}
 

import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; //导入依赖的package包/类
@Override
public final void onFullDefinitionDeclared(
        final Mutable<String, TypeStatement, EffectiveStatement<String, TypeStatement>> stmt) {
    super.onFullDefinitionDeclared(stmt);

    // if it is yang built-in type, no prerequisite is needed, so simply return
    if (BUILT_IN_TYPES.containsKey(stmt.getStatementArgument())) {
        return;
    }

    final QName typeQName = StmtContextUtils.qnameFromArgument(stmt, stmt.getStatementArgument());
    final ModelActionBuilder typeAction = stmt.newInferenceAction(ModelProcessingPhase.EFFECTIVE_MODEL);
    final Prerequisite<StmtContext<?, ?, ?>> typePrereq = typeAction.requiresCtx(stmt, TypeNamespace.class,
            typeQName, ModelProcessingPhase.EFFECTIVE_MODEL);
    typeAction.mutatesEffectiveCtx(stmt.getParentContext());

    /*
     * If the type does not exist, throw new InferenceException.
     * Otherwise perform no operation.
     */
    typeAction.apply(new InferenceAction() {
        @Override
        public void apply(final InferenceContext ctx) {
            // Intentional NOOP
        }

        @Override
        public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
            InferenceException.throwIf(failed.contains(typePrereq), stmt.getStatementSourceReference(),
                "Type [%s] was not found.", typeQName);
        }
    });
}
 

import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private static Mutable<?, ?, EffectiveStatement<?, ?>> tryToFindUnknownStatement(final String localName,
        final Mutable<?, ?, EffectiveStatement<?, ?>> current) {
    final Collection<? extends StmtContext<?, ?, ?>> unknownSubstatements = StmtContextUtils.findAllSubstatements(
        current, UnknownStatement.class);
    for (final StmtContext<?, ?, ?> unknownSubstatement : unknownSubstatements) {
        if (localName.equals(unknownSubstatement.rawStatementArgument())) {
            return (Mutable<?, ?, EffectiveStatement<?, ?>>) unknownSubstatement;
        }
    }
    return null;
}
 

import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; //导入依赖的package包/类
public static void resolveUsesNode(
        final Mutable<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> usesNode,
        final StmtContext<?, ?, ?> targetNodeStmtCtx) {
    for (final Mutable<?, ?, ?> subStmtCtx : usesNode.mutableDeclaredSubstatements()) {
        if (StmtContextUtils.producesDeclared(subStmtCtx, RefineStatement.class)
                && areFeaturesSupported(subStmtCtx)) {
            performRefine(subStmtCtx, targetNodeStmtCtx);
        }
    }
}