Java Code Examples for sun.util.logging.PlatformLogger#warning()

/**
 * Initialization of the maps from id and type to Chronology.
 * The ServiceLoader is used to find and register any implementations
 * of {@link java.time.chrono.AbstractChronology} found in the bootclass loader.
 * The built-in chronologies are registered explicitly.
 * Calendars configured via the Thread's context classloader are local
 * to that thread and are ignored.
 * <p>
 * The initialization is done only once using the registration
 * of the IsoChronology as the test and the final step.
 * Multiple threads may perform the initialization concurrently.
 * Only the first registration of each Chronology is retained by the
 * ConcurrentHashMap.
 * @return true if the cache was initialized
 */
private static boolean initCache() {
    if (CHRONOS_BY_ID.get("ISO") == null) {
        // Initialization is incomplete

        // Register built-in Chronologies
        /* /* J2ObjC removed: Only "gregorian" and "julian" calendars are supported.
        registerChrono(HijrahChronology.INSTANCE);
        registerChrono(JapaneseChronology.INSTANCE);
        registerChrono(MinguoChronology.INSTANCE);
        registerChrono(ThaiBuddhistChronology.INSTANCE); */

        // Register Chronologies from the ServiceLoader
        @SuppressWarnings("rawtypes")
        ServiceLoader<AbstractChronology> loader =  ServiceLoader.load(AbstractChronology.class, null);
        for (AbstractChronology chrono : loader) {
            String id = chrono.getId();
            if (id.equals("ISO") || registerChrono(chrono) != null) {
                // Log the attempt to replace an existing Chronology
                PlatformLogger logger = PlatformLogger.getLogger("java.time.chrono");
                logger.warning("Ignoring duplicate Chronology, from ServiceLoader configuration "  + id);
            }
        }

        // finally, register IsoChronology to mark initialization is complete
        registerChrono(IsoChronology.INSTANCE);
        return true;
    }
    return false;
}
 

private static void testLogMethods(PlatformLogger logger) {
    logger.severe("Test severe(String, Object...) {0} {1}", new Long(1), "string");
    // test Object[]
    logger.severe("Test severe(String, Object...) {0}", (Object[]) getPoints());
    logger.warning("Test warning(String, Throwable)", new Throwable("Testing"));
    logger.info("Test info(String)");
}
 

/**
 * Initialization of the maps from id and type to Chronology.
 * The ServiceLoader is used to find and register any implementations
 * of {@link java.time.chrono.AbstractChronology} found in the bootclass loader.
 * The built-in chronologies are registered explicitly.
 * Calendars configured via the Thread's context classloader are local
 * to that thread and are ignored.
 * <p>
 * The initialization is done only once using the registration
 * of the IsoChronology as the test and the final step.
 * Multiple threads may perform the initialization concurrently.
 * Only the first registration of each Chronology is retained by the
 * ConcurrentHashMap.
 * @return true if the cache was initialized
 */
private static boolean initCache() {
    if (CHRONOS_BY_ID.get("ISO") == null) {
        // Initialization is incomplete

        // Register built-in Chronologies
        registerChrono(HijrahChronology.INSTANCE);
        registerChrono(JapaneseChronology.INSTANCE);
        registerChrono(MinguoChronology.INSTANCE);
        registerChrono(ThaiBuddhistChronology.INSTANCE);

        // Register Chronologies from the ServiceLoader
        @SuppressWarnings("rawtypes")
        ServiceLoader<AbstractChronology> loader =  ServiceLoader.load(AbstractChronology.class, null);
        for (AbstractChronology chrono : loader) {
            String id = chrono.getId();
            if (id.equals("ISO") || registerChrono(chrono) != null) {
                // Log the attempt to replace an existing Chronology
                PlatformLogger logger = PlatformLogger.getLogger("java.time.chrono");
                logger.warning("Ignoring duplicate Chronology, from ServiceLoader configuration "  + id);
            }
        }

        // finally, register IsoChronology to mark initialization is complete
        registerChrono(IsoChronology.INSTANCE);
        return true;
    }
    return false;
}
 

/**
 * Initialization of the maps from id and type to Chronology.
 * The ServiceLoader is used to find and register any implementations
 * of {@link java.time.chrono.AbstractChronology} found in the bootclass loader.
 * The built-in chronologies are registered explicitly.
 * Calendars configured via the Thread's context classloader are local
 * to that thread and are ignored.
 * <p>
 * The initialization is done only once using the registration
 * of the IsoChronology as the test and the final step.
 * Multiple threads may perform the initialization concurrently.
 * Only the first registration of each Chronology is retained by the
 * ConcurrentHashMap.
 * @return true if the cache was initialized
 */
private static boolean initCache() {
    if (CHRONOS_BY_ID.get("ISO") == null) {
        // Initialization is incomplete

        // Register built-in Chronologies
        registerChrono(HijrahChronology.INSTANCE);
        registerChrono(JapaneseChronology.INSTANCE);
        registerChrono(MinguoChronology.INSTANCE);
        registerChrono(ThaiBuddhistChronology.INSTANCE);

        // Register Chronologies from the ServiceLoader
        @SuppressWarnings("rawtypes")
        ServiceLoader<AbstractChronology> loader =  ServiceLoader.load(AbstractChronology.class, null);
        for (AbstractChronology chrono : loader) {
            String id = chrono.getId();
            if (id.equals("ISO") || registerChrono(chrono) != null) {
                // Log the attempt to replace an existing Chronology
                PlatformLogger logger = PlatformLogger.getLogger("java.time.chrono");
                logger.warning("Ignoring duplicate Chronology, from ServiceLoader configuration "  + id);
            }
        }

        // finally, register IsoChronology to mark initialization is complete
        registerChrono(IsoChronology.INSTANCE);
        return true;
    }
    return false;
}
 

private static void testLogMethods(PlatformLogger logger) {
    logger.severe("Test severe(String, Object...) {0} {1}", new Long(1), "string");
    // test Object[]
    logger.severe("Test severe(String, Object...) {0}", (Object[]) getPoints());
    logger.warning("Test warning(String, Throwable)", new Throwable("Testing"));
    logger.info("Test info(String)");
}
 

/**
 * Initialization of the maps from id and type to Chronology.
 * The ServiceLoader is used to find and register any implementations
 * of {@link java.time.chrono.AbstractChronology} found in the bootclass loader.
 * The built-in chronologies are registered explicitly.
 * Calendars configured via the Thread's context classloader are local
 * to that thread and are ignored.
 * <p>
 * The initialization is done only once using the registration
 * of the IsoChronology as the test and the final step.
 * Multiple threads may perform the initialization concurrently.
 * Only the first registration of each Chronology is retained by the
 * ConcurrentHashMap.
 * @return true if the cache was initialized
 */
private static boolean initCache() {
    if (CHRONOS_BY_ID.get("ISO") == null) {
        // Initialization is incomplete

        // Register built-in Chronologies
        registerChrono(HijrahChronology.INSTANCE);
        registerChrono(JapaneseChronology.INSTANCE);
        registerChrono(MinguoChronology.INSTANCE);
        registerChrono(ThaiBuddhistChronology.INSTANCE);

        // Register Chronologies from the ServiceLoader
        @SuppressWarnings("rawtypes")
        ServiceLoader<AbstractChronology> loader =  ServiceLoader.load(AbstractChronology.class, null);
        for (AbstractChronology chrono : loader) {
            String id = chrono.getId();
            if (id.equals("ISO") || registerChrono(chrono) != null) {
                // Log the attempt to replace an existing Chronology
                PlatformLogger logger = PlatformLogger.getLogger("java.time.chrono");
                logger.warning("Ignoring duplicate Chronology, from ServiceLoader configuration "  + id);
            }
        }

        // finally, register IsoChronology to mark initialization is complete
        registerChrono(IsoChronology.INSTANCE);
        return true;
    }
    return false;
}
 

private static void testLogMethods(PlatformLogger logger) {
    logger.severe("Test severe(String, Object...) {0} {1}", new Long(1), "string");
    // test Object[]
    logger.severe("Test severe(String, Object...) {0}", (Object[]) getPoints());
    logger.warning("Test warning(String, Throwable)", new Throwable("Testing"));
    logger.info("Test info(String)");
}
 

/**
 * Initialization of the maps from id and type to Chronology.
 * The ServiceLoader is used to find and register any implementations
 * of {@link java.time.chrono.AbstractChronology} found in the bootclass loader.
 * The built-in chronologies are registered explicitly.
 * Calendars configured via the Thread's context classloader are local
 * to that thread and are ignored.
 * <p>
 * The initialization is done only once using the registration
 * of the IsoChronology as the test and the final step.
 * Multiple threads may perform the initialization concurrently.
 * Only the first registration of each Chronology is retained by the
 * ConcurrentHashMap.
 * @return true if the cache was initialized
 */
private static boolean initCache() {
    if (CHRONOS_BY_ID.get("ISO") == null) {
        // Initialization is incomplete

        // Register built-in Chronologies
        registerChrono(HijrahChronology.INSTANCE);
        registerChrono(JapaneseChronology.INSTANCE);
        registerChrono(MinguoChronology.INSTANCE);
        registerChrono(ThaiBuddhistChronology.INSTANCE);

        // Register Chronologies from the ServiceLoader
        @SuppressWarnings("rawtypes")
        ServiceLoader<AbstractChronology> loader =  ServiceLoader.load(AbstractChronology.class, null);
        for (AbstractChronology chrono : loader) {
            String id = chrono.getId();
            if (id.equals("ISO") || registerChrono(chrono) != null) {
                // Log the attempt to replace an existing Chronology
                PlatformLogger logger = PlatformLogger.getLogger("java.time.chrono");
                logger.warning("Ignoring duplicate Chronology, from ServiceLoader configuration "  + id);
            }
        }

        // finally, register IsoChronology to mark initialization is complete
        registerChrono(IsoChronology.INSTANCE);
        return true;
    }
    return false;
}
 

/**
 * Initialization of the maps from id and type to Chronology.
 * The ServiceLoader is used to find and register any implementations
 * of {@link java.time.chrono.AbstractChronology} found in the bootclass loader.
 * The built-in chronologies are registered explicitly.
 * Calendars configured via the Thread's context classloader are local
 * to that thread and are ignored.
 * <p>
 * The initialization is done only once using the registration
 * of the IsoChronology as the test and the final step.
 * Multiple threads may perform the initialization concurrently.
 * Only the first registration of each Chronology is retained by the
 * ConcurrentHashMap.
 * @return true if the cache was initialized
 */
private static boolean initCache() {
    if (CHRONOS_BY_ID.get("ISO") == null) {
        // Initialization is incomplete

        // Register built-in Chronologies
        registerChrono(HijrahChronology.INSTANCE);
        registerChrono(JapaneseChronology.INSTANCE);
        registerChrono(MinguoChronology.INSTANCE);
        registerChrono(ThaiBuddhistChronology.INSTANCE);

        // Register Chronologies from the ServiceLoader
        @SuppressWarnings("rawtypes")
        ServiceLoader<AbstractChronology> loader =  ServiceLoader.load(AbstractChronology.class, null);
        for (AbstractChronology chrono : loader) {
            String id = chrono.getId();
            if (id.equals("ISO") || registerChrono(chrono) != null) {
                // Log the attempt to replace an existing Chronology
                PlatformLogger logger = PlatformLogger.getLogger("java.time.chrono");
                logger.warning("Ignoring duplicate Chronology, from ServiceLoader configuration "  + id);
            }
        }

        // finally, register IsoChronology to mark initialization is complete
        registerChrono(IsoChronology.INSTANCE);
        return true;
    }
    return false;
}
 

/**
 * Initialization of the maps from id and type to Chronology.
 * The ServiceLoader is used to find and register any implementations
 * of {@link java.time.chrono.AbstractChronology} found in the bootclass loader.
 * The built-in chronologies are registered explicitly.
 * Calendars configured via the Thread's context classloader are local
 * to that thread and are ignored.
 * <p>
 * The initialization is done only once using the registration
 * of the IsoChronology as the test and the final step.
 * Multiple threads may perform the initialization concurrently.
 * Only the first registration of each Chronology is retained by the
 * ConcurrentHashMap.
 * @return true if the cache was initialized
 */
private static boolean initCache() {
    if (CHRONOS_BY_ID.get("ISO") == null) {
        // Initialization is incomplete

        // Register built-in Chronologies
        registerChrono(HijrahChronology.INSTANCE);
        registerChrono(JapaneseChronology.INSTANCE);
        registerChrono(MinguoChronology.INSTANCE);
        registerChrono(ThaiBuddhistChronology.INSTANCE);

        // Register Chronologies from the ServiceLoader
        @SuppressWarnings("rawtypes")
        ServiceLoader<AbstractChronology> loader =  ServiceLoader.load(AbstractChronology.class, null);
        for (AbstractChronology chrono : loader) {
            String id = chrono.getId();
            if (id.equals("ISO") || registerChrono(chrono) != null) {
                // Log the attempt to replace an existing Chronology
                PlatformLogger logger = PlatformLogger.getLogger("java.time.chrono");
                logger.warning("Ignoring duplicate Chronology, from ServiceLoader configuration "  + id);
            }
        }

        // finally, register IsoChronology to mark initialization is complete
        registerChrono(IsoChronology.INSTANCE);
        return true;
    }
    return false;
}
 

/**
 * Initialization of the maps from id and type to Chronology.
 * The ServiceLoader is used to find and register any implementations
 * of {@link java.time.chrono.AbstractChronology} found in the bootclass loader.
 * The built-in chronologies are registered explicitly.
 * Calendars configured via the Thread's context classloader are local
 * to that thread and are ignored.
 * <p>
 * The initialization is done only once using the registration
 * of the IsoChronology as the test and the final step.
 * Multiple threads may perform the initialization concurrently.
 * Only the first registration of each Chronology is retained by the
 * ConcurrentHashMap.
 * @return true if the cache was initialized
 */
private static boolean initCache() {
    if (CHRONOS_BY_ID.get("ISO") == null) {
        // Initialization is incomplete

        // Register built-in Chronologies
        registerChrono(HijrahChronology.INSTANCE);
        registerChrono(JapaneseChronology.INSTANCE);
        registerChrono(MinguoChronology.INSTANCE);
        registerChrono(ThaiBuddhistChronology.INSTANCE);

        // Register Chronologies from the ServiceLoader
        @SuppressWarnings("rawtypes")
        ServiceLoader<AbstractChronology> loader =  ServiceLoader.load(AbstractChronology.class, null);
        for (AbstractChronology chrono : loader) {
            String id = chrono.getId();
            if (id.equals("ISO") || registerChrono(chrono) != null) {
                // Log the attempt to replace an existing Chronology
                PlatformLogger logger = PlatformLogger.getLogger("java.time.chrono");
                logger.warning("Ignoring duplicate Chronology, from ServiceLoader configuration "  + id);
            }
        }

        // finally, register IsoChronology to mark initialization is complete
        registerChrono(IsoChronology.INSTANCE);
        return true;
    }
    return false;
}
 

/**
 * Initialization of the maps from id and type to Chronology.
 * The ServiceLoader is used to find and register any implementations
 * of {@link java.time.chrono.AbstractChronology} found in the bootclass loader.
 * The built-in chronologies are registered explicitly.
 * Calendars configured via the Thread's context classloader are local
 * to that thread and are ignored.
 * <p>
 * The initialization is done only once using the registration
 * of the IsoChronology as the test and the final step.
 * Multiple threads may perform the initialization concurrently.
 * Only the first registration of each Chronology is retained by the
 * ConcurrentHashMap.
 * @return true if the cache was initialized
 */
private static boolean initCache() {
    if (CHRONOS_BY_ID.get("ISO") == null) {
        // Initialization is incomplete

        // Register built-in Chronologies
        registerChrono(HijrahChronology.INSTANCE);
        registerChrono(JapaneseChronology.INSTANCE);
        registerChrono(MinguoChronology.INSTANCE);
        registerChrono(ThaiBuddhistChronology.INSTANCE);

        // Register Chronologies from the ServiceLoader
        @SuppressWarnings("rawtypes")
        ServiceLoader<AbstractChronology> loader =  ServiceLoader.load(AbstractChronology.class, null);
        for (AbstractChronology chrono : loader) {
            String id = chrono.getId();
            if (id.equals("ISO") || registerChrono(chrono) != null) {
                // Log the attempt to replace an existing Chronology
                PlatformLogger logger = PlatformLogger.getLogger("java.time.chrono");
                logger.warning("Ignoring duplicate Chronology, from ServiceLoader configuration "  + id);
            }
        }

        // finally, register IsoChronology to mark initialization is complete
        registerChrono(IsoChronology.INSTANCE);
        return true;
    }
    return false;
}
 

private static void testLogMethods(PlatformLogger logger) {
    logger.severe("Test severe(String, Object...) {0} {1}", new Long(1), "string");
    // test Object[]
    logger.severe("Test severe(String, Object...) {0}", (Object[]) getPoints());
    logger.warning("Test warning(String, Throwable)", new Throwable("Testing"));
    logger.info("Test info(String)");
}
 

private static void testLogMethods(PlatformLogger logger) {
    logger.severe("Test severe(String, Object...) {0} {1}", new Long(1), "string");
    // test Object[]
    logger.severe("Test severe(String, Object...) {0}", (Object[]) getPoints());
    logger.warning("Test warning(String, Throwable)", new Throwable("Testing"));
    logger.info("Test info(String)");
}
 

private static void warning(String msg) {
    PlatformLogger logger = PlatformLogger.getLogger("sun.awt.FontConfiguration");
    logger.warning(msg);
}
 

private static void warning(String msg) {
    PlatformLogger logger = PlatformLogger.getLogger("sun.awt.FontConfiguration");
    logger.warning(msg);
}
 

private static void warning(String msg) {
    PlatformLogger logger = PlatformLogger.getLogger("sun.awt.FontConfiguration");
    logger.warning(msg);
}
 

private static void warning(String msg) {
    PlatformLogger logger = PlatformLogger.getLogger("sun.awt.FontConfiguration");
    logger.warning(msg);
}
 

private static void warning(String msg) {
    PlatformLogger logger = PlatformLogger.getLogger("sun.awt.FontConfiguration");
    logger.warning(msg);
}
 

private static void warning(String msg) {
    PlatformLogger logger = PlatformLogger.getLogger("sun.awt.FontConfiguration");
    logger.warning(msg);
}