import org.opendaylight.yangtools.yang.binding.util.BindingReflections; //导入依赖的package包/类
static Collection<SchemaPath> decomposeRpcService(final Class<RpcService> service,
        final SchemaContext schemaContext, final Predicate<RpcRoutingStrategy> filter) {
    final QNameModule moduleName = BindingReflections.getQNameModule(service);
    final Module module = schemaContext.findModuleByNamespaceAndRevision(moduleName.getNamespace(),
            moduleName.getRevision());
    LOG.debug("Resolved service {} to module {}", service, module);

    final Collection<RpcDefinition> rpcs = module.getRpcs();
    final Collection<SchemaPath> ret = new ArrayList<>(rpcs.size());
    for (RpcDefinition rpc : rpcs) {
        final RpcRoutingStrategy strategy = RpcRoutingStrategy.from(rpc);
        if (filter.test(strategy)) {
            ret.add(rpc.getPath());
        }
    }

    return ret;
}
 

import org.opendaylight.yangtools.yang.binding.util.BindingReflections; //导入依赖的package包/类
/**
 * @throws java.lang.Exception
 */
@Before
public void setUp() throws Exception {
    final BindingBrokerTestFactory testFactory = new BindingBrokerTestFactory();
    testFactory.setExecutor(MoreExecutors.newDirectExecutorService());
    testFactory.setStartWithParsedSchema(true);
    testContext = testFactory.getTestContext();

    testContext.start();
    domMountPointService = testContext.getDomMountProviderService();
    bindingMountPointService = testContext.getBindingMountPointService();
    assertNotNull(domMountPointService);

    final InputStream moduleStream = BindingReflections.getModuleInfo(
            OpendaylightTestRpcServiceService.class)
            .getModuleSourceStream();

    assertNotNull(moduleStream);
    final List<InputStream> rpcModels = Collections.singletonList(moduleStream);
    schemaContext = YangParserTestUtils.parseYangStreams(rpcModels);
}
 

import org.opendaylight.yangtools.yang.binding.util.BindingReflections; //导入依赖的package包/类
private NotificationInvoker(final NotificationListener listener) {
    delegate = listener;
    final Map<Class<? extends Notification>, InvokerContext> builder = new HashMap<>();
    for(final TypeToken<?> ifaceToken : TypeToken.of(listener.getClass()).getTypes().interfaces()) {
        final Class<?> iface = ifaceToken.getRawType();
        if(NotificationListener.class.isAssignableFrom(iface) && BindingReflections.isBindingClass(iface)) {
            @SuppressWarnings("unchecked")
            final Class<? extends NotificationListener> listenerType = (Class<? extends NotificationListener>) iface;
            final NotificationListenerInvoker invoker = NotificationListenerInvoker.from(listenerType);
            for(final Class<? extends Notification> type : getNotificationTypes(listenerType)) {
                builder.put(type, new InvokerContext(BindingReflections.findQName(type) , invoker));
            }
        }
    }
    invokers = ImmutableMap.copyOf(builder);
}
 

import org.opendaylight.yangtools.yang.binding.util.BindingReflections; //导入依赖的package包/类
/**
 * DON'T CALL THIS IN PRODUCTION CODE EVER!!! UNTIL IT IS FIXED!
 * <p>
 * Return the {@link DataSchemaNode}
 *
 * @param context SchemaContext
 * @param d DataObject
 * @return DataSchemaNode
 * @deprecated
 */
@Deprecated
public static final DataSchemaNode getSchemaNodeForDataObject(final SchemaContext context,
        final DataObject d) {
    final QName qn = BindingReflections.findQName(d.getClass());

    final Set<DataSchemaNode> allTheNodes = getAllTheNode(context);

    // TODO: create a map to make this faster!!!!
    for (final DataSchemaNode dsn : allTheNodes) {
        if (dsn instanceof DataNodeContainer) {
            allTheNodes.addAll(((DataNodeContainer) dsn).getChildNodes());
        }
        if (dsn.getQName().equals(qn)) {
            return dsn;
        }
    }
    return null;
}
 

import org.opendaylight.yangtools.yang.binding.util.BindingReflections; //导入依赖的package包/类
/**
 * DON'T CALL THIS IN PRODUCTION CODE EVER!!! UNTIL IT IS FIXED!
 *
 * Return the {@link DataSchemaNode}
 *
 * @param context SchemaContext
 * @param d DataObject
 * @return null
 * @deprecated
 */
@Deprecated
public DataSchemaNode getSchemaNodeForDataObject(final SchemaContext context, final DataObject d) {


    final QName qn = BindingReflections.findQName(d.getClass());

    final Set<DataSchemaNode> allTheNodes = getAllTheNode(context);

    // TODO: create a map to make this faster!!!!
    for ( final DataSchemaNode dsn : allTheNodes ) {
        if(dsn instanceof DataNodeContainer) {
            allTheNodes.addAll(((DataNodeContainer)dsn).getChildNodes());
        }
        if (dsn.getQName().equals(qn)) {
            return dsn;
        }
    }
    return null;
}
 

import org.opendaylight.yangtools.yang.binding.util.BindingReflections; //导入依赖的package包/类
/**
 * Default constructor. Requires the QName of the container augmented under the routes choice
 * node in instantiations of the rib grouping. It is assumed that this container is defined by
 * the same model which populates it with route grouping instantiation, and by extension with
 * the route attributes container.
 * @param cazeClass Binding class of the AFI/SAFI-specific case statement, must not be null
 * @param containerClass Binding class of the container in routes choice, must not be null.
 * @param listClass Binding class of the route list, nust not be null;
 * @param afiClass address Family Class
 * @param safiClass SubsequentAddressFamily
 * @param destinationQname destination Qname
 */
protected AbstractRIBSupport(final Class<? extends Routes> cazeClass,
        final Class<? extends DataObject> containerClass,
    final Class<? extends Route> listClass, final Class<? extends AddressFamily> afiClass,
        final Class<? extends SubsequentAddressFamily> safiClass,
    final QName destinationQname) {
    final QName qname = BindingReflections.findQName(containerClass).intern();
    this.routesContainerIdentifier = new NodeIdentifier(qname);
    this.routeAttributesIdentifier = new NodeIdentifier(QName.create(qname,
            Attributes.QNAME.getLocalName().intern()));
    this.cazeClass = requireNonNull(cazeClass);
    this.containerClass = requireNonNull(containerClass);
    this.listClass = requireNonNull(listClass);
    this.routeQname = QName.create(qname, BindingReflections.findQName(listClass).intern().getLocalName());
    this.routesListIdentifier = new NodeIdentifier(this.routeQname);
    this.emptyRoutes = Builders.choiceBuilder().withNodeIdentifier(ROUTES).addChild(Builders.containerBuilder()
        .withNodeIdentifier(routesContainerIdentifier()).withChild(ImmutableNodes.mapNodeBuilder(this.routeQname)
                    .build()).build()).build();
    this.afiClass = afiClass;
    this.safiClass = safiClass;
    this.destinationNid = new NodeIdentifier(destinationQname);
}
 

import org.opendaylight.yangtools.yang.binding.util.BindingReflections; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    MockitoAnnotations.initMocks(this);
    this.ribActivator = new RIBActivator();
    this.ribExtension = new SimpleRIBExtensionProviderContext();

    this.ribActivator.startRIBExtensionProvider(this.ribExtension);

    this.bgpActivator = new BGPActivator();
    this.inetActivator = new org.opendaylight.protocol.bgp.inet.BGPActivator();
    this.context = new SimpleBGPExtensionProviderContext();
    this.bgpActivator.start(this.context);
    this.inetActivator.start(this.context);

    this.mappingService = new BindingToNormalizedNodeCodec(
        GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(),
        new BindingNormalizedNodeCodecRegistry(StreamWriterGenerator.create(
            JavassistUtils.forClassPool(ClassPool.getDefault()))));
    final ModuleInfoBackedContext moduleInfoBackedContext = ModuleInfoBackedContext.create();
    moduleInfoBackedContext.registerModuleInfo(BindingReflections.getModuleInfo(BgpParameters.class));
    moduleInfoBackedContext.registerModuleInfo(BindingReflections.getModuleInfo(MultiprotocolCapability.class));
    moduleInfoBackedContext.registerModuleInfo(BindingReflections.getModuleInfo(DestinationIpv4Case.class));
    moduleInfoBackedContext.registerModuleInfo(BindingReflections.getModuleInfo(AdvertizedRoutes.class));
    moduleInfoBackedContext.registerModuleInfo(BindingReflections.getModuleInfo(BgpRib.class));
    moduleInfoBackedContext.registerModuleInfo(BindingReflections.getModuleInfo(Attributes1.class));
    moduleInfoBackedContext.registerModuleInfo(BindingReflections.getModuleInfo(MpReachNlri.class));
    this.mappingService.onGlobalContextUpdated(moduleInfoBackedContext.tryToCreateSchemaContext().get());
    this.schemaContext = moduleInfoBackedContext.getSchemaContext();
    if (!Epoll.isAvailable()) {
        this.worker = new NioEventLoopGroup();
        this.boss = new NioEventLoopGroup();
    }
    this.serverRegistry = new StrictBGPPeerRegistry();
    this.serverDispatcher = new BGPDispatcherImpl(this.context.getMessageRegistry(), this.boss, this.worker,
        this.serverRegistry);
    doReturn(Mockito.mock(ClusterSingletonServiceRegistration.class)).when(this.clusterSingletonServiceProvider)
        .registerClusterSingletonService(any(ClusterSingletonService.class));
}
 

import org.opendaylight.yangtools.yang.binding.util.BindingReflections; //导入依赖的package包/类
/**
 * Creates a FpcCodecUtils instance.
 * @param module - Yang Module the instance should use for basis
 * @param topPath - Top path for the instance
 * @return FpcCodecUtils
 */
static public FpcCodecUtils get(Class<?> module,
        YangInstanceIdentifier topPath) {
     try {
         return new FpcCodecUtils(Collections.singleton(BindingReflections
                 .getModuleInfo(module)), topPath);
     } catch (Exception e) {
         LOG.error("Exception occured during FpcCodecUtilsInitialization");
         throw Throwables.propagate(e);
     }
}
 

import org.opendaylight.yangtools.yang.binding.util.BindingReflections; //导入依赖的package包/类
/**
 * Creates a NameResolver for a specific module.
 * @param module - Class instance of a Yang Module
 * @return NameResolver instance
 */
static public NameResolver get(Class<?> module) {
     try {
         return new NameResolver(Collections.singleton(BindingReflections
                 .getModuleInfo(module)));
     } catch (Exception e) {
         LOG.error("Exception occured during FpcCodecUtilsInitialization");
         throw Throwables.propagate(e);
     }
}
 

import org.opendaylight.yangtools.yang.binding.util.BindingReflections; //导入依赖的package包/类
/**
 * Returns a new ModuleInfoBackedContext loaded with default modules
 * @return ModuleInfoBackedContext
 */
public static ModuleInfoBackedContext get() {
    ModuleInfoBackedContext returnValue = ModuleInfoBackedContext.create();
    loadDefaultModules(returnValue);
    moduleContext.addModuleInfos(BindingReflections.loadModuleInfos());
    return returnValue;
}
 

import org.opendaylight.yangtools.yang.binding.util.BindingReflections; //导入依赖的package包/类
private BindingContext(final Class<DataObject> appConfigBindingClass,
        final InstanceIdentifier<DataObject> appConfigPath, final Class<? extends DataSchemaNode> schemaType) {
    this.appConfigBindingClass = appConfigBindingClass;
    this.appConfigPath = appConfigPath;
    this.schemaType = schemaType;

    bindingQName = BindingReflections.findQName(appConfigBindingClass);
}
 

import org.opendaylight.yangtools.yang.binding.util.BindingReflections; //导入依赖的package包/类
public void loadSchemas(final Class<?>... classes) {
    YangModuleInfo moduleInfo;
    try {
        final ModuleInfoBackedContext context = ModuleInfoBackedContext.create();
        for (final Class<?> clz : classes) {
            moduleInfo = BindingReflections.getModuleInfo(clz);

            context.registerModuleInfo(moduleInfo);
        }
        this.schemaContext = context.tryToCreateSchemaContext().get();
        this.domStore.onGlobalContextUpdated(this.schemaContext);
    } catch (final Exception e) {
        Throwables.propagateIfPossible(e);
    }
}
 

import org.opendaylight.yangtools.yang.binding.util.BindingReflections; //导入依赖的package包/类
@Before
public final void setup() throws Exception {
    final YangModuleInfo moduleInfo = BindingReflections
            .getModuleInfo(TwoLevelList.class);
    final ModuleInfoBackedContext context = ModuleInfoBackedContext.create();
    context.registerModuleInfo(moduleInfo);
    this.schemaContext = context.tryToCreateSchemaContext().get();

    this.dclExecutorService = new TestDCLExecutorService(
            SpecialExecutors.newBlockingBoundedFastThreadPool(1, 10, "DCL" ));

    this.datastore = new InMemoryDOMDataStore("TEST", this.dclExecutorService);
    this.datastore.onGlobalContextUpdated(this.schemaContext);
}
 

import org.opendaylight.yangtools.yang.binding.util.BindingReflections; //导入依赖的package包/类
@Override
public <T extends Notification> ListenerRegistration<NotificationListener<T>> registerNotificationListener(
        final Class<T> type, final NotificationListener<T> listener) {

    final FunctionalNotificationListenerAdapter<T> adapter = new FunctionalNotificationListenerAdapter<>(codec, type, listener);
    final SchemaPath domType = SchemaPath.create(true, BindingReflections.findQName(type));
    final ListenerRegistration<?> domReg = domService.registerNotificationListener(adapter, domType);
    return new AbstractListenerRegistration<NotificationListener<T>>(listener) {
        @Override
        protected void removeRegistration() {
            domReg.close();
        }

    };
}
 

import org.opendaylight.yangtools.yang.binding.util.BindingReflections; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private static Set<Class<? extends Notification>> getNotificationTypes(final Class<? extends org.opendaylight.yangtools.yang.binding.NotificationListener> type) {
    // TODO: Investigate possibility and performance impact if we cache this or expose
    // it from NotificationListenerInvoker
    final Set<Class<? extends Notification>> ret = new HashSet<>();
    for(final Method method : type.getMethods()) {
        if(BindingReflections.isNotificationCallback(method)) {
            final Class<? extends Notification> notification = (Class<? extends Notification>) method.getParameterTypes()[0];
            ret.add(notification);
        }
    }
    return ret;
}
 

import org.opendaylight.yangtools.yang.binding.util.BindingReflections; //导入依赖的package包/类
private Module getModuleBlocking(final Class<?> modeledClass) {
    final QNameModule moduleName = BindingReflections.getQNameModule(modeledClass);
    final URI namespace = moduleName.getNamespace();
    final Date revision = moduleName.getRevision();
    Module module = runtimeContext().getSchemaContext().findModuleByNamespaceAndRevision(namespace, revision);
    if ((module == null) && this.futureSchema.waitForSchema(namespace, revision)) {
        module = runtimeContext().getSchemaContext().findModuleByNamespaceAndRevision(namespace, revision);
    }
    Preconditions.checkState(module != null, "Schema for %s is not available.", modeledClass);
    return module;
}
 

import org.opendaylight.yangtools.yang.binding.util.BindingReflections; //导入依赖的package包/类
public static Map<SchemaPath, NotificationListenerInvoker> createInvokerMapFor(final Class<? extends NotificationListener> implClz) {
    final Map<SchemaPath, NotificationListenerInvoker> builder = new HashMap<>();
    for(final TypeToken<?> ifaceToken : TypeToken.of(implClz).getTypes().interfaces()) {
        Class<?> iface = ifaceToken.getRawType();
        if(NotificationListener.class.isAssignableFrom(iface) && BindingReflections.isBindingClass(iface)) {
            @SuppressWarnings("unchecked")
            final Class<? extends NotificationListener> listenerType = (Class<? extends NotificationListener>) iface;
            final NotificationListenerInvoker invoker = NotificationListenerInvoker.from(listenerType);
            for(final SchemaPath path : getNotificationTypes(listenerType)) {
                builder.put(path, invoker);
            }
        }
    }
    return ImmutableMap.copyOf(builder);
}
 

import org.opendaylight.yangtools.yang.binding.util.BindingReflections; //导入依赖的package包/类
private static Set<SchemaPath> getNotificationTypes(final Class<? extends NotificationListener> type) {
    // TODO: Investigate possibility and performance impact if we cache this or expose
    // it from NotificationListenerInvoker
    final Set<SchemaPath> ret = new HashSet<>();
    for(final Method method : type.getMethods()) {
        if(BindingReflections.isNotificationCallback(method)) {
            final Class<?> notification = method.getParameterTypes()[0];
            final QName name = BindingReflections.findQName(notification);
            ret.add(SchemaPath.create(true, name));
        }
    }
    return ret;
}
 

import org.opendaylight.yangtools.yang.binding.util.BindingReflections; //导入依赖的package包/类
@Override
protected Iterable<YangModuleInfo> getModuleInfos() throws Exception {
    return ImmutableSet.of(
            BindingReflections.getModuleInfo(TwoLevelList.class),
            BindingReflections.getModuleInfo(TreeComplexUsesAugment.class)
            );
}
 

import org.opendaylight.yangtools.yang.binding.util.BindingReflections; //导入依赖的package包/类
@Override
protected Iterable<YangModuleInfo> getModuleInfos() throws Exception {
    Builder<YangModuleInfo> moduleInfoSet = ImmutableSet.<YangModuleInfo>builder();
    for (Class<?> moduleClass : ImmutableList.<Class<?>>of(
        NetworkTopology.class, Neutron.class, NetconfNode.class)) {
        YangModuleInfo moduleInfo = BindingReflections.getModuleInfo(moduleClass);
        Preconditions.checkNotNull(moduleInfo, "Module Info for %s is not available.", moduleClass);
        collectYangModuleInfo(moduleInfo, moduleInfoSet);
    }
    return moduleInfoSet.build();
}