import org.opendaylight.controller.sal.packet.IDataPacketService; //导入依赖的package包/类
/**
 * Unsets DataPacketService
 */
void unsetDataPacketService(IDataPacketService s) {
    log.trace("Removed DataPacketService.");

    if (dataPacketService == s) {
        dataPacketService = null;
    }
}
 

import org.opendaylight.controller.sal.packet.IDataPacketService; //导入依赖的package包/类
public void configureInstance(Component c, Object imp, String containerName) {
    log.trace("Configuring instance");

    if (imp.equals(DissectorHandler.class)) {
        // Define exported and used services for DissectorHandler component.

        Dictionary<String, Object> props = new Hashtable<String, Object>();
        props.put("salListenerName", "myDissectorHandler");

        // Export IListenDataPacket interface to receive packet-in events.
        c.setInterface(new String[] {IListenDataPacket.class.getName()}, props);

        // Need the DataPacketService for encoding, decoding, sending data packets
        c.add(createContainerServiceDependency(containerName).setService(
                IDataPacketService.class).setCallbacks(
                "setDataPacketService", "unsetDataPacketService")
                .setRequired(true));
        
        // Need FlowProgrammerService for programming flows
        c.add(createContainerServiceDependency(containerName).setService(
                IFlowProgrammerService.class).setCallbacks(
                "setFlowProgrammerService", "unsetFlowProgrammerService")
                .setRequired(true));
        
        // Need SwitchManager service for enumerating ports of switch
        c.add(createContainerServiceDependency(containerName).setService(
                ISwitchManager.class).setCallbacks(
                "setSwitchManagerService", "unsetSwitchManagerService")
                .setRequired(true));
    }

}
 

import org.opendaylight.controller.sal.packet.IDataPacketService; //导入依赖的package包/类
/**
 * Callback called by OpenDaylight when DataPacketService is unbound.
 */
void unsetDataPacketService(IDataPacketService s) {
    log.trace("Removed DataPacketService.");

    if (dataPacketService == s) {
        dataPacketService = null;
    }
}
 

import org.opendaylight.controller.sal.packet.IDataPacketService; //导入依赖的package包/类
/**
 * Unbind from DataPacketService.
 */
void unsetDataPacketService(IDataPacketService s) {
    log.trace("Unbind from DataPacketService.");

    if (dataPacketService == s) {
        dataPacketService = null;
    }
}
 

import org.opendaylight.controller.sal.packet.IDataPacketService; //导入依赖的package包/类
public void configureInstance(Component c, Object imp, String containerName) {
    if (imp.equals(PacketHandler.class)) {
        log.trace("Configuring packet handler");
     
        // Export IListenDataPacket interface to receive packet-in events.
        Dictionary<String, Object> props = new Hashtable<String, Object>();
        props.put("salListenerName", "sdnmq");
        c.setInterface(new String[] {IListenDataPacket.class.getName()}, props);

        // Need the DataPacketService for decoding data packets
        c.add(createContainerServiceDependency(containerName).setService(
                IDataPacketService.class).setCallbacks(
                        "setDataPacketService", "unsetDataPacketService").setRequired(true));

    } else if (imp.equals(PacketForwarder.class)) {
        log.trace("Configuring packet forwarder");
        
        // Need the DataPacketService for encoding and sending packets
        c.add(createContainerServiceDependency(containerName).setService(
                IDataPacketService.class).setCallbacks(
                        "setDataPacketService", "unsetDataPacketService").setRequired(true));
        
        // Need SwitchManager service for finding nodes and node connectors
        c.add(createContainerServiceDependency(containerName).setService(
                ISwitchManager.class).setCallbacks(
                        "setSwitchManagerService", "unsetSwitchManagerService").setRequired(true));
    } else if (imp.equals(FlowProgrammer.class)) {
        log.trace("Configuring flow programmer");
        
        // Need SwitchManager service for finding nodes and node connectors
        c.add(createContainerServiceDependency(containerName).setService(
                ISwitchManager.class).setCallbacks(
                        "setSwitchManagerService", "unsetSwitchManagerService").setRequired(true));
        
        // Need FlowProgrammerService for programming flows
        c.add(createContainerServiceDependency(containerName).setService(
                IFlowProgrammerService.class).setCallbacks(
                        "setFlowProgrammerService", "unsetFlowProgrammerService").setRequired(true));
    }
}
 

import org.opendaylight.controller.sal.packet.IDataPacketService; //导入依赖的package包/类
/**
 * Function that is called when configuration of the dependencies
 * is required.
 *
 * @param c dependency manager Component object, used for
 * configuring the dependencies exported and imported
 * @param imp Implementation class that is being configured,
 * needed as long as the same routine can configure multiple
 * implementations
 * @param containerName The containerName being configured, this allow
 * also optional per-container different behavior if needed, usually
 * should not be the case though.
 */
public void configureInstance(Component c, Object imp, String containerName) {
    if (imp.equals(ArpHandler.class)) {
        // export the service
        Dictionary<String, String> props = new Hashtable<String, String>();
        props.put("salListenerName", "arphandler");
        c.setInterface(new String[] { IHostFinder.class.getName(),
                IListenDataPacket.class.getName() }, props);

        c.add(createContainerServiceDependency(containerName).setService(
                ISwitchManager.class).setCallbacks("setSwitchManager",
                "unsetSwitchManager").setRequired(true));

        c.add(createContainerServiceDependency(containerName).setService(
                ITopologyManager.class).setCallbacks("setTopologyManager",
                "unsetTopologyMananger").setRequired(true));

       c.add(createContainerServiceDependency(containerName).setService(
                IDataPacketService.class).setCallbacks(
                "setDataPacketService", "unsetDataPacketService")
                .setRequired(true));

        // the Host Listener is optional
        c.add(createContainerServiceDependency(containerName).setService(
                IfHostListener.class).setCallbacks("setHostListener",
                "unsetHostListener").setRequired(false));

        // the IfIptoHost is a required dependency
        c.add(createContainerServiceDependency(containerName).setService(
                IfIptoHost.class).setCallbacks("setHostTracker",
                "unsetHostTracker").setRequired(true));
    }
}
 

import org.opendaylight.controller.sal.packet.IDataPacketService; //导入依赖的package包/类
/**
 * Function that is called when configuration of the dependencies is
 * required.
 *
 * @param c
 *            dependency manager Component object, used for configuring the
 *            dependencies exported and imported
 * @param imp
 *            Implementation class that is being configured, needed as long
 *            as the same routine can configure multiple implementations
 * @param containerName
 *            The containerName being configured, this allow also optional
 *            per-container different behavior if needed, usually should not
 *            be the case though.
 */
@Override
public void configureInstance(Component c, Object imp, String containerName) {
    if (imp.equals(DeviceManagerImpl.class)) {
        // export the service
        // XXX - TODO merge with existing APIs
        Dictionary<String, String> props = new Hashtable<String, String>();
        props.put("salListenerName", "devicemanager");

        c.setInterface(
                new String[] { IDeviceService.class.getName(),
                        IfIptoHost.class.getName(),
                        IListenDataPacket.class.getName(),
                        ITopologyManagerAware.class.getName() }, props);

        c.add(createContainerServiceDependency(containerName)
                .setService(ISwitchManager.class)
                .setCallbacks("setSwitchManager", "unsetSwitchManager")
                .setRequired(false));

        c.add(createContainerServiceDependency(containerName)
                .setService(IDataPacketService.class)
                .setCallbacks("setDataPacketService",
                        "unsetDataPacketService").setRequired(true));

        c.add(createContainerServiceDependency(containerName)
                .setService(IfNewHostNotify.class)
                .setCallbacks("setNewHostNotify",
                        "unsetNewHostNotify").setRequired(false));

        // c.add(createContainerServiceDependency(containerName).setService(
        // IClusterContainerServices.class).setCallbacks(
        // "setClusterContainerService",
        // "unsetClusterContainerService").setRequired(true));
        c.add(createContainerServiceDependency(containerName)
                .setService(ITopologyManager.class)
                .setCallbacks("setTopologyManager", "unsetTopologyManager")
                .setRequired(false));
    }
}
 

import org.opendaylight.controller.sal.packet.IDataPacketService; //导入依赖的package包/类
/**
 * Function that is called when configuration of the dependencies
 * is required.
 *
 * @param c dependency manager Component object, used for
 * configuring the dependencies exported and imported
 * @param imp Implementation class that is being configured,
 * needed as long as the same routine can configure multiple
 * implementations
 * @param containerName The containerName being configured, this allow
 * also optional per-container different behavior if needed, usually
 * should not be the case though.
 */
public void configureInstance(Component c, Object imp, String containerName) {
    if (imp.equals(LoadBalancerService.class)) {
        // export the service
        Dictionary<String, String> props = new Hashtable<String, String>();
        props.put("salListenerName", "loadbalancer");

        c.setInterface(new String[] { IListenDataPacket.class.getName(),
                    IConfigManager.class.getName()}, props);

        c.add(createContainerServiceDependency(containerName).setService(
                IDataPacketService.class).setCallbacks(
                "setDataPacketService", "unsetDataPacketService")
                .setRequired(true));

        c.add(createContainerServiceDependency(containerName).setService(
                IRouting.class).setCallbacks("setRouting", "unsetRouting")
                .setRequired(false));

        c.add(createContainerServiceDependency(containerName).setService(
                IfIptoHost.class).setCallbacks("setHostTracker",
                "unsetHostTracker").setRequired(true));

        c.add(createContainerServiceDependency(containerName).setService(
                IForwardingRulesManager.class).setCallbacks(
                "setForwardingRulesManager", "unsetForwardingRulesManager")
                .setRequired(true));
    }
}
 

import org.opendaylight.controller.sal.packet.IDataPacketService; //导入依赖的package包/类
/**
 * Function that is called when configuration of the dependencies
 * is required.
 *
 * @param c dependency manager Component object, used for
 * configuring the dependencies exported and imported
 * @param imp Implementation class that is being configured,
 * needed as long as the same routine can configure multiple
 * implementations
 * @param containerName The containerName being configured, this allow
 * also optional per-container different behavior if needed, usually
 * should not be the case though.
 */
public void configureInstance(Component c, Object imp, String containerName) {
    if (imp.equals(QoSHandler.class)) {
        // export the service
        Dictionary<String, String> props = new Hashtable<String, String>();
        props.put("salListenerName", "qoshandler");
        c.setInterface(new String[] { IPluginOutDataPacketService.class.getName(),
                IListenDataPacket.class.getName() }, props);

        c.add(createContainerServiceDependency(containerName).setService(
                ISwitchManager.class).setCallbacks("setSwitchManager",
                "unsetSwitchManager").setRequired(true));

        c.add(createContainerServiceDependency(containerName).setService(
                ITopologyManager.class).setCallbacks("setTopologyManager",
                "unsetTopologyMananger").setRequired(true));

       c.add(createContainerServiceDependency(containerName).setService(
                IDataPacketService.class).setCallbacks(
                "setDataPacketService", "unsetDataPacketService")
                .setRequired(true));

        // the Host Listener is optional
        c.add(createContainerServiceDependency(containerName).setService(
                IfHostListener.class).setCallbacks("setHostListener",
                "unsetHostListener").setRequired(false));

        // the IfIptoHost is a required dependency
        c.add(createContainerServiceDependency(containerName).setService(
                IfIptoHost.class).setCallbacks("setHostTracker",
                "unsetHostTracker").setRequired(true));
    }
}
 

import org.opendaylight.controller.sal.packet.IDataPacketService; //导入依赖的package包/类
/**
 * Sets a reference to the requested DataPacketService
 */
void setDataPacketService(IDataPacketService s) {
    log.trace("Set DataPacketService.");

    dataPacketService = s;
}
 

import org.opendaylight.controller.sal.packet.IDataPacketService; //导入依赖的package包/类
public void setDataPacketService(IDataPacketService s) {
    log.trace("Set DataPacketService.");
    this.dataPacketService = s;
}
 

import org.opendaylight.controller.sal.packet.IDataPacketService; //导入依赖的package包/类
public void unsetDataPacketService(IDataPacketService s) {
    log.trace("Removed DataPacketService.");
    if (this.dataPacketService == s) {
        this.dataPacketService = null;
    }
}
 

import org.opendaylight.controller.sal.packet.IDataPacketService; //导入依赖的package包/类
@Override
public void configureInstance(Component c, Object imp, String containerName) {
    if (imp.equals(JumpIP.class)) {
        // export the service needed to listen to topology updates
        final Dictionary<String, Object> props = new Hashtable<String, Object>();
        props.put("StatisgetListenerName", "Statisget");
        props.put("salListenerName", "datapacketget");
        props.put("topoListenerName", "topoget");
        
        //listen topology to update topo & handle packet_in
        c.setInterface(new String[] { ITopologyManagerAware.class.getName(),
                 IListenDataPacket.class.getName() }, props);
        
        //statistics service
        c.add(createContainerServiceDependency(containerName)
            .setService(IStatisticsManager.class)
            .setCallbacks("setStatisticsManager", "unsetStatisticsManager")
            .setRequired(false));

        //flowprogrammer service
        c.add(createContainerServiceDependency(containerName)
            .setService(IFlowProgrammerService.class)
            .setCallbacks("setFlowProgrammerService","unsetFlowProgrammerService")
            .setRequired(true));

        //topology service
        c.add(createContainerServiceDependency(containerName)
            .setService(ITopologyManager.class)
            .setCallbacks("setTopologyManager", "unsetTopologyManager")
            .setRequired(true));
        
        //switch service
        c.add(createContainerServiceDependency(containerName)
            .setService(ISwitchManager.class)
            .setCallbacks("setSwitchManager", "unsetSwitchManager")
            .setRequired(false));
        c.add(createContainerServiceDependency(containerName)
            .setService(IfIptoHost.class)
            .setCallbacks("setHostTracker", "unsetHostTracker")
            .setRequired(true));
        c.add(createContainerServiceDependency(containerName)
            .setService(IDataPacketService.class)
            .setCallbacks("setDataPacketService", "unsetDataPacketService")
            .setRequired(true));
        c.add(createContainerServiceDependency(containerName)
            .setService(IForwardingRulesManager.class)
            .setCallbacks("setForwarder", "unsetForwarder")
            .setRequired(true));   
    }
}
 

import org.opendaylight.controller.sal.packet.IDataPacketService; //导入依赖的package包/类
/**
 * Callback invoked by OpenDaylight when DataPacketService is bound.
 */
void setDataPacketService(IDataPacketService s) {
    log.trace("Set DataPacketService.");

    dataPacketService = s;
}
 

import org.opendaylight.controller.sal.packet.IDataPacketService; //导入依赖的package包/类
/**
 * Bind to DataPacketService.
 */
void setDataPacketService(IDataPacketService s) {
    log.trace("Bind to DataPacketService.");

    dataPacketService = s;
}
 

import org.opendaylight.controller.sal.packet.IDataPacketService; //导入依赖的package包/类
void setDataPacketService(IDataPacketService s) {
    this.dataPacketService = s;
}
 

import org.opendaylight.controller.sal.packet.IDataPacketService; //导入依赖的package包/类
void unsetDataPacketService(IDataPacketService s) {
    if (this.dataPacketService == s) {
        this.dataPacketService = null;
    }
}
 

import org.opendaylight.controller.sal.packet.IDataPacketService; //导入依赖的package包/类
void setDataPacketService(IDataPacketService s) {
	this.dataPacketService = s;
}
 

import org.opendaylight.controller.sal.packet.IDataPacketService; //导入依赖的package包/类
void unsetDataPacketService(IDataPacketService s) {
	if (this.dataPacketService == s) {
		this.dataPacketService = null;
	}
}