Java Code Examples for sun.management.snmp.util.SnmpCachedData#oidComparator()

/**
 * Return a table handler containing the Thread indexes.
 * Indexes are computed from the ThreadId.
 **/
protected SnmpCachedData updateCachedDatas(Object userData) {

    // We are getting all the thread ids. WARNING.
    // Some of them will be not valid when accessed for data...
    // See getEntry
    long[] id = JvmThreadingImpl.getThreadMXBean().getAllThreadIds();


    // Time stamp for the cache
    final long time = System.currentTimeMillis();

    SnmpOid indexes[] = new SnmpOid[id.length];
    final TreeMap<SnmpOid, Object> table =
            new TreeMap<>(SnmpCachedData.oidComparator);
    for(int i = 0; i < id.length; i++) {
        log.debug("", "Making index for thread id [" + id[i] +"]");
        //indexes[i] = makeOid(id[i]);
        SnmpOid oid = makeOid(id[i]);
        table.put(oid, oid);
    }

    return new SnmpCachedData(time, table);
}
 

/**
 * Return a table handler that holds the jvmMemManagerTable table data.
 * This method return the cached table data if it is still
 * valid, recompute it and cache the new value if it's not.
 * If it needs to recompute the cached data, it first
 * try to obtain the list of memory managers from the request
 * contextual cache, and if it is not found, it calls
 * <code>ManagementFactory.getMemoryMBean().getMemoryManagers()</code>
 * and caches the value.
 * This ensures that
 * <code>ManagementFactory.getMemoryMBean().getMemoryManagers()</code>
 * is not called more than once per request, thus ensuring a
 * consistent view of the table.
 **/
protected SnmpCachedData updateCachedDatas(Object userData) {
    // Get the MemoryManager     table
    final SnmpTableHandler mmHandler =
        meta.getManagerHandler(userData);

    // Get the MemoryPool        table
    final SnmpTableHandler mpHandler =
        meta.getPoolHandler(userData);

    // Time stamp for the cache
    final long time = System.currentTimeMillis();

    //     Build a Map poolname -> index
    final Map<String,SnmpOid> poolIndexMap = buildPoolIndexMap(mpHandler);

    // For each memory manager, get the list of memory pools
    // For each memory pool, find its index in the memory pool table
    // Create a row in the relation table.
    final TreeMap<SnmpOid, Object> table =
            new TreeMap<>(SnmpCachedData.oidComparator);
    updateTreeMap(table,userData,mmHandler,mpHandler,poolIndexMap);

    return new SnmpCachedData(time,table);
}
 

/**
 * Return a table handler containing the Thread indexes.
 * Indexes are computed from the ThreadId.
 **/
protected SnmpCachedData updateCachedDatas(Object userData) {

    // We are getting all the thread ids. WARNING.
    // Some of them will be not valid when accessed for data...
    // See getEntry
    long[] id = JvmThreadingImpl.getThreadMXBean().getAllThreadIds();


    // Time stamp for the cache
    final long time = System.currentTimeMillis();

    SnmpOid indexes[] = new SnmpOid[id.length];
    final TreeMap<SnmpOid, Object> table =
            new TreeMap<>(SnmpCachedData.oidComparator);
    for(int i = 0; i < id.length; i++) {
        log.debug("", "Making index for thread id [" + id[i] +"]");
        //indexes[i] = makeOid(id[i]);
        SnmpOid oid = makeOid(id[i]);
        table.put(oid, oid);
    }

    return new SnmpCachedData(time, table);
}
 

/**
 * Return a table handler that holds the jvmMemManagerTable table data.
 * This method return the cached table data if it is still
 * valid, recompute it and cache the new value if it's not.
 * If it needs to recompute the cached data, it first
 * try to obtain the list of memory managers from the request
 * contextual cache, and if it is not found, it calls
 * <code>ManagementFactory.getMemoryMBean().getMemoryManagers()</code>
 * and caches the value.
 * This ensures that
 * <code>ManagementFactory.getMemoryMBean().getMemoryManagers()</code>
 * is not called more than once per request, thus ensuring a
 * consistent view of the table.
 **/
protected SnmpCachedData updateCachedDatas(Object userData) {
    // Get the MemoryManager     table
    final SnmpTableHandler mmHandler =
        meta.getManagerHandler(userData);

    // Get the MemoryPool        table
    final SnmpTableHandler mpHandler =
        meta.getPoolHandler(userData);

    // Time stamp for the cache
    final long time = System.currentTimeMillis();

    //     Build a Map poolname -> index
    final Map<String,SnmpOid> poolIndexMap = buildPoolIndexMap(mpHandler);

    // For each memory manager, get the list of memory pools
    // For each memory pool, find its index in the memory pool table
    // Create a row in the relation table.
    final TreeMap<SnmpOid, Object> table =
            new TreeMap<>(SnmpCachedData.oidComparator);
    updateTreeMap(table,userData,mmHandler,mpHandler,poolIndexMap);

    return new SnmpCachedData(time,table);
}
 

/**
 * Return a table handler containing the Thread indexes.
 * Indexes are computed from the ThreadId.
 **/
protected SnmpCachedData updateCachedDatas(Object userData) {

    // We are getting all the thread ids. WARNING.
    // Some of them will be not valid when accessed for data...
    // See getEntry
    long[] id = JvmThreadingImpl.getThreadMXBean().getAllThreadIds();


    // Time stamp for the cache
    final long time = System.currentTimeMillis();

    SnmpOid indexes[] = new SnmpOid[id.length];
    final TreeMap<SnmpOid, Object> table =
            new TreeMap<>(SnmpCachedData.oidComparator);
    for(int i = 0; i < id.length; i++) {
        log.debug("", "Making index for thread id [" + id[i] +"]");
        //indexes[i] = makeOid(id[i]);
        SnmpOid oid = makeOid(id[i]);
        table.put(oid, oid);
    }

    return new SnmpCachedData(time, table);
}
 

/**
 * Return a table handler that holds the jvmMemManagerTable table data.
 * This method return the cached table data if it is still
 * valid, recompute it and cache the new value if it's not.
 * If it needs to recompute the cached data, it first
 * try to obtain the list of memory managers from the request
 * contextual cache, and if it is not found, it calls
 * <code>ManagementFactory.getMemoryMBean().getMemoryManagers()</code>
 * and caches the value.
 * This ensures that
 * <code>ManagementFactory.getMemoryMBean().getMemoryManagers()</code>
 * is not called more than once per request, thus ensuring a
 * consistent view of the table.
 **/
protected SnmpCachedData updateCachedDatas(Object userData) {
    // Get the MemoryManager     table
    final SnmpTableHandler mmHandler =
        meta.getManagerHandler(userData);

    // Get the MemoryPool        table
    final SnmpTableHandler mpHandler =
        meta.getPoolHandler(userData);

    // Time stamp for the cache
    final long time = System.currentTimeMillis();

    //     Build a Map poolname -> index
    final Map<String,SnmpOid> poolIndexMap = buildPoolIndexMap(mpHandler);

    // For each memory manager, get the list of memory pools
    // For each memory pool, find its index in the memory pool table
    // Create a row in the relation table.
    final TreeMap<SnmpOid, Object> table =
            new TreeMap<>(SnmpCachedData.oidComparator);
    updateTreeMap(table,userData,mmHandler,mpHandler,poolIndexMap);

    return new SnmpCachedData(time,table);
}
 

/**
 * Return a table handler containing the Thread indexes.
 * Indexes are computed from the ThreadId.
 **/
protected SnmpCachedData updateCachedDatas(Object userData) {

    // We are getting all the thread ids. WARNING.
    // Some of them will be not valid when accessed for data...
    // See getEntry
    long[] id = JvmThreadingImpl.getThreadMXBean().getAllThreadIds();


    // Time stamp for the cache
    final long time = System.currentTimeMillis();

    SnmpOid indexes[] = new SnmpOid[id.length];
    final TreeMap<SnmpOid, Object> table =
            new TreeMap<>(SnmpCachedData.oidComparator);
    for(int i = 0; i < id.length; i++) {
        log.debug("", "Making index for thread id [" + id[i] +"]");
        //indexes[i] = makeOid(id[i]);
        SnmpOid oid = makeOid(id[i]);
        table.put(oid, oid);
    }

    return new SnmpCachedData(time, table);
}
 

/**
 * Return a table handler that holds the jvmMemManagerTable table data.
 * This method return the cached table data if it is still
 * valid, recompute it and cache the new value if it's not.
 * If it needs to recompute the cached data, it first
 * try to obtain the list of memory managers from the request
 * contextual cache, and if it is not found, it calls
 * <code>ManagementFactory.getMemoryMBean().getMemoryManagers()</code>
 * and caches the value.
 * This ensures that
 * <code>ManagementFactory.getMemoryMBean().getMemoryManagers()</code>
 * is not called more than once per request, thus ensuring a
 * consistent view of the table.
 **/
protected SnmpCachedData updateCachedDatas(Object userData) {
    // Get the MemoryManager     table
    final SnmpTableHandler mmHandler =
        meta.getManagerHandler(userData);

    // Get the MemoryPool        table
    final SnmpTableHandler mpHandler =
        meta.getPoolHandler(userData);

    // Time stamp for the cache
    final long time = System.currentTimeMillis();

    //     Build a Map poolname -> index
    final Map<String,SnmpOid> poolIndexMap = buildPoolIndexMap(mpHandler);

    // For each memory manager, get the list of memory pools
    // For each memory pool, find its index in the memory pool table
    // Create a row in the relation table.
    final TreeMap<SnmpOid, Object> table =
            new TreeMap<>(SnmpCachedData.oidComparator);
    updateTreeMap(table,userData,mmHandler,mpHandler,poolIndexMap);

    return new SnmpCachedData(time,table);
}
 

/**
 * Return a table handler containing the Thread indexes.
 * Indexes are computed from the ThreadId.
 **/
protected SnmpCachedData updateCachedDatas(Object userData) {

    // We are getting all the thread ids. WARNING.
    // Some of them will be not valid when accessed for data...
    // See getEntry
    long[] id = JvmThreadingImpl.getThreadMXBean().getAllThreadIds();


    // Time stamp for the cache
    final long time = System.currentTimeMillis();

    SnmpOid indexes[] = new SnmpOid[id.length];
    final TreeMap<SnmpOid, Object> table =
            new TreeMap<>(SnmpCachedData.oidComparator);
    for(int i = 0; i < id.length; i++) {
        log.debug("", "Making index for thread id [" + id[i] +"]");
        //indexes[i] = makeOid(id[i]);
        SnmpOid oid = makeOid(id[i]);
        table.put(oid, oid);
    }

    return new SnmpCachedData(time, table);
}
 

/**
 * Return a table handler that holds the jvmMemManagerTable table data.
 * This method return the cached table data if it is still
 * valid, recompute it and cache the new value if it's not.
 * If it needs to recompute the cached data, it first
 * try to obtain the list of memory managers from the request
 * contextual cache, and if it is not found, it calls
 * <code>ManagementFactory.getMemoryMBean().getMemoryManagers()</code>
 * and caches the value.
 * This ensures that
 * <code>ManagementFactory.getMemoryMBean().getMemoryManagers()</code>
 * is not called more than once per request, thus ensuring a
 * consistent view of the table.
 **/
protected SnmpCachedData updateCachedDatas(Object userData) {
    // Get the MemoryManager     table
    final SnmpTableHandler mmHandler =
        meta.getManagerHandler(userData);

    // Get the MemoryPool        table
    final SnmpTableHandler mpHandler =
        meta.getPoolHandler(userData);

    // Time stamp for the cache
    final long time = System.currentTimeMillis();

    //     Build a Map poolname -> index
    final Map<String,SnmpOid> poolIndexMap = buildPoolIndexMap(mpHandler);

    // For each memory manager, get the list of memory pools
    // For each memory pool, find its index in the memory pool table
    // Create a row in the relation table.
    final TreeMap<SnmpOid, Object> table =
            new TreeMap<>(SnmpCachedData.oidComparator);
    updateTreeMap(table,userData,mmHandler,mpHandler,poolIndexMap);

    return new SnmpCachedData(time,table);
}
 

/**
 * Return a table handler containing the Thread indexes.
 * Indexes are computed from the ThreadId.
 **/
protected SnmpCachedData updateCachedDatas(Object userData) {

    // We are getting all the thread ids. WARNING.
    // Some of them will be not valid when accessed for data...
    // See getEntry
    long[] id = JvmThreadingImpl.getThreadMXBean().getAllThreadIds();


    // Time stamp for the cache
    final long time = System.currentTimeMillis();

    SnmpOid indexes[] = new SnmpOid[id.length];
    final TreeMap<SnmpOid, Object> table =
            new TreeMap<>(SnmpCachedData.oidComparator);
    for(int i = 0; i < id.length; i++) {
        log.debug("", "Making index for thread id [" + id[i] +"]");
        //indexes[i] = makeOid(id[i]);
        SnmpOid oid = makeOid(id[i]);
        table.put(oid, oid);
    }

    return new SnmpCachedData(time, table);
}
 

/**
 * Return a table handler that holds the jvmMemManagerTable table data.
 * This method return the cached table data if it is still
 * valid, recompute it and cache the new value if it's not.
 * If it needs to recompute the cached data, it first
 * try to obtain the list of memory managers from the request
 * contextual cache, and if it is not found, it calls
 * <code>ManagementFactory.getMemoryMBean().getMemoryManagers()</code>
 * and caches the value.
 * This ensures that
 * <code>ManagementFactory.getMemoryMBean().getMemoryManagers()</code>
 * is not called more than once per request, thus ensuring a
 * consistent view of the table.
 **/
protected SnmpCachedData updateCachedDatas(Object userData) {
    // Get the MemoryManager     table
    final SnmpTableHandler mmHandler =
        meta.getManagerHandler(userData);

    // Get the MemoryPool        table
    final SnmpTableHandler mpHandler =
        meta.getPoolHandler(userData);

    // Time stamp for the cache
    final long time = System.currentTimeMillis();

    //     Build a Map poolname -> index
    final Map<String,SnmpOid> poolIndexMap = buildPoolIndexMap(mpHandler);

    // For each memory manager, get the list of memory pools
    // For each memory pool, find its index in the memory pool table
    // Create a row in the relation table.
    final TreeMap<SnmpOid, Object> table =
            new TreeMap<>(SnmpCachedData.oidComparator);
    updateTreeMap(table,userData,mmHandler,mpHandler,poolIndexMap);

    return new SnmpCachedData(time,table);
}
 

/**
 * Return a table handler containing the Thread indexes.
 * Indexes are computed from the ThreadId.
 **/
protected SnmpCachedData updateCachedDatas(Object userData) {

    // We are getting all the thread ids. WARNING.
    // Some of them will be not valid when accessed for data...
    // See getEntry
    long[] id = JvmThreadingImpl.getThreadMXBean().getAllThreadIds();


    // Time stamp for the cache
    final long time = System.currentTimeMillis();

    SnmpOid indexes[] = new SnmpOid[id.length];
    final TreeMap<SnmpOid, Object> table =
            new TreeMap<>(SnmpCachedData.oidComparator);
    for(int i = 0; i < id.length; i++) {
        log.debug("", "Making index for thread id [" + id[i] +"]");
        //indexes[i] = makeOid(id[i]);
        SnmpOid oid = makeOid(id[i]);
        table.put(oid, oid);
    }

    return new SnmpCachedData(time, table);
}
 

/**
 * Return a table handler that holds the jvmMemManagerTable table data.
 * This method return the cached table data if it is still
 * valid, recompute it and cache the new value if it's not.
 * If it needs to recompute the cached data, it first
 * try to obtain the list of memory managers from the request
 * contextual cache, and if it is not found, it calls
 * <code>ManagementFactory.getMemoryMBean().getMemoryManagers()</code>
 * and caches the value.
 * This ensures that
 * <code>ManagementFactory.getMemoryMBean().getMemoryManagers()</code>
 * is not called more than once per request, thus ensuring a
 * consistent view of the table.
 **/
protected SnmpCachedData updateCachedDatas(Object userData) {
    // Get the MemoryManager     table
    final SnmpTableHandler mmHandler =
        meta.getManagerHandler(userData);

    // Get the MemoryPool        table
    final SnmpTableHandler mpHandler =
        meta.getPoolHandler(userData);

    // Time stamp for the cache
    final long time = System.currentTimeMillis();

    //     Build a Map poolname -> index
    final Map<String,SnmpOid> poolIndexMap = buildPoolIndexMap(mpHandler);

    // For each memory manager, get the list of memory pools
    // For each memory pool, find its index in the memory pool table
    // Create a row in the relation table.
    final TreeMap<SnmpOid, Object> table =
            new TreeMap<>(SnmpCachedData.oidComparator);
    updateTreeMap(table,userData,mmHandler,mpHandler,poolIndexMap);

    return new SnmpCachedData(time,table);
}
 

/**
 * Return a table handler containing the Thread indexes.
 * Indexes are computed from the ThreadId.
 **/
protected SnmpCachedData updateCachedDatas(Object userData) {

    // We are getting all the thread ids. WARNING.
    // Some of them will be not valid when accessed for data...
    // See getEntry
    long[] id = JvmThreadingImpl.getThreadMXBean().getAllThreadIds();


    // Time stamp for the cache
    final long time = System.currentTimeMillis();

    SnmpOid indexes[] = new SnmpOid[id.length];
    final TreeMap<SnmpOid, Object> table =
            new TreeMap<>(SnmpCachedData.oidComparator);
    for(int i = 0; i < id.length; i++) {
        log.debug("", "Making index for thread id [" + id[i] +"]");
        //indexes[i] = makeOid(id[i]);
        SnmpOid oid = makeOid(id[i]);
        table.put(oid, oid);
    }

    return new SnmpCachedData(time, table);
}
 

/**
 * Return a table handler that holds the jvmMemManagerTable table data.
 * This method return the cached table data if it is still
 * valid, recompute it and cache the new value if it's not.
 * If it needs to recompute the cached data, it first
 * try to obtain the list of memory managers from the request
 * contextual cache, and if it is not found, it calls
 * <code>ManagementFactory.getMemoryMBean().getMemoryManagers()</code>
 * and caches the value.
 * This ensures that
 * <code>ManagementFactory.getMemoryMBean().getMemoryManagers()</code>
 * is not called more than once per request, thus ensuring a
 * consistent view of the table.
 **/
protected SnmpCachedData updateCachedDatas(Object userData) {
    // Get the MemoryManager     table
    final SnmpTableHandler mmHandler =
        meta.getManagerHandler(userData);

    // Get the MemoryPool        table
    final SnmpTableHandler mpHandler =
        meta.getPoolHandler(userData);

    // Time stamp for the cache
    final long time = System.currentTimeMillis();

    //     Build a Map poolname -> index
    final Map<String,SnmpOid> poolIndexMap = buildPoolIndexMap(mpHandler);

    // For each memory manager, get the list of memory pools
    // For each memory pool, find its index in the memory pool table
    // Create a row in the relation table.
    final TreeMap<SnmpOid, Object> table =
            new TreeMap<>(SnmpCachedData.oidComparator);
    updateTreeMap(table,userData,mmHandler,mpHandler,poolIndexMap);

    return new SnmpCachedData(time,table);
}
 

/**
 * Return a table handler that holds the jvmMemManagerTable table data.
 * This method return the cached table data if it is still
 * valid, recompute it and cache the new value if it's not.
 * If it needs to recompute the cached data, it first
 * try to obtain the list of memory managers from the request
 * contextual cache, and if it is not found, it calls
 * <code>ManagementFactory.getMemoryMBean().getMemoryManagers()</code>
 * and caches the value.
 * This ensures that
 * <code>ManagementFactory.getMemoryMBean().getMemoryManagers()</code>
 * is not called more than once per request, thus ensuring a
 * consistent view of the table.
 **/
protected SnmpCachedData updateCachedDatas(Object userData) {
    // Get the MemoryManager     table
    final SnmpTableHandler mmHandler =
        meta.getManagerHandler(userData);

    // Get the MemoryPool        table
    final SnmpTableHandler mpHandler =
        meta.getPoolHandler(userData);

    // Time stamp for the cache
    final long time = System.currentTimeMillis();

    //     Build a Map poolname -> index
    final Map<String,SnmpOid> poolIndexMap = buildPoolIndexMap(mpHandler);

    // For each memory manager, get the list of memory pools
    // For each memory pool, find its index in the memory pool table
    // Create a row in the relation table.
    final TreeMap<SnmpOid, Object> table =
            new TreeMap<>(SnmpCachedData.oidComparator);
    updateTreeMap(table,userData,mmHandler,mpHandler,poolIndexMap);

    return new SnmpCachedData(time,table);
}
 

/**
 * Return a table handler that holds the jvmMemManagerTable table data.
 * This method return the cached table data if it is still
 * valid, recompute it and cache the new value if it's not.
 * If it needs to recompute the cached data, it first
 * try to obtain the list of memory managers from the request
 * contextual cache, and if it is not found, it calls
 * <code>ManagementFactory.getMemoryMBean().getMemoryManagers()</code>
 * and caches the value.
 * This ensures that
 * <code>ManagementFactory.getMemoryMBean().getMemoryManagers()</code>
 * is not called more than once per request, thus ensuring a
 * consistent view of the table.
 **/
protected SnmpCachedData updateCachedDatas(Object userData) {
    // Get the MemoryManager     table
    final SnmpTableHandler mmHandler =
        meta.getManagerHandler(userData);

    // Get the MemoryPool        table
    final SnmpTableHandler mpHandler =
        meta.getPoolHandler(userData);

    // Time stamp for the cache
    final long time = System.currentTimeMillis();

    //     Build a Map poolname -> index
    final Map<String,SnmpOid> poolIndexMap = buildPoolIndexMap(mpHandler);

    // For each memory manager, get the list of memory pools
    // For each memory pool, find its index in the memory pool table
    // Create a row in the relation table.
    final TreeMap<SnmpOid, Object> table =
            new TreeMap<>(SnmpCachedData.oidComparator);
    updateTreeMap(table,userData,mmHandler,mpHandler,poolIndexMap);

    return new SnmpCachedData(time,table);
}
 

/**
 * Return a table handler containing the Thread indexes.
 * Indexes are computed from the ThreadId.
 **/
protected SnmpCachedData updateCachedDatas(Object userData) {

    // We are getting all the thread ids. WARNING.
    // Some of them will be not valid when accessed for data...
    // See getEntry
    long[] id = JvmThreadingImpl.getThreadMXBean().getAllThreadIds();


    // Time stamp for the cache
    final long time = System.currentTimeMillis();

    SnmpOid indexes[] = new SnmpOid[id.length];
    final TreeMap<SnmpOid, Object> table =
            new TreeMap<>(SnmpCachedData.oidComparator);
    for(int i = 0; i < id.length; i++) {
        log.debug("", "Making index for thread id [" + id[i] +"]");
        //indexes[i] = makeOid(id[i]);
        SnmpOid oid = makeOid(id[i]);
        table.put(oid, oid);
    }

    return new SnmpCachedData(time, table);
}
 

/**
 * Return a table handler that holds the jvmMemManagerTable table data.
 * This method return the cached table data if it is still
 * valid, recompute it and cache the new value if it's not.
 * If it needs to recompute the cached data, it first
 * try to obtain the list of memory managers from the request
 * contextual cache, and if it is not found, it calls
 * <code>ManagementFactory.getMemoryMBean().getMemoryManagers()</code>
 * and caches the value.
 * This ensures that
 * <code>ManagementFactory.getMemoryMBean().getMemoryManagers()</code>
 * is not called more than once per request, thus ensuring a
 * consistent view of the table.
 **/
protected SnmpCachedData updateCachedDatas(Object userData) {
    // Get the MemoryManager     table
    final SnmpTableHandler mmHandler =
        meta.getManagerHandler(userData);

    // Get the MemoryPool        table
    final SnmpTableHandler mpHandler =
        meta.getPoolHandler(userData);

    // Time stamp for the cache
    final long time = System.currentTimeMillis();

    //     Build a Map poolname -> index
    final Map<String,SnmpOid> poolIndexMap = buildPoolIndexMap(mpHandler);

    // For each memory manager, get the list of memory pools
    // For each memory pool, find its index in the memory pool table
    // Create a row in the relation table.
    final TreeMap<SnmpOid, Object> table =
            new TreeMap<>(SnmpCachedData.oidComparator);
    updateTreeMap(table,userData,mmHandler,mpHandler,poolIndexMap);

    return new SnmpCachedData(time,table);
}