X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-parser-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fparser%2Fstmt%2Frfc6020%2Feffective%2FEffectiveStatementBase.java;h=4fabc2e4f14f957d0a9038be6870d9a1d59ca05d;hb=c24d6e2f39acbb11e22b5676bb7481ed52bec461;hp=5b0c94cc98d9c97b31c63a787375d56950150bcc;hpb=d1f606bf178d536ab6681bc9dbf8205906bcf40d;p=yangtools.git diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/EffectiveStatementBase.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/EffectiveStatementBase.java index 5b0c94cc98..4fabc2e4f1 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/EffectiveStatementBase.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/EffectiveStatementBase.java @@ -1,4 +1,4 @@ -/** +/* * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. * * This program and the accompanying materials are made available under the @@ -7,177 +7,114 @@ */ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective; +import com.google.common.base.Optional; import com.google.common.base.Predicates; import com.google.common.collect.Collections2; -import com.google.common.collect.FluentIterable; import com.google.common.collect.ImmutableList; import com.google.common.collect.Iterables; -import com.google.common.collect.Lists; - +import java.util.ArrayList; import java.util.Collection; -import java.util.Collections; -import java.util.LinkedList; +import java.util.List; import java.util.Map; -import java.util.NoSuchElementException; - +import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping; import org.opendaylight.yangtools.yang.model.api.SchemaNode; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace; -import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; -import org.opendaylight.yangtools.yang.model.api.meta.StatementSource; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; -import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils; import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase; -abstract public class EffectiveStatementBase> - implements EffectiveStatement { - - private final StmtContext stmtCtx; - private final ImmutableList> substatements; - private final StatementSource statementSource; - private final StatementDefinition statementDefinition; - private D declaredInstance; - - private final A argument; - - public EffectiveStatementBase(StmtContext ctx) { - - this.stmtCtx = ctx; - this.statementDefinition = ctx.getPublicDefinition(); - this.argument = ctx.getStatementArgument(); - this.statementSource = ctx.getStatementSource(); - - Collection> declaredSubstatements = ctx - .declaredSubstatements(); - Collection> effectiveSubstatements = ctx - .effectiveSubstatements(); - - Collection> substatementsInit = new LinkedList<>(); - - for(StatementContextBase declaredSubstatement : declaredSubstatements) { - if(declaredSubstatement.getPublicDefinition() == Rfc6020Mapping.USES) { +public abstract class EffectiveStatementBase> implements EffectiveStatement { + private final List> substatements; + + /** + * Constructor. + * + * @param ctx + * context of statement. + */ + protected EffectiveStatementBase(final StmtContext ctx) { + final Collection> effectiveSubstatements = ctx.effectiveSubstatements(); + final Collection> substatementsInit = new ArrayList<>(); + + final Collection> supportedDeclaredSubStmts = Collections2.filter( + ctx.declaredSubstatements(), StmtContextUtils::areFeaturesSupported); + for (final StatementContextBase declaredSubstatement : supportedDeclaredSubStmts) { + if (declaredSubstatement.getPublicDefinition().equals(Rfc6020Mapping.USES)) { substatementsInit.add(declaredSubstatement); substatementsInit.addAll(declaredSubstatement.getEffectOfStatement()); - ((StatementContextBase)ctx).removeStatementsFromEffectiveSubstatements(declaredSubstatement + ((StatementContextBase) ctx).removeStatementsFromEffectiveSubstatements(declaredSubstatement .getEffectOfStatement()); } else { substatementsInit.add(declaredSubstatement); } } - substatementsInit.addAll(effectiveSubstatements); - this.substatements = FluentIterable.from(substatementsInit).filter(StmtContextUtils.IS_SUPPORTED_TO_BUILD_EFFECTIVE) - .transform(StmtContextUtils.buildEffective()).toList(); - } - - @Override - public StatementDefinition statementDefinition() { - return statementDefinition; - } - - @Override - public A argument() { - return argument; - } - - @Override - public StatementSource getStatementSource() { - return statementSource; + this.substatements = ImmutableList.copyOf(initSubstatements(substatementsInit)); } - @Override - public D getDeclared() { - if (declaredInstance == null) { - declaredInstance = stmtCtx.buildDeclared(); - } - return declaredInstance; + /** + * Create a set of substatements. This method is split out so it can be overridden in + * {@link ExtensionEffectiveStatementImpl} to leak a not-fully-initialized instance. + * + * @param substatementsInit proposed substatements + * @return Filtered substatements + */ + Collection> initSubstatements( + final Collection> substatementsInit) { + return Collections2.transform(Collections2.filter(substatementsInit, + StmtContext::isSupportedToBuildEffective), StatementContextBase::buildEffective); } @Override - public > V get( - Class namespace, K identifier) { - return stmtCtx.getFromNamespace(namespace, identifier); + public final > V get(@Nonnull final Class namespace, @Nonnull final K identifier) { + throw new UnsupportedOperationException("Not implemented yet."); } @Override - public > Map getAll( - Class namespace) { - return (Map) stmtCtx.getAllFromNamespace(namespace); + public final > Map getAll(@Nonnull final Class namespace) { + throw new UnsupportedOperationException("Not implemented yet."); } + @Nonnull @Override - public Collection> effectiveSubstatements() { + public final Collection> effectiveSubstatements() { return substatements; } - public StmtContext getStatementContext() { - return stmtCtx; + protected final > S firstEffective(final Class type) { + final Optional> possible = Iterables.tryFind(substatements, + Predicates.instanceOf(type)); + return possible.isPresent() ? type.cast(possible.get()) : null; } - protected final > S firstEffective( - Class type) { - S result = null; - try { - result = type.cast(Iterables.find(substatements, - Predicates.instanceOf(type))); - } catch (NoSuchElementException e) { - result = null; - } - return result; - } - - protected final S firstSchemaNode(Class type) { - S result = null; - try { - result = type.cast(Iterables.find(substatements, - Predicates.instanceOf(type))); - } catch (NoSuchElementException e) { - result = null; - } - return result; + protected final S firstSchemaNode(final Class type) { + final Optional> possible = Iterables.tryFind(substatements, + Predicates.instanceOf(type)); + return possible.isPresent() ? type.cast(possible.get()) : null; } @SuppressWarnings("unchecked") - protected final Collection allSubstatementsOfType( - Class type) { - Collection result = null; - - try { - result = Collection.class.cast(Collections2.filter(substatements, - Predicates.instanceOf(type))); - } catch (NoSuchElementException e) { - result = Collections.emptyList(); - } - return result; + protected final Collection allSubstatementsOfType(final Class type) { + return Collection.class.cast(Collections2.filter(substatements, Predicates.instanceOf(type))); } - protected final T firstSubstatementOfType(Class type) { - T result = null; - try { - result = type.cast(Iterables.find(substatements, - Predicates.instanceOf(type))); - } catch (NoSuchElementException e) { - result = null; - } - return result; + protected final T firstSubstatementOfType(final Class type) { + final Optional> possible = Iterables.tryFind(substatements, + Predicates.instanceOf(type)); + return possible.isPresent() ? type.cast(possible.get()) : null; } - protected final R firstSubstatementOfType(Class type, - Class returnType) { - R result = null; - try { - result = returnType.cast(Iterables.find( - substatements, - Predicates.and(Predicates.instanceOf(type), - Predicates.instanceOf(returnType)))); - } catch (NoSuchElementException e) { - result = null; - } - return result; + protected final R firstSubstatementOfType(final Class type, final Class returnType) { + final Optional> possible = Iterables.tryFind(substatements, + Predicates.and(Predicates.instanceOf(type), Predicates.instanceOf(returnType))); + return possible.isPresent() ? returnType.cast(possible.get()) : null; } + protected final EffectiveStatement firstEffectiveSubstatementOfType(final Class type) { + return Iterables.tryFind(substatements, Predicates.instanceOf(type)).orNull(); + } }