Java ConcurrentInvertedRadixTree类代码示例

import com.googlecode.concurrenttrees.radixinverted.ConcurrentInvertedRadixTree; //导入依赖的package包/类
@Activate
public void activate() {
    ribTable4 = new ConcurrentInvertedRadixTree<>(
            new DefaultByteArrayNodeFactory());
    ribTable6 = new ConcurrentInvertedRadixTree<>(
            new DefaultByteArrayNodeFactory());

    routesWaitingOnArp = Multimaps.synchronizedSetMultimap(
            HashMultimap.create());

    coreService.registerApplication(ROUTER_APP_ID);

    bgpUpdatesExecutor = Executors.newSingleThreadExecutor(
            new ThreadFactoryBuilder()
            .setNameFormat("rib-updates-%d").build());
}
 

import com.googlecode.concurrenttrees.radixinverted.ConcurrentInvertedRadixTree; //导入依赖的package包/类
@Override
public void stop() {
    routeSourceService.stop();

    this.hostService.removeListener(hostListener);

    // Stop the thread(s)
    bgpUpdatesExecutor.shutdownNow();

    synchronized (this) {
        // Cleanup all local state
        ribTable4 = new ConcurrentInvertedRadixTree<>(
                new DefaultByteArrayNodeFactory());
        ribTable6 = new ConcurrentInvertedRadixTree<>(
                new DefaultByteArrayNodeFactory());
        routeUpdatesQueue.clear();
        routesWaitingOnArp.clear();
        ip2Mac.clear();
    }
}
 

import com.googlecode.concurrenttrees.radixinverted.ConcurrentInvertedRadixTree; //导入依赖的package包/类
@Override
public void stop() {
	// TODO Auto-generated method stub
	this.closed = true;
	// Stop host service
	hostService.stop();

	// Stop the thread(s)
	bgpUpdatesExecutor.shutdownNow();
	synchronized (this) {
		// Cleanup all local state
		ribTable4 = new ConcurrentInvertedRadixTree<>(new DefaultByteArrayNodeFactory());
		routeUpdatesQueue.clear();
		routesWaitingOnArp.clear();
		ip2Mac.clear();
	}
}
 

import com.googlecode.concurrenttrees.radixinverted.ConcurrentInvertedRadixTree; //导入依赖的package包/类
@Override
public void stop() {
    bgpService.stop();

    this.hostService.removeListener(hostListener);

    // Stop the thread(s)
    bgpUpdatesExecutor.shutdownNow();

    synchronized (this) {
        // Cleanup all local state
        ribTable4 = new ConcurrentInvertedRadixTree<>(
                new DefaultByteArrayNodeFactory());
        ribTable6 = new ConcurrentInvertedRadixTree<>(
                new DefaultByteArrayNodeFactory());
        routeUpdatesQueue.clear();
        routesWaitingOnArp.clear();
        ip2Mac.clear();
    }
}
 

import com.googlecode.concurrenttrees.radixinverted.ConcurrentInvertedRadixTree; //导入依赖的package包/类
public static void main(String[] args) {
    InvertedRadixTree<Integer> tree = new ConcurrentInvertedRadixTree<Integer>(new DefaultCharArrayNodeFactory());

    tree.put("TEST", 1);
    tree.put("TOAST", 2);
    tree.put("TEAM", 3);

    System.out.println("Tree structure:");
    // PrettyPrintable is a non-public API for testing, prints semi-graphical representations of trees...
    PrettyPrinter.prettyPrint((PrettyPrintable) tree, System.out);

    System.out.println();
    System.out.println("Value for 'TEST' (exact match): " + tree.getValueForExactKey("TEST"));
    System.out.println("Value for 'TOAST' (exact match): " + tree.getValueForExactKey("TOAST"));
    System.out.println();
    System.out.println("Keys contained in 'MY TEAM LIKES TOAST': " + Iterables.toString(tree.getKeysContainedIn("MY TEAM LIKES TOAST")));
    System.out.println("Keys contained in 'MY TEAM LIKES TOASTERS': " + Iterables.toString(tree.getKeysContainedIn("MY TEAM LIKES TOASTERS")));
    System.out.println("Values for keys contained in 'MY TEAM LIKES TOAST': " + Iterables.toString(tree.getValuesForKeysContainedIn("MY TEAM LIKES TOAST")));
    System.out.println("Key-value pairs for keys contained in 'MY TEAM LIKES TOAST': " + Iterables.toString(tree.getKeyValuePairsForKeysContainedIn("MY TEAM LIKES TOAST")));
}
 

import com.googlecode.concurrenttrees.radixinverted.ConcurrentInvertedRadixTree; //导入依赖的package包/类
public QuikDomains() {
	// Initialize
	this.domains = new HashSet<>();
	this.domainTree = new ConcurrentInvertedRadixTree<>(new DefaultCharArrayNodeFactory());
	
	// Manually add QuikCore
	this.domains.add("quikcore");
	this.domainTree.put("com.github.quikmod.quikcore", "quikcore");
}
 

import com.googlecode.concurrenttrees.radixinverted.ConcurrentInvertedRadixTree; //导入依赖的package包/类
@Override
public void onSessionInitiated(ProviderContext session) {
	LOG.info("Router Session Initiated");
	routesWaitingOnArp = Multimaps.synchronizedSetMultimap(HashMultimap.<AtriumIpAddress, RouteEntry> create());
	ribTable4 = new ConcurrentInvertedRadixTree<>(new DefaultByteArrayNodeFactory());
	bgpUpdatesExecutor = Executors
			.newSingleThreadExecutor(new ThreadFactoryBuilder().setNameFormat("atrium-bgp-updates-%d").build());
}
 

import com.googlecode.concurrenttrees.radixinverted.ConcurrentInvertedRadixTree; //导入依赖的package包/类
@Activate
public void activate() {
    ribTable4 = new ConcurrentInvertedRadixTree<>(
            new DefaultByteArrayNodeFactory());
    ribTable6 = new ConcurrentInvertedRadixTree<>(
            new DefaultByteArrayNodeFactory());

    routesWaitingOnArp = Multimaps.synchronizedSetMultimap(
            HashMultimap.<IpAddress, RouteEntry>create());

    bgpUpdatesExecutor = Executors.newSingleThreadExecutor(
            new ThreadFactoryBuilder()
            .setNameFormat("sdnip-bgp-updates-%d").build());
}
 

import com.googlecode.concurrenttrees.radixinverted.ConcurrentInvertedRadixTree; //导入依赖的package包/类
/**
 * Package-private constructor, used by static factory methods.
 */
protected InvertedRadixTreeIndex(Attribute<O, A> attribute, NodeFactory nodeFactory) {
    super(attribute, new HashSet<Class<? extends Query>>() {{
        add(Equal.class);
        add(In.class);
        add(StringIsContainedIn.class);
    }});
    this.nodeFactory = nodeFactory;
    this.tree = new ConcurrentInvertedRadixTree<StoredResultSet<O>>(nodeFactory);
}
 

import com.googlecode.concurrenttrees.radixinverted.ConcurrentInvertedRadixTree; //导入依赖的package包/类
RulesBySsurt(Collection<AccessRule> rules) {
    tree = new ConcurrentInvertedRadixTree<>(new DefaultCharArrayNodeFactory());
    for (AccessRule rule: rules) {
        try {
            put(rule);
        } catch (IllegalArgumentException e) {
            log.log(Level.WARNING, "Skipping invalid access rule: " + rule.id, e);
        }
    }
}
 

import com.googlecode.concurrenttrees.radixinverted.ConcurrentInvertedRadixTree; //导入依赖的package包/类
public synchronized void setDrawerItems(ArrayList<DrawerItem> drawerItems) {
    tree = new ConcurrentInvertedRadixTree<>(new DefaultCharArrayNodeFactory());
    for (int i = 0; i < drawerItems.size(); i++) {
        String path = drawerItems.get(i).path;
        if(path != null) tree.put(path, i);
    }
    this.drawerItems = drawerItems;
}
 

import com.googlecode.concurrenttrees.radixinverted.ConcurrentInvertedRadixTree; //导入依赖的package包/类
@Override
public void init(FloodlightModuleContext context) throws FloodlightModuleException {
    interfaceRoutes = new ConcurrentInvertedRadixTree<>(
            new DefaultByteArrayNodeFactory());
    externalNetworkSwitchPorts = new HashSet<SwitchPort>();
    // Reading config values
    String configFilenameParameter = context.getConfigParams(this).get("configfile");
    if (configFilenameParameter != null) {
        currentConfigFilename = configFilenameParameter;
    }
    log.debug("Config file set to {}", currentConfigFilename);

    readConfiguration(currentConfigFilename);
}
 

import com.googlecode.concurrenttrees.radixinverted.ConcurrentInvertedRadixTree; //导入依赖的package包/类
/**
 * This is just a test of the InvertedRadixTree, rather than an actual unit
 * test of SdnIp. It tests that the algorithm used to retrieve the
 * longest prefix match from the tree actually does retrieve the longest
 * prefix, and not just any matching prefix.
 */
@Test
public void getOutgoingInterfaceTest() {
    interfaces = new HashMap<>();
    interfaceRoutes = new ConcurrentInvertedRadixTree<>(
            new DefaultByteArrayNodeFactory());

    Interface interface1 = new Interface("sw3-eth1", "00:00:00:00:00:00:00:a3",
            (short) 1, "192.168.10.101", 24);
    interfaces.put(interface1.getName(), interface1);
    Interface interface2 = new Interface("sw5-eth1", "00:00:00:00:00:00:00:a5",
            (short) 1, "192.168.20.101", 16);
    interfaces.put(interface2.getName(), interface2);
    Interface interface3 = new Interface("sw2-eth1", "00:00:00:00:00:00:00:a2",
            (short) 1, "192.168.60.101", 16);
    interfaces.put(interface3.getName(), interface3);
    Interface interface4 = new Interface("sw6-eth1", "00:00:00:00:00:00:00:a6",
            (short) 1, "192.168.60.101", 30);
    interfaces.put(interface4.getName(), interface4);
    Interface interface5 = new Interface("sw4-eth4", "00:00:00:00:00:00:00:a4",
            (short) 4, "192.168.60.101", 24);
    interfaces.put(interface5.getName(), interface5);

    for (Interface intf : interfaces.values()) {
        Prefix prefix = new Prefix(intf.getIpAddress().getAddress(),
                intf.getPrefixLength());
        interfaceRoutes.put(prefix.toBinaryString(), intf);
    }

    // Check whether the prefix length takes effect
    InetAddress nextHopAddress = InetAddresses.forString("192.0.0.1");
    assertNotNull(nextHopAddress);
    assertNull(longestInterfacePrefixMatch(nextHopAddress));

    // Check whether it returns the longest matchable address
    nextHopAddress = InetAddresses.forString("192.168.60.101");
    assertEquals("sw6-eth1", longestInterfacePrefixMatch(nextHopAddress).getName());
}
 

import com.googlecode.concurrenttrees.radixinverted.ConcurrentInvertedRadixTree; //导入依赖的package包/类
/**
 * Creates a new route table.
 */
public RouteTable() {
    routeTable = new ConcurrentInvertedRadixTree<>(
            new DefaultByteArrayNodeFactory());

    alternativeRoutes = Maps.newHashMap();
}
 

import com.googlecode.concurrenttrees.radixinverted.ConcurrentInvertedRadixTree; //导入依赖的package包/类
/**
 * Creates a new route table.
 */
public RouteTable() {
    routeTable = new ConcurrentInvertedRadixTree<>(
            new DefaultByteArrayNodeFactory());
}