import org.opendaylight.yangtools.concepts.Builder; //导入依赖的package包/类
protected <S1 extends INeutronObject<S1>, M extends IdAttributes, B extends Builder<M>>
    void toMdIds(INeutronObject<S1> neutronObject, B builder) {
    try {
        if (neutronObject.getID() != null) {
            setUuid.invoke(builder, toUuid(neutronObject.getID()));
        } else {
            LOG.warn("Attempting to write neutron object {} without UUID", builderClass.getSimpleName());
        }
        if (neutronObject.getTenantID() != null && !neutronObject.getTenantID().isEmpty()) {
            setTenantId.invoke(builder, toUuid(neutronObject.getTenantID()));
        }
        if (neutronObject.getProjectID() != null) {
            setProjectId.invoke(builder, neutronObject.getTenantID());
        }
        if (neutronObject.getRevisionNumber() != null) {
            setRevisionNumber.invoke(builder, neutronObject.getRevisionNumber());
        }
    } catch (IllegalAccessException | InvocationTargetException e) {
        throw new IllegalArgumentException(e);
    }
}
 

import org.opendaylight.yangtools.concepts.Builder; //导入依赖的package包/类
@Before
public void setUp() {
    this.ctx = ServiceLoaderBGPExtensionProviderContext.getSingletonInstance();
    final MessageRegistry msgRegistry = this.ctx.getMessageRegistry();
    this.parser = new AbstractBmpPerPeerMessageParser<Builder<?>>(msgRegistry) {
        @Override
        public Notification parseMessageBody(final ByteBuf bytes) {
            return null;
        }

        @Override
        public int getBmpMessageType() {
            return 0;
        }
    };
}
 

import org.opendaylight.yangtools.concepts.Builder; //导入依赖的package包/类
private PathArgument computeIdentifierWithPredicate(final QName name) {
    product.add(new NodeIdentifier(name));

    ImmutableMap.Builder<QName, Object> keyValues = ImmutableMap.builder();
    while (!allCharactersConsumed() && PRECONDITION_START == currentChar()) {
        skipCurrentChar();
        skipWhitespaces();
        final QName key = nextQName();

        skipWhitespaces();
        checkCurrentAndSkip(EQUALS, "Precondition must contain '='");
        skipWhitespaces();
        final Object keyValue = nextCurrentFunctionPathValue();
        skipWhitespaces();
        checkCurrentAndSkip(PRECONDITION_END, "Precondition must ends with ']'");

        keyValues.put(key, keyValue);
    }
    return new NodeIdentifierWithPredicates(name, keyValues.build());
}
 

import org.opendaylight.yangtools.concepts.Builder; //导入依赖的package包/类
protected AbstractTranscriberInterface(Class<? extends Builder<T>> builderClass, DataBroker db) {
    this.db = Preconditions.checkNotNull(db);
    this.builderClass = builderClass;

    ParameterizedType parameterizedType = (ParameterizedType) getClass().getGenericSuperclass();
    Type[] types = parameterizedType.getActualTypeArguments();
    @SuppressWarnings("unchecked")
    Class<T> localMdListClass = (Class<T>) types[MD_LIST_CLASS_TYPE_INDEX];
    mdListClass = localMdListClass;
    @SuppressWarnings("unchecked")
    Class<U> localMdContainerClass = (Class<U>) types[MD_CONTAINER_CLASS_TYPE_INDEX];
    mdContainerClass = localMdContainerClass;
    mdParentClass = getMdParentClass(types);
    @SuppressWarnings("unchecked")
    Class<S> neutronObjectClass = (Class<S>) types[NEUTRON_OBJECT_TYPE_INDEX];
    try {
        setUuid = builderClass.getDeclaredMethod("setUuid", Uuid.class);
        setTenantId = builderClass.getDeclaredMethod("setTenantId", Uuid.class);
        setProjectId = builderClass.getDeclaredMethod("setProjectId", String.class);
        setRevisionNumber = builderClass.getDeclaredMethod("setRevisionNumber", Long.class);
        if (INeutronBaseAttributes.class.isAssignableFrom(neutronObjectClass)) {
            setName = builderClass.getDeclaredMethod("setName", String.class);
        } else {
            setName = null;
        }

        if (INeutronAdminAttributes.class.isAssignableFrom(neutronObjectClass)) {
            setAdminStateUp = builderClass.getDeclaredMethod("setAdminStateUp", Boolean.class);
            setStatus = builderClass.getDeclaredMethod("setStatus", String.class);
        } else {
            setAdminStateUp = null;
            setStatus = null;
        }
    } catch (NoSuchMethodException e) {
        throw new IllegalArgumentException(e);
    }
}
 

import org.opendaylight.yangtools.concepts.Builder; //导入依赖的package包/类
protected <S1 extends INeutronBaseAttributes<S1>, M extends BaseAttributes, B extends Builder<M>>
    void toMdBaseAttributes(S1 neutronObject, B builder) {
    toMdIds(neutronObject, builder);
    try {
        if (neutronObject.getName() != null) {
            setName.invoke(builder, neutronObject.getName());
        }
    } catch (IllegalAccessException | InvocationTargetException e) {
        throw new IllegalArgumentException(e);
    }
}
 

import org.opendaylight.yangtools.concepts.Builder; //导入依赖的package包/类
protected <S1 extends INeutronAdminAttributes<S1>, M extends BaseAttributes & AdminAttributes, B extends Builder<M>>
    void toMdAdminAttributes(S1 neutronObject, B builder) {
    toMdBaseAttributes(neutronObject, builder);
    try {
        if (neutronObject.getAdminStateUp() != null) {
            setAdminStateUp.invoke(builder, neutronObject.getAdminStateUp());
        }
        if (neutronObject.getStatus() != null) {
            setStatus.invoke(builder, neutronObject.getStatus());
        }
    } catch (IllegalAccessException | InvocationTargetException e) {
        throw new IllegalArgumentException(e);
    }
}
 

import org.opendaylight.yangtools.concepts.Builder; //导入依赖的package包/类
protected T toMd(String uuid) {
    Builder<T> builder;
    try {
        builder = builderClass.newInstance();
        setUuid.invoke(builder, toUuid(uuid));
    } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
        // should not happen.
        throw new IllegalArgumentException(e);
    }
    return builder.build();
}
 

import org.opendaylight.yangtools.concepts.Builder; //导入依赖的package包/类
/**
 * Creates a new CustomCrossSourceStatementReactorBuilder object initialized by specific version bundle. Statement
 * parser will support all versions defined in given version bundle.
 *
 * @param supportedVersions
 *            bundle of supported verions
 */
CustomCrossSourceStatementReactorBuilder(final Set<YangVersion> supportedVersions) {
    reactorSupportBundles = ImmutableMap.<ModelProcessingPhase, StatementSupportBundle.Builder>builder()
            .put(ModelProcessingPhase.INIT, StatementSupportBundle.builder(supportedVersions))
            .put(ModelProcessingPhase.SOURCE_PRE_LINKAGE, StatementSupportBundle.builder(supportedVersions))
            .put(ModelProcessingPhase.SOURCE_LINKAGE, StatementSupportBundle.builder(supportedVersions))
            .put(ModelProcessingPhase.STATEMENT_DEFINITION, StatementSupportBundle.builder(supportedVersions))
            .put(ModelProcessingPhase.FULL_DECLARATION, StatementSupportBundle.builder(supportedVersions))
            .put(ModelProcessingPhase.EFFECTIVE_MODEL, StatementSupportBundle.builder(supportedVersions)).build();
}
 

import org.opendaylight.yangtools.concepts.Builder; //导入依赖的package包/类
public CustomCrossSourceStatementReactorBuilder addAllNamespaceSupports(final ModelProcessingPhase phase,
        final Collection<NamespaceBehaviour<?, ?, ?>> namespaceSupports) {
    final StatementSupportBundle.Builder stmtBundleBuilder = reactorSupportBundles.get(phase);
    for (final NamespaceBehaviour<?, ?, ?> namespaceSupport : namespaceSupports) {
        stmtBundleBuilder.addSupport(namespaceSupport);
    }
    return this;
}
 

import org.opendaylight.yangtools.concepts.Builder; //导入依赖的package包/类
public CustomCrossSourceStatementReactorBuilder addAllCommonStatementSupports(final ModelProcessingPhase phase,
        final Collection<StatementSupport<?, ?, ?>> statementSupports) {
    final StatementSupportBundle.Builder stmtBundleBuilder = reactorSupportBundles.get(phase);
    for (final StatementSupport<?, ?, ?> statementSupport : statementSupports) {
        stmtBundleBuilder.addSupport(statementSupport);
    }
    return this;
}
 

import org.opendaylight.yangtools.concepts.Builder; //导入依赖的package包/类
public CustomCrossSourceStatementReactorBuilder addAllVersionSpecificSupports(final ModelProcessingPhase phase,
        final Table<YangVersion, QName, StatementSupport<?, ?, ?>> versionSpecificSupports) {
    final StatementSupportBundle.Builder stmtBundleBuilder = reactorSupportBundles.get(phase);
    for (final Cell<YangVersion, QName, StatementSupport<?, ?, ?>> cell : versionSpecificSupports.cellSet()) {
        stmtBundleBuilder.addVersionSpecificSupport(cell.getRowKey(), cell.getValue());
    }
    return this;
}
 

import org.opendaylight.yangtools.concepts.Builder; //导入依赖的package包/类
@Override
public @NonNull CrossSourceStatementReactor build() {
    final StatementSupportBundle initBundle = reactorSupportBundles.get(ModelProcessingPhase.INIT).build();
    final StatementSupportBundle preLinkageBundle = reactorSupportBundles
            .get(ModelProcessingPhase.SOURCE_PRE_LINKAGE).setParent(initBundle).build();
    final StatementSupportBundle linkageBundle = reactorSupportBundles.get(ModelProcessingPhase.SOURCE_LINKAGE)
            .setParent(preLinkageBundle).build();
    final StatementSupportBundle stmtDefBundle = reactorSupportBundles
            .get(ModelProcessingPhase.STATEMENT_DEFINITION).setParent(linkageBundle).build();
    final StatementSupportBundle fullDeclBundle = reactorSupportBundles.get(ModelProcessingPhase.FULL_DECLARATION)
            .setParent(stmtDefBundle).build();
    final StatementSupportBundle effectiveBundle = reactorSupportBundles.get(ModelProcessingPhase.EFFECTIVE_MODEL)
            .setParent(fullDeclBundle).build();

    final CrossSourceStatementReactor.Builder reactorBuilder = CrossSourceStatementReactor.builder()
            .setBundle(ModelProcessingPhase.INIT, initBundle)
            .setBundle(ModelProcessingPhase.SOURCE_PRE_LINKAGE, preLinkageBundle)
            .setBundle(ModelProcessingPhase.SOURCE_LINKAGE, linkageBundle)
            .setBundle(ModelProcessingPhase.STATEMENT_DEFINITION, stmtDefBundle)
            .setBundle(ModelProcessingPhase.FULL_DECLARATION, fullDeclBundle)
            .setBundle(ModelProcessingPhase.EFFECTIVE_MODEL, effectiveBundle);

    for (final Entry<ValidationBundleType, Collection<StatementDefinition>> entry : reactorValidationBundles
            .entrySet()) {
        reactorBuilder.setValidationBundle(entry.getKey(), entry.getValue());
    }

    return reactorBuilder.build();
}
 

import org.opendaylight.yangtools.concepts.Builder; //导入依赖的package包/类
private void addError(final RpcError error) {

        if (errors == null) {
            errors = new ImmutableList.Builder<>();
        }

        errors.add(error);
    }
 

import org.opendaylight.yangtools.concepts.Builder; //导入依赖的package包/类
/**
 * Creates path argument with predicates and sets offset
 * to end of path argument.
 *
 * {@code
 *     predicate = "[" *WSP (predicate-expr / pos) *WSP "]"
 *     predicate-expr = (node-identifier / ".") *WSP "=" *WSP
 *          ((DQUOTE string DQUOTE) /
 *           (SQUOTE string SQUOTE))
 *     pos = non-negative-integer-value
 * }
 *
 * @param name QName of node, for which predicates are computed.
 * @return PathArgument representing node selection with predictes
 */
private PathArgument computeIdentifierWithPredicate(final QName name) {
    DataSchemaContextNode<?> currentNode = nextContextNode(name);
    checkValid(currentNode.isKeyedEntry(), "Entry %s does not allow specifying predicates.", name);

    ImmutableMap.Builder<QName,Object> keyValues = ImmutableMap.builder();
    while (!allCharactersConsumed() && PRECONDITION_START == currentChar()) {
        skipCurrentChar();
        skipWhitespaces();
        final QName key;
        if (DOT == currentChar()) {
            key = null;
            skipCurrentChar();
        } else {
            key = nextQName();
        }
        skipWhitespaces();
        checkCurrentAndSkip(EQUALS, "Precondition must contain '='");
        skipWhitespaces();
        final String keyValue = nextQuotedValue();
        skipWhitespaces();
        checkCurrentAndSkip(PRECONDITION_END, "Precondition must ends with ']'");

        // Break-out from method for leaf-list case
        if (key == null && currentNode.isLeaf()) {
            checkValid(offset == data.length(), "Leaf argument must be last argument of instance identifier.");
            return new NodeWithValue<>(name, keyValue);
        }
        final DataSchemaContextNode<?> keyNode = currentNode.getChild(key);
        checkValid(keyNode != null, "%s is not correct schema node identifier.", key);
        final Object value = codec.deserializeKeyValue(keyNode.getDataSchemaNode(), keyValue);
        keyValues.put(key, value);
    }
    return new NodeIdentifierWithPredicates(name, keyValues.build());
}
 

import org.opendaylight.yangtools.concepts.Builder; //导入依赖的package包/类
public final T build(final String testName, final String key, final String value) {
    final Builder<T> builder = builder();
    this.counter++;
    if (key != null) {
        setKey(builder, String.format(FORMAT_STR, testName, key, this.counter));
    }
    if (value != null) {
        setValue(builder, String.format(FORMAT_STR, testName, value, this.counter));
    }
    return builder.build();
}
 

import org.opendaylight.yangtools.concepts.Builder; //导入依赖的package包/类
protected AbstractNeutronInterface(Class<? extends Builder<T>> builderClass, DataBroker db) {
    super(builderClass, db);
}
 

import org.opendaylight.yangtools.concepts.Builder; //导入依赖的package包/类
private static void restrictedBuilderTest(final Builder<?> typeBuilder1, final Builder<?> typeBuilder2) {
    final TypeDefinition<?> typeDefinition1 = ((AbstractRestrictedTypeBuilder<?>) typeBuilder1).buildType();
    final TypeDefinition<?> typeDefinition2 = ((AbstractRestrictedTypeBuilder<?>) typeBuilder2).buildType();
    hashCodeEqualsToStringTest(typeDefinition1, typeDefinition2);
}
 

import org.opendaylight.yangtools.concepts.Builder; //导入依赖的package包/类
@Override
protected Builder<QueuesExternalIds> builder() {
    return new QueuesExternalIdsBuilder();
}
 

import org.opendaylight.yangtools.concepts.Builder; //导入依赖的package包/类
@Override
protected void setKey(Builder<QueuesExternalIds> builder, String key) {
    ((QueuesExternalIdsBuilder) builder).setQueuesExternalIdKey(key);
}
 

import org.opendaylight.yangtools.concepts.Builder; //导入依赖的package包/类
@Override
protected void setValue(Builder<QueuesExternalIds> builder, String value) {
    ((QueuesExternalIdsBuilder) builder).setQueuesExternalIdValue(value);
}