/*
 * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
 * Copyright (c) 2017, 2021 IBM Corporation. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0,
 * or the Eclipse Distribution License v. 1.0 which is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
 */

// Contributors:
//     Oracle - initial API and implementation from Oracle TopLink
//     09/13/2013-2.5 Guy Pelletier
//       - 350487: JPA 2.1 Specification defined support for Stored Procedure Calls
//     11/07/2017 - Dalia Abo Sheasha
//       - 526957 : Split the logging and trace messages
//     05/11/2020-2.7.0 Jody Grassel
//       - 538296: Wrong month is returned if OffsetDateTime is used in JPA 2.2 code
package org.eclipse.persistence.internal.localization.i18n;

import java.util.ListResourceBundle;

/**
 * English ResourceBundle for TraceLocalization messages.  Traces are only localized.  They do not get translated.
 * These logs are picked up by AbstractSessionLog.getLog().log() when the level is below CONFIG=4 (FINE, FINER, FINEST, ALL)
 * @author Shannon Chen
 * @since OracleAS TopLink 10<i>g</i> (9.0.4)
 */
public class TraceLocalizationResource extends ListResourceBundle {
    static final Object[][] contents = {
        // FINEST, FINER and FINE level messages.
        { "login_successful", "{0} login successful" },
        { "logout_successful", "{0} logout successful" },
        { "acquire_unit_of_work_with_argument", "acquire unit of work: {0}" },
        { "external_transaction_has_begun_internally", "external transaction has begun internally" },
        { "external_transaction_has_committed_internally", "external transaction has committed internally" },
        { "initialize_all_identitymaps", "initialize all identitymaps" },
        { "initialize_identitymap", "initialize identitymap: {0}" },
        { "initialize_identitymaps", "initialize identitymaps" },
        { "external_transaction_has_rolled_back_internally", "external transaction has rolled back internally" },
        { "validate_cache", "validate cache." },
        { "cache_item_creation", "Entity ({0}) with Id ({1}) was stored in the cache by thread (Id: {2} Name: {3})" },
        { "cache_item_refresh", "Entity ({0}) with Id ({1}) was refreshed in the cache by thread (Id: {2} Name: {3})" },
        { "cache_item_removal", "Entity ({0}) with Id ({1}) was removed from the cache by thread (Id: {2} Name: {3})" },
        { "cache_item_invalidation", "Entity ({0}) with Id ({1}) was invalidated from the cache by thread (Id: {2} Name: {3})" },
        { "cache_class_invalidation", "Entities based on class ({0}) was invalidated from the cache by thread (Id: {1} Name: {2})" },
        { "cache_hit", "Cache hit for entity ({0}) with Id ({1})" },
        { "cache_miss", "Cache miss for entity ({0}) with Id ({1})" },
        { "stack_of_visited_objects_that_refer_to_the_corrupt_object", "stack of visited objects that refer to the corrupt object: {0}" },
        { "corrupt_object_referenced_through_mapping", "corrupt object referenced through mapping: {0}" },
        { "corrupt_object", "corrupt object: {0}" },
        { "begin_unit_of_work_flush", "begin unit of work flush" },
        { "end_unit_of_work_flush", "end unit of work flush" },
        { "begin_unit_of_work_commit", "begin unit of work commit" },
        { "end_unit_of_work_commit", "end unit of work commit" },
        { "resume_unit_of_work", "resume unit of work" },
        { "resuming_unit_of_work_from_failure", "resuming unit of work from failure" },
        { "release_unit_of_work", "release unit of work" },
        { "revert_unit_of_work", "revert unit of work" },
        { "validate_object_space", "validate object space." },
        { "execute_query", "Execute query {0}" },
        { "merge_clone", "Merge clone {0} " },
        { "merge_clone_with_references", "Merge clone with references {0}" },
        { "new_instance", "New instance {0}" },
        { "register_existing", "Register the existing object {0}" },
        { "register_new", "Register the new object {0}" },
        { "register_new_bean", "Register the new bean {0}" },
        { "register", "Register the object {0}" },
        { "revert", "Revert the object''s attributes {0}" },
        { "unregister", "Unregister the object {0}" },
        { "begin_batch_statements", "Begin batch statements" },
        { "end_batch_statements", "End Batch Statements" },
        { "query_column_meta_data_with_column", "query column meta data ({0}.{1}.{2}.{3})" },
        { "query_column_meta_data", "query table meta data ({0}.{1}.{2})" },
        { "reconnecting_to_external_connection_pool", "reconnecting to external connection pool" },
        { "connecting", "connecting({0})" },
        { "disconnect", "disconnect" },
        { "reconnecting", "reconnecting({0})" },
        { "begin_transaction", "begin transaction" },
        { "commit_transaction", "commit transaction" },
        { "rollback_transaction", "rollback transaction" },
        { "adapter_result", "Adapter result: {0}" },
        { "data_access_result", "Data access result: {0}" },
        { "acquire_unit_of_work", "acquire unit of work" },
        { "JTS_register", "JTS register" },
        { "JTS_after_completion", "After JTS Completion" },
        { "JTS_before_completion", "Before JTS Completion" },
        { "JTS_begin", "Begin JTS transaction" },
        { "JTS_commit_with_argument", "JTS#commit({0})" },
        { "JTS_rollback", "Rollback JTS transaction." },
        { "JTS_commit", "Commit JTS transaction." },
        { "JTS_after_completion_with_argument", "After JTS Completion ({0})" },
        { "TX_beforeCompletion", "TX beforeCompletion callback, status={0}" },
        { "TX_afterCompletion", "TX afterCompletion callback, status={0}" },
        { "TX_bind", "TX binding to tx mgr, status={0}" },
        { "TX_begin", "TX beginTransaction, status={0}" },
        { "TX_beginningTxn", "TX Internally starting" },
        { "TX_commit", "TX commitTransaction, status={0}" },
        { "TX_committingTxn", "TX Internally committing" },
        { "TX_rollback", "TX rollbackTransaction, status={0}" },
        { "TX_rollingBackTxn", "TX Internally rolling back" },
        { "lock_writer_header", "Current object locks:" },
        { "lock_writer_footer", "End of locked objects." },
        { "active_thread", "Thread : {0}" },
        { "locked_object", "Locked Object : {0}" },
        { "depth", "Depth : {0}" },
        { "cachekey_released", "This thread is no longer holding the lock.  It must not be a blocking thread."},
        { "cache_thread_info", "Cached entity ({0}) with Id ({1}) was prepared and stored into cache by another thread (id: {2} name: {3}), than current thread (id: {4} name: {5})" },
        { "deferred_locks", "Deferred lock on : {0}" },
        { "deferred_locks_released", "All deferred locks for thread \"{0}\" have been released." },
        { "acquiring_deferred_lock", "Thread \"{1}\" has acquired a deferred lock on object : {0} in order to avoid deadlock." },
        { "dead_lock_encountered_on_write", "Thread \"{1}\" encountered deadlock when attempting to lock : {0}.  Entering deadlock avoidance algorithm." },
        { "dead_lock_encountered_on_write_no_cache_key", "Thread \"{2}\" encountered deadlock when attempting to lock object of class: {0} with PK {1}.  Entering deadlock avoidance algorithm." },
        { "concurrency_manager_release_locks_acquired_by_thread_1", "releaseAllLocksAcquiredByThread: Thread \"{0}\"  .The Lock manager is null. This might be an acquire operation. So not possible to lockManager.releaseActiveLocksOnThread(). Cache Key:  \"{1}\"" },
        { "concurrency_manager_release_locks_acquired_by_thread_2", "releaseAllLocksAcquiredByThread: Release active locks on Thread \"{0}\"" },
        { "concurrency_manager_build_object_thread_complete_1", "isBuildObjectComplete ExpandedThread NR  {0}: {1} \n" },
        { "concurrency_manager_build_object_thread_complete_2", "\nAll threads in this stack are doing object building and needed to defer on one or more cache keys.\n"
                + "The last thread has deferred lock on ac cache key that is acquired by thread that is not yet finished with its work. \n\n"},
        { "concurrency_manager_build_object_thread_complete_3", "finalDeferredLockCausingTrouble:  {0} \n"
                + " This cache key had to be deferred by the last thread on the recursive stack. The thread was ACQUIRED. \n"},
        { "concurrency_manager_build_object_thread_complete_4", "activeThreadOnTheCacheKey: {0}  \n"
                + " hasDeferredLockManager: {1} \n "
                + " This is the thread that has acquired the cache key and has been considered to not yet be finished with its business. \n"
                + " When hasDeferredLockManager is true it typically means this thread is doing object building. \n"
                + " When hasDeferredLockManager is false it might an object building thread or it could be a thread doing a commit and acquiring final locks to merge its objects with changesets look at the stack trace to understand. \n"},
        { "concurrency_manager_allow_concurrency_exception_fired_up", "allowConcurrencyExceptionToBeFiredUp: is set to FALSE."
                + " No any exception be fired to avoid the risk of aborting the current thread not being sufficient to resolve any dead lock."
                + " and leaving the system in a worth shape where aver 3 retries the business transaction is not re-attempted and the recovery of the system becomes complicated. "
                + " We are going with the option of letting the system freeze. " },
        { "concurrency_util_stuck_thread_tiny_log_cache_key", "Stuck thread problem: unique tiny message number ({0}) \n"
                + " The Thread [{1}]  appears to be stuck (possible dead lock ongoing). \n"
                + " The thread is working in the context of (CacheKey) = ({2}) . \n"
                + " The thread has been stuck for: ({3} ms) \n "
                + " Bellow we will describe the ActiveLocks, DeferredLocks and ReadLocks for this thread. " },
        { "concurrency_util_owned_cache_key_null", "ObjectNull. Most likely not yet in server session cache and in the process of being created."},
        { "concurrency_util_owned_cache_key_is_cache_key", "--- CacheKey  ({0}):  (primaryKey: {1}) (object hash code: {2}) (cacheKeyClass: {3}) (cacheKey hash code: {4}) (current cache key owner/activeThread: {5}) (getNumberOfReaders: {6}) "
                + " (concurrencyManagerId: {7}) (concurrencyManagerCreationDate: {8})"
                + "  (totalNumberOfTimeCacheKeyAcquiredForReading:  {9}) "
                + " (totalNumberOfTimeCacheKeyReleasedForReading:  {10}) "
                + " (totalNumberOfTimeCacheKeyReleasedForReadingBlewUpExceptionDueToCacheKeyHavingReachedCounterZero:  {11})  "
                + "(depth: {12}) ---"},
        { "concurrency_util_owned_cache_key_is_not_cache_key", "--- ConcurrencyManager: (ConcurrencyManagerClass: {0} ) (ConcurrencyManagerToString: {1}) (current cache key owner/activeThread: {2}) (concurrencyManagerId: {3}) (concurrencyManagerCreationDate: {4}) "
                + "  (totalNumberOfTimeCacheKeyAcquiredForReading:  {5}) "
                + " (totalNumberOfTimeCacheKeyReleasedForReading:  {6}) "
                + " (totalNumberOfTimeCacheKeyReleasedForReadingBlewUpExceptionDueToCacheKeyHavingReachedCounterZero:  {7}) "
                + "(depth: {8}) ---"},
        { "concurrency_util_header_current_cache_key", "Summary current cache key of thread {0} "},
        { "concurrency_util_header_active_locks_owned_by_thread", "Summary of active locks owned by thread {0} "},
        { "concurrency_util_header_deferred_locks_owned_by_thread", "Summary of deferred locks (could not be acquired and cause thread to wait for object building to complete) of thread {0} "},
        { "concurrency_util_header_reader_locks_owned_by_thread", "Summary of read locks acquired by thread {0} "},
        { "concurrency_util_summary_active_locks_on_thread_1", "Listing of all ACTIVE Locks.\n"
                + "Thread Name: {0} \n"},
        { "concurrency_util_summary_active_locks_on_thread_2", "0 Active locks. The lockManager for this thread is null. \n\n"},
        { "concurrency_util_summary_active_locks_on_thread_3", "{0} Active locks.\n"},
        { "concurrency_util_summary_active_locks_on_thread_4", "Active lock nr: {0} , Active cache key: {1}\n\n"},
        { "concurrency_util_summary_deferred_locks_on_thread_1", "Listing of all DEFERRED Locks.\n"
                + "Thread Name: {0} \n"},
        { "concurrency_util_summary_deferred_locks_on_thread_2", "0 deferred locks. The lockManager for this thread is null. \n\n"},
        { "concurrency_util_summary_deferred_locks_on_thread_3", "{0} Deferred locks.\n"},
        { "concurrency_util_summary_deferred_locks_on_thread_4", "Deferred lock nr: {0} , Deferred cache key: {1}\n\n"},
        { "concurrency_util_summary_read_locks_on_thread_step001_1", "Listing of all READ Locks. Step 001 - sparse summary loop over all read locks acquired:\n"
                 + "Thread Name: {0} \n"},
        { "concurrency_util_summary_read_locks_on_thread_step001_2", "0 read locks. The lockManager for this thread is null. \n\n"},
        { "concurrency_util_summary_read_locks_on_thread_step001_3", "{0} Read locks.\n"},
        { "concurrency_util_summary_read_locks_on_thread_step001_4", "Read lock nr: {0} , Read cache key: {1}\n\n"},
        { "concurrency_util_summary_read_locks_on_thread_step002_1", "\nListing of all READ Locks. Step 002 - fat-detailed information about all read locks acquired:"},
        { "concurrency_util_summary_read_locks_on_thread_step002_2", "Read locks acquired by thread: {0} with id: {1} never released.\n"
                + "number of never released read locks: {2}"},
        { "concurrency_util_summary_read_locks_on_thread_step002_3", "\nRead lock nr: {0} Read lock Cache Key: {1}"
                + "\nRead lock nr: {0} dateOfReadLockAcquisition: {2}"
                + "\nRead lock nr: {0} numberOfReadersOnCacheKeyBeforeIncrementingByOne: {3}"
                + "\nRead lock nr: {0} currentThreadStackTraceInformationCpuTimeCostMs: {4}"},
        { "concurrency_util_summary_read_locks_on_thread_step002_4", "\nRead lock nr: {0}  stackTraceInformation:  same as stack trace id: {1}"},
        { "concurrency_util_summary_read_locks_on_thread_step002_5", "\nRead lock nr: {0} Stack trace id: {1} Start"
                + "\nRead lock nr: {0} stackTraceInformation: {2}"
                + "\nRead lock nr: {0} Stack trace id: {1} End"},
        { "concurrency_util_summary_read_locks_on_thread_step002_6", "Read locks problems detected by thread: {0} during release read locks"
                + "\n{1} removeReadLockProblemsDetected."},
        { "concurrency_util_summary_read_locks_on_thread_step002_7", "\nRelease read lock problem nr: {0} \n   {1}"},
        { "concurrency_util_enrich_thread_dump", "enrichGenerateThreadDump: Failed to generate thread dump with error: {0} "},
        { "concurrency_util_enrich_thread_dump_thread_info_1", "\"{0}\" "
                + "\n   java.lang.Thread.State: {1}"},
        { "concurrency_util_enrich_thread_dump_thread_info_2", "\n        at {0}"},
        { "concurrency_util_create_information_thread_dump", "Concurrency manager - Page 01 start - thread dump about all threads at time of event\n {0}"
                + "\nConcurrency manager - Page 01 end - thread dump about all threads at time of event\n"},
        { "concurrency_util_create_information_all_threads_acquire_cache_keys_1", "Concurrency manager - Page 02 start - information about threads waiting to acquire (write/deferred) cache keys "
                + "\nTotal number of threads waiting to acquire lock: {0}\n\n"},
        { "concurrency_util_create_information_all_threads_acquire_cache_keys_2", "[currentThreadNumber: {0}] [ThreadName: {1}]: Waiting to acquire (write/deferred): {2}\n"},
        { "concurrency_util_create_information_all_threads_acquire_cache_keys_3", "It seems, that trace was produced by the THREADS_TO_FAIL_TO_ACQUIRE_CACHE_KEYS - - org.eclipse.persistence.internal.helper.WriteLockManager.acquireRequiredLocks(MergeManager, UnitOfWorkChangeSet)"},
        { "concurrency_util_create_information_all_threads_acquire_cache_keys_4", "[methodNameThatGotStuckWaitingToAcquire: {0}] \n"},
        { "concurrency_util_create_information_all_threads_acquire_cache_keys_5", "Concurrency manager - Page 02 end - information about threads waiting to acquire (write/deferred) cache keys\n"},
        { "concurrency_util_create_information_all_threads_acquire_read_cache_keys_1", "Concurrency manager - Page 03 start - information about threads waiting to acquire read cache keys "
                + "\nTotal number of threads waiting to acquire read locks: {0} \n\n"},
        { "concurrency_util_create_information_all_threads_acquire_read_cache_keys_2", "[currentThreadNumber: {0}] [ThreadName: {1} ]: Waiting to acquire (read lock): {2}\n"},
        { "concurrency_util_create_information_all_threads_acquire_read_cache_keys_3", "[methodNameThatGotStuckWaitingToAcquire: {0}]  \n"},
        { "concurrency_util_create_information_all_threads_acquire_read_cache_keys_4", "Concurrency manager - Page 03 end - information about threads waiting to acquire read cache keys\n"},
        { "concurrency_util_create_information_all_threads_release_deferred_locks_1", "Concurrency manager - Page 04 start - information about threads waiting on release deferred locks (waiting for other thread to finish building the objects deferred) "
                + "\nTotal number of threads waiting to acquire lock: {0} \n\n"},
        { "concurrency_util_create_information_all_threads_release_deferred_locks_2", "[currentThreadNumber: {0}] [ThreadName: {1} ]\n"},
        { "concurrency_util_create_information_all_threads_release_deferred_locks_3", "Concurrency manager - Page 04 end - information about threads waiting on release deferred locks (waiting for other thread to finish building the objects deferred)\n"},
        { "concurrency_util_create_information_all_resources_acquired_deferred_1", "Concurrency manager - Page 05 start (currentThreadNumber: {0} of totalNumberOfThreads: {1})  - detailed information about specific thread "
                + "\nThread: {2}"
                + "\nThreadWaitingToReleaseDeferredLocks: {3}\n"},
        { "concurrency_util_create_information_all_resources_acquired_deferred_2", " waitingOnAcquireWritingCacheKey: true  waiting to acquire writing: {0}\n"},
        { "concurrency_util_create_information_all_resources_acquired_deferred_3", " waitingOnAcquireWritingCacheKey: false\n"},
        { "concurrency_util_create_information_all_resources_acquired_deferred_4", " waitingOnAcquireReadCacheKey: true   waiting to acquire reading: {0}\n"},
        { "concurrency_util_create_information_all_resources_acquired_deferred_5", " waitingOnAcquireReadCacheKey: false\n"},
        { "concurrency_util_create_information_all_resources_acquired_deferred_6", " writeManagerThreadPrimaryKeysWithChangesToBeMerged: true"
                + "\n writeManagerThreadPrimaryKeysWithChangesToBeMerged list: {0}\n"},
        { "concurrency_util_create_information_all_resources_acquired_deferred_7", " writeManagerThreadPrimaryKeysWithChangesToBeMerged: false\n"},
        { "concurrency_util_create_information_all_resources_acquired_deferred_8", " waitingToReleaseDeferredLocksJustification: \n {0} \n"},
        { "concurrency_util_create_information_all_resources_acquired_deferred_9", " waitingToReleaseDeferredLocksJustification: information not available. \n"},
        { "concurrency_util_create_information_all_resources_acquired_deferred_10", "Concurrency manager - Page 05 end (currentThreadNumber: {0} of totalNumberOfThreads: {1})  - detailed information about specific thread\n"},
        { "concurrency_util_read_lock_manager_problem01", "Remove cache key from read lock manager problem 01:"
                + "\n The current thread: {0} is about to decrement the currentNumberOfReaders from: {1}  to decrementedNumberOfReaders {2} "
                + "\n  on the cache key: {3}"
                + "\n however the readLockManager for the current thread is null."
                + "\n This should never happen. If the readLockManager is null either the we have not incremented the number readers in the past. "
                + "\n Or we have removed all the cache keys of the readLockManager belonging to this thread making the map become empty and be removed. "
                + "\n It should never be the case that we are bout the decrement the count of readers and are not tracing the cache key are we about to decrement."
                + "\n Stack trace as we detect the problem: {4}"
                + "\n CurrentDate: {5}"},
        { "concurrency_util_read_lock_manager_problem02", "Remove cache key from read lock manager problem 02:"
                + "\n removeReadLock PROBLEM Detected - mapThreadToReadLockAcquisitionMetadata does not have have threadId  . "
                + "\n The following problem is taking place. The Thread: {0} is about to decrease the number of readers on the cacheKey: {1} "
                + "\n However this ReadLockManager currently has no entries on the mapThreadToReadLockAcquisitionMetadata associated to the ongoing threadId:  {2}"
                + "\n as result in terms of tracing we will simply ignore this call to removeReadLock for the current cache key. "
                + "\n Problem is taking place in Thread: {2} "
                + "\n Stack trace as we detect the problem: {3}"
                + "\n CurrentDate: {4}"},
        { "concurrency_util_read_lock_manager_problem03", "Remove cache key from read lock manager problem 03:"
                + "\n removeReadLock problem detected - mapThreadToReadLockAcquisitionMetadata.readLocksAcquiredDuringCurrentThread does not have have threadId  . "
                + "\n The following problem is taking place. The Thread: {0} is about to decrease the number of readers on the cacheKey: {1}"
                + "\n However this ReadLockManager currently has no entries on the mapThreadToReadLockAcquisitionMetadata.readLocksAcquiredDuringCurrentThread associated to the ongoing threadId:  {2}"
                + "\n as result in terms of tracing we will simply ignore this call to removeReadLock for the current cache key. "
                + "\n Problem is taking place in Thread: {2} "
                + "\n Stack trace as we detect the problem: {3}"
                + "\n CurrentDate: {4}"},
        { "concurrency_util_read_lock_acquisition_metadata", "No stack trace take. isAllowTakingStackTraceDuringReadLockAcquisition is false."},
        { "concurrency_util_dump_concurrency_manager_information_step02_01", "Start full concurrency manager state (massive) dump No: {0}\n"},
        { "concurrency_util_dump_concurrency_manager_information_step02_02", "End full concurrency manager state (massive) dump No: {0}\n"},
        { "concurrency_util_dump__dead_lock_explanation_01", "dumpDeadLockExplanationIfPossible code is buggy. The algorithm to try to explain dead locks should not break. Instead we have caught an exception"},
        { "concurrency_util_dump__dead_lock_explanation_02", "Concurrency manager - Page 07 start - dead lock explanation\n"},
        { "concurrency_util_dump__dead_lock_explanation_03", "We were not able to determine to determine a set of threads that went into dead lock."},
        { "concurrency_util_dump__dead_lock_explanation_04", "Dead  lock result is comprised by  {0} thread entries where one of them is repeated. \n"},
        { "concurrency_util_dump__dead_lock_explanation_05", "Dead lock participantNR: {0} "
                + "\n {1} \n\n"},
        { "concurrency_util_dump__dead_lock_explanation_06", "deadlock algorithm took {0} ms to try to find deadlock."
                + "\nConcurrency manager - Page 07 end - dead lock explanation\n"},
        { "concurrency_util_cache_keys_threads_making_use_cache_key_01", "Concurrency manager - Page 06 start - information about cache keys and threads needing them "
                + "\nTotal number of cacheKeys to describe: {0} \n\n"},
        { "concurrency_util_cache_keys_threads_making_use_cache_key_02", "-------------- [currentCacheKeyNumber: {0} of {1}]--------------\n"},
        { "concurrency_util_cache_keys_threads_making_use_cache_key_03", "[currentCacheKeyNumber: {0}] [CacheKey: {1} ]:"
                + "\n[currentCacheKeyNumber: {0}] threadsThatAcquiredActiveLock: {2}"
                + "\n[currentCacheKeyNumber: {0}] threadsThatAcquiredDeferredLock: {3}"
                + "\n[currentCacheKeyNumber: {0}] threadsThatAcquiredReadLock:  {4}"
                + "\n[currentCacheKeyNumber: {0}] threadsKnownToBeStuckTryingToAcquireLock:  {5}"
                + "\n[currentCacheKeyNumber: {0}] threadsKnownToBeStuckTryingToAcquireLockForReading:  {6}"
                + "\n[currentCacheKeyNumber: {0}] threads doing object building with root on this cache key (not yet supported)...\n\n"},
        { "concurrency_util_cache_keys_threads_making_use_cache_key_04", "Concurrency manager - Page 06 end - information about cache keys and threads needing them\n"},
        { "explain_dead_lock_util_current_thread_blocked_active_thread_warning", "recursiveExplainPossibleDeadLockStep03Scenario03CurrentWriterVsCacheKeyActiveThread: nextCandidateThreadPartOfTheDeadLock is Thread: {0}  "
                + " This thread appears to be blocking the thread: {1}  from progressing because it is set as the active thread on the cacheKey: {2} "},
        { "explain_dead_lock_util_thread_stuck_deferred_locks", "recursiveExplainPossibleDeadLockStep04ExpandBasedOnThreadStuckOnReleaseDeferredLocks: currentCandidateThreadPartOfTheDeadLock is Thread: {0}  "
                + " This thread appears to be stuck in the releaseDeferredLock logic. "
                + " But our hacked implementation of the  isBuildObjectOnThreadComplete was not able to explain what thread and cache key are recursively "
                + " stopping the candidate thread to make progress... We expect this code spot to never be invoked. "
                + " Either this thread made progress or if it continues to be stuck in the releaseDeferredLock "
                + " we most likely have an implementation bug somewhere. "},

        { "XML_call", "XML call" },
        { "XML_data_call", "XML data call" },
        { "XML_data_delete", "XML data delete" },
        { "XML_data_insert", "XML data insert" },
        { "XML_data_read", "XML data read" },
        { "XML_data_update", "XML data update" },
        { "XML_delete", "XML delete" },
        { "XML_existence_check", "XML existence check" },
        { "XML_insert", "XML insert" },
        { "XML_read_all", "XML read all" },
        { "XML_read", "XML read" },
        { "XML_update", "XML update" },
        { "write_BLOB", "Writing BLOB value(size = {0} bytes) through the locator to the table field: {1}" },
        { "write_CLOB", "Writing CLOB value(size = {0} bytes) through the locator to the table field: {1}" },
        { "assign_sequence", "assign sequence to the object ({0} -> {1})" },
        { "assign_return_row", "Assign return row {0}" },
        { "compare_failed", "Compare failed: {0}:{1}:{2}" },
        { "added_unmapped_field_to_returning_policy", "Added unmapped field {0} to ReturningPolicy of {1}" },
        { "field_for_unsupported_mapping_returned", "Returned field {0} specified in ReturningPolicy of {1} mapped with unsupported mapping" },
        { "received_updates_from_remote_server", "Received updates from Remote Server" },
        { "received_remote_connection_from", "Received remote connection from {0}" },
        { "applying_changeset_from_remote_server", "Applying changeset from remote server {0}" },
        { "change_from_remote_server_older_than_current_version", "Change from Remote Server is older than current Version for {0}: {1}" },
        { "current_version_much_older_than_change_from_remote_server", "Current Version is much older than change from remote server for {0}: {1}" },
        { "Merging_from_remote_server", "Merging {0}: {1} from remote server" },
        { "initializing_local_discovery_communication_socket", "Initializing local discovery communication socket" },
        { "place_local_remote_session_dispatcher_into_naming_service", "Place local remote session dispatcher into naming service" },
        { "connecting_to_other_sessions", "connecting to other sessions" },
        { "done", "Done" },
        { "getting_local_initial_context", "Getting local initial context" },
        { "received_connection_from", "Received connection from {0}" },
        { "sending_changeset_to_network", "Sending changeSet to network" },
        { "failed_to_reconnect_remote_connection", "Failed to reconnect the remote connection on error" },
        { "dropping_connection", "Dropping connection: {0}" },
        { "attempting_to_reconnect_to_JMS_service", "Attempting to reconnect to JMS service" },
        { "retreived_remote_message_from_JMS_topic", "Retreived remote message from JMS topic: {0}" },
        { "retreived_remote_message_from_jgroup_channel", "Retreived remote message from JGroups channel: {0}" },
        { "processing_topLink_remote_command", "Processing TopLink remote command" },
        { "JMS_exception_thrown", "JMSException thrown" },
        { "announcement_sent_from", "Announcement sent from {0}" },
        { "announcement_received_from", "Announcement received from {0}" },
        { "reconnect_to_jms", "Reconnect to the JMS topic name {0}" },
        { "sequencing_connected", "sequencing connected, state is {0}" },
        { "sequencing_connected_several_states", "sequencing connected, several states are used" },
        { "sequence_without_state", "sequence {0}: preallocation size {1}" },
        { "sequence_with_state", "sequence {0}: preallocation size {1}, state {2}" },
        { "sequencing_disconnected", "sequencing disconnected" },
        { "sequencing_localPreallocation", "local sequencing preallocation for {0}: objects: {1} , first: {2}, last: {3}" },
        { "sequencing_afterTransactionCommitted", "local sequencing preallocation is copied to preallocation after transaction commit" },
        { "sequencing_afterTransactionRolledBack", "local sequencing preallocation is discarded after transaction roll back" },
        { "sequencing_preallocation", "sequencing preallocation for {0}: objects: {1} , first: {2}, last: {3}" },
        { "starting_rcm", "Starting Remote Command Manager {0}" },
        { "stopping_rcm", "Stopping Remote Command Manager {0}" },
        { "initializing_discovery_resources", "Initializing discovery resources - group={0} port={1}" },
        { "sending_announcement", "Sending service announcement..." },
        { "register_local_connection_in_jndi", "Registering local connection in JNDI under name {0}" },
        { "register_local_connection_in_registry", "Registering local connection in RMIRegistry under name {0}" },
        { "context_props_for_remote_lookup", "Remote context properties: {0}" },
        { "looking_up_remote_conn_in_jndi", "Looking up remote connection in JNDI under name {0} at URL {1}" },
        { "looking_up_remote_conn_in_registry", "Looking up remote connection in RMIRegistry at {0}" },
        { "unable_to_look_up_remote_conn_in_jndi", "Unable to look up remote connection in JNDI under name {0} at URL {1}" },
        { "unable_to_look_up_remote_conn_in_registry", "Unable to look up remote connection in RMIRegistry under name {0}" },
        { "converting_to_toplink_command", "Converting {0} to TopLink Command format" },
        { "converting_to_user_command", "Converting {0} from TopLink Command format to user format" },
        { "executing_merge_changeset", "Executing MergeChangeSet command from {0}" },
        { "received_remote_command", "Received remote command {0} from {1}" },
        { "processing_internal_command", "Executing internal RCM command {0} from {1}" },
        { "processing_remote_command", "Executing command {0} from {1}" },
        { "sync_propagation", "Propagating command synchronously" },
        { "async_propagation", "Propagating command asynchronously" },
        { "propagate_command_to", "Propagating command {0} to {1}" },
        { "discovery_manager_active", "RCM Discovery Manager active" },
        { "discovery_manager_stopped", "RCM Discovery Manager stopped" },
        { "announcement_sent", "RCM service announcement sent out to cluster" },
        { "announcement_received", "RCM service announcement received from {0}" },
        { "creating_session_broker", "Creating session broker: {0}" },
        { "creating_database_session", "Creating database session: {0}" },
        { "creating_server_session", "Creating server session: {0}" },
        { "EJB_create", "Create EJB ({0}) " },
        { "EJB_find_all", "Find all EJB objects ({0})" },
        { "EJB_find_all_by_name", "Find all EJB objects by named query ({0})" },
        { "EJB_find_one", "Find one EJB object ({0})" },
        { "EJB_find_one_by_name", "Find one EJB object by named query ({0})" },
        { "EJB_load", "Load EJB" },
        { "EJB_remove", "Remove EJB ({0})" },
        { "EJB_store", "Store EJB ({0})" },
        { "error_in_preInvoke", "Error in preInvoke." },
        { "unable_to_load_generated_subclass", "Unable to load generated subclass: {0}" },
        { "WebLogic_10_Platform_serverSpecificRegisterMBeans_enter", "WebLogic_10_Platform.serverSpecificRegisterMBeans enter" },
        { "WebLogic_10_Platform_serverSpecificRegisterMBeans_return", "WebLogic_10_Platform.serverSpecificRegisterMBeans return" },
        { "executeFinder_query", "executeFinder query: {0}, {1}" },
        { "executeFinder_finder_execution_results", "executeFinder - finder execution results: {0}" },
        { "PM_initialize_enter", "PersistenceManager.initialize enter for {0}" },
        { "PM_initialize_return", "PersistenceManager.initialize return for {0}" },
        { "PM_preDeploy_enter", "PersistenceManager.preDeploy enter for {0}" },
        { "PM_preDeploy_return", "PersistenceManager.preDeploy return for {0}" },
        { "PM_postDeploy_enter", "PersistenceManager.postDeploy enter for {0}" },
        { "PM_postDeploy_return", "PersistenceManager.postDeploy return for {0}" },
        { "createEJB_call", "createEJB call: {0}" },
        { "createEJB_return", "createEJB return: {0}" },
        { "removeEJB_call", "removeEJB call: {0}" },
        { "invokeHomeMethod_call", "invokeHomeMethod call: {0}({1})" },
        { "invokeHomeMethod_return", "invokeHomeMethod return" },
        { "ProjectDeployment_undeploy_enter", "ProjectDeployment.undeploy enter" },
        { "ProjectDeployment_undeploy_return", "ProjectDeployment.undeploy return" },
        { "ProjectDeployment_configureDescriptor_enter", "ProjectDeployment.configureDescriptor enter: {0}" },
        { "ProjectDeployment_configureDescriptor_return", "ProjectDeployment.configureDescriptor return" },
        { "ProjectDeployment_configureDescriptors_enter", "ProjectDeployment.configureDescriptors enter" },
        { "ProjectDeployment_configureDescriptors_return", "ProjectDeployment.configureDescriptors return" },
        { "configuring_descriptor", "configuring descriptor: {0}, {1}" },
        { "concrete_class", "concrete class: {0}" },
        { "setting_ref_class_of_foreign_ref_mapping", "setting ref class of foreign ref mapping: {0}, {1}" },
        { "setting_ref_class_of_aggregate_mapping", "setting ref class of aggregate mapping: {0}, {1}" },
        { "desc_has_inheritance_policy", "Descriptor has inheritance policy: {0}" },
        { "one_time_initialization_of_ProjectDeployment", "one-time initialization of ProjectDeployment" },
        { "generateBeanSubclass_call", "generateBeanSubclass call: {0}" },
        { "remote_and_local_homes", "remote and local homes: {0}, {1}" },
        { "generateBeanSubclass_return", "generateBeanSubclass return: {0}" },
        { "error_in_startBusinessCall", "Error in startBusinessCall." },
        { "error_in_endLocalTx", "Error in endLocalTx." },
        { "EJB20_Project_Deployment_adjustDescriptorsForUOW_enter", "UOWChangeSetFlagCodeGenerator.adjustDescriptorForUOWFlag enter" },
        { "EJB20_Codegeneration_For_UOW_Change_Policy_enter", "UOWChangePolicyCodeGenerator.generateCodeForUOWChangePolicy enter" },
        { "OBJECTCHANGEPOLICY_TURNED_ON", "Change tracking turned on for: {0}" },
        { "PM_DescriptorContents", "********** PersistenceManager.getPMDescriptorContents()" },
        { "project_class_used", "The project class [{0}] is being used." },
        { "pessimistic_lock_bean", "prepare pessimistic locking for bean {0}" },
        { "changetracker_interface_not_implemented", "Class [{0}] for attribute [{1}] does not implement ChangeTracker interface. This class is being reverted to DeferredChangeDetectionPolicy." },
        { "changetracker_interface_not_implemented_non_cmp", "Class [{0}] is being reverted to DeferredChangeDetectionPolicy since the attribute [{1}] " + "is a non-cmp field but the owinging class does not implement ChangeTracker interface." },
        { "acquire_client_session_broker", "acquire client session broker" },
        { "releasing_client_session_broker", "releasing client session broker" },
        { "client_released", "client released" },
        { "client_acquired", "client acquired: {0}" },
        { "tracking_pl_object", "track pessimistic locked object {0} with UnitOfWork {1}" },
        { "instantiate_pl_relationship", "instantiate pessimistic locking relationship when relationship is accessed in a new transaction." },
        { "descriptor_xml_not_in_jar", "The descriptor file ({0}) is not found in jar({1}) file, no migration therefore will be performed for this jar." },
        { "pessimistic_locking_migrated", "The native CMP setting 'pessimistic-locking' on entity({0}) has been migrated and supported." },
        { "read_only_migrated", "The native CMP setting 'read-only' on entity({0}) has been migrated and supported." },
        { "call_timeout_migrated", "Oc4j native CMP setting 'time-out' on entity({0}) has been migrated and supported." },
        { "verifiy_columns_version_locking_migrated", "Optimistic setting 'Version' on 'verifiy-columns' in entity ({0}) has been migrated." },
        { "verifiy_columns_timestamp_locking_migrated", "Optimistic setting 'Timestamp' on 'verifiy-columns' in entity ({0}) has been migrated." },
        { "verifiy_columns_changedField_locking_migrated", "Optimistic setting 'Modify' on 'verifiy-columns' in entity ({0}) has been migrated." },
        { "order_database_operations_supported", "WLS native CMP setting 'order-database-operations' has been supported and migrated" },
        { "pattern_syntax_error", "Regular expression syntax error, exception is: {0}" },
        { "weaver_user_impl_change_tracking", "Weaving for change tracking not required for class [{0}] because it already implements the ChangeTracker interface."},
        { "weaver_found_field_lock", "Weaving for change tracking not enabled for class [{0}] because it uses field-based optimisitic locking."},
        { "weaver_processing_class", "Class [{0}] registered to be processed by weaver."},
        { "begin_weaving_class", "Begin weaver class transformer processing class [{0}]."},
        { "end_weaving_class", "End weaver class transformer processing class [{0}]."},
        { "transform_missing_class_details", "Missing class details for [{0}]."},
        { "transform_existing_class_bytes", "Using existing class bytes for [{0}]."},
        { "weaved_lazy", "Weaved lazy (ValueHolder indirection) [{0}]."},
        { "weaved_fetchgroups", "Weaved fetch groups (FetchGroupTracker) [{0}]."},
        { "weaved_changetracker", "Weaved change tracking (ChangeTracker) [{0}]."},
        { "weaved_persistenceentity", "Weaved persistence (PersistenceEntity) [{0}]."},
        { "weaved_rest", "Weaved REST [{0}]."},
        { "cmp_init_invoke_predeploy", "JavaSECMPInitializer - predeploying {0}."},
        { "cmp_init_register_transformer", "JavaSECMPInitializer - registering transformer for {0}."},
        { "cmp_init_tempLoader_created", "JavaSECMPInitializer - created temporary ClassLoader: {0}."},
        { "cmp_init_shouldOverrideLoadClassForCollectionMembers", "JavaSECMPInitializer - override load class for collection members: {0}."},
        { "cmp_loading_entities_using_loader", "JavaSECMPInitializer - loading entities using ClassLoader: {0}."},
        { "cmp_init_transformer_is_null", "JavaSECMPInitializer - transformer is null."},
        { "cmp_init_globalInstrumentation_is_null", "JavaSECMPInitializer - global instrumentation is null."},
        { "cmp_init_invoke_deploy", "JavaSECMPInitializer - deploying {0}."},
        { "cmp_init_completed_deploy", "JavaSECMPInitializer - completed deploy of {0}."},
        { "cmp_init_initialize", "JavaSECMPInitializer - initializing {0}."},
        { "cmp_init_initialize_from_main", "JavaSECMPInitializer - initializing from main."},
        { "cmp_init_initialize_from_agent", "JavaSECMPInitializer - initializing from agent."},
        { "validation_factory_not_initialized", "Bean Validation Factory was not initialized: [{0}]."},
        { "searching_for_default_mapping_file", "Searching for mapping file: [{0}] at root URL: [{1}]."},
        { "found_default_mapping_file", "Found mapping file: [{0}] at root URL: [{1}]."},

        { "detect_server_platform","Detected server platform: {0}."},
        { "configured_server_platform", "Configured server platform: {0}"},
        { "dbPlatformHelper_detectedVendorPlatform", "Detected database platform: {0}"},
        { "dbPlatformHelper_regExprDbPlatform", "Database platform: {1}, regular expression: {0}"},
        { "dbPlatformHelper_patternSyntaxException", "Exception while using regular expression: {0}" },
        { "platform_ora_init_id_seq", "Init Oracle identity sequence {0} -> {1} for table {2}"},
        { "platform_ora_remove_id_seq", "Remove Oracle identity sequence {0} -> {1} for table {2}"},
        { "unknown_query_hint", "query {0}: unknown query hint {1} will be ignored"},
        { "query_hint", "query {0}: query hint {1}; value {2}"},
        { "property_value_specified", "property={0}; value={1}"},
        { "property_value_default", "property={0}; default value={1}"},
        { "handler_property_value_specified", "property={0}; value={1}; translated value={2}"},
        { "handler_property_value_default", "property={0}; default value={1}; translated value={2}"},
        { "predeploy_begin", "Begin predeploying Persistence Unit {0}; session {1}; state {2}; factoryCount {3}"},
        { "predeploy_end", "End predeploying Persistence Unit {0}; session {1}; state {2}; factoryCount {3}"},
        { "session_name_change", "Session change name: Persistence Unit {0}; old session {1}; new session {2}"},
        { "deploy_begin", "Begin deploying Persistence Unit {0}; session {1}; state {2}; factoryCount {3}"},
        { "deploy_end", "End deploying Persistence Unit {0}; session {1}; state {2}; factoryCount {3}"},
        { "undeploy_begin", "Begin undeploying Persistence Unit {0}; session {1}; state {2}; factoryCount {3}"},
        { "undeploy_end", "End undeploying Persistence Unit {0}; session {1}; state {2}; factoryCount {3}"},
        { "composite_member_begin_call", "Begin {0} on composite member Persistence Unit {1}; state {2}"},
        { "composite_member_end_call", "End {0} on composite member Persistence Unit {1}; state {2}"},
        { "loading_session_xml", "Loading persistence unit from sessions-xml file: {0}, session-name: {1}"},

        { "default_tables_created", "The table ({0}) is created."},
        { "cannot_create_table", "The table ({0}) could not be created due to exception: {1}" },
        { "cannot_add_field_to_table", "The field ({0}) could not be added to the table ({1}) due to exception: {2}" },
        { "identity_map_does_not_exist",  "Identity Map [{0}] does not exist" },
        { "identity_map_is_empty",  "Identity Map [{0}] is empty" },
        { "key_value",  "Key [{0}] => Value [{1}]" },
        { "no_identity_maps_in_this_session",  "There are no Identity Maps in this session" },
        { "identity_map_class",  "Identity Map [{0}] class = {1}" },
        { "identity_map_initialized",  "Identity Map [{0}] is initialized" },
        { "identity_map_invalidated",  "Identity Map [{0}] is invalidated" },
        { "no_classes_in_session", "No Classes in session." },

        { "creating_broadcast_connection", "{0}: creating connection." },
        { "broadcast_connection_created", "{0}: connection created." },
        { "failed_to_create_broadcast_connection", "{0}: failed to create connection." },
        { "broadcast_sending_message", "{0}: sending message {1}" },
        { "broadcast_sent_message", "{0}: has sent message {1}" },
        { "broadcast_closing_connection", "{0}: connection is closing." },
        { "broadcast_connection_closed", "{0}: connection closed." },
        { "broadcast_retreived_message", "{0}: has received message {1}" },
        { "broadcast_processing_remote_command", "{0}: processing message {1} sent by service id {2}: processing remote command {3}." },
        { "broadcast_connection_start_listening", "{0}: Start listening." },
        { "broadcast_connection_stop_listening", "{0}: Stop listening." },
        { "sdo_type_generation_processing_type", "{0}: Generating Type  [{1}]."},
        { "sdo_type_generation_processing_type_as", "{0}: Generating Type  [{1}] as [{2}]."},
        { "registered_mbean", "Registered MBean: {0} on server {1}" },
        { "unregistering_mbean", "Unregistering MBean: {0} on server {1}" },
        { "mbean_get_application_name", "The applicationName for the MBean attached to session [{0}] is [{1}]" },
        { "mbean_get_module_name", "The moduleName for the MBean attached to session [{0}] is [{1}]" },
        { "active_thread_is_different_from_current_thread", "Forcing the activeThread \"{0}\" on the mergeManager \"{1}\" to be the currentThread \"{2}\" because they are different." },
        { "dead_lock_encountered_on_write_no_cachekey", "Potential deadlock encountered while thread: {2} attempted to lock object of class: {0} with id: {1}, entering deadlock avoidance algorithm.  This is a notice only."},
        { "metamodel_attribute_class_type_is_null", "Metamodel processing: The class type is null for the attribute: {0}." },
        { "metamodel_mapping_type_is_unsupported", "Metamodel processing: The mapping type [{0}] in the attribute [{1}] is currently unsupported." },
        { "metamodel_descriptor_type_eis_or_xml_is_unsupported", "Metamodel processing: EIS or XML ClassDescriptor instances [{0}] are currently not supported." },
        { "connect_drivermanager_fail", "DriverManager connect failed, trying direct connect."},
        { "metamodel_unable_to_determine_element_type_in_absence_of_generic_parameters", "Metamodel processing: Unable to get the element type for the mapping [{0}] in the absence of generic parameters on mapping declaration." },
        { "metamodel_init_failed", "Initialization of the metamodel failed during deployment.  Ignoring exception: [{0}] " },
        { "metamodel_canonical_model_class_not_found", "Canonical Metamodel class [{0}] not found during initialization."},
        { "metamodel_canonical_model_class_found", "Canonical Metamodel class [{0}] found and instantiated during initialization."},
        { "metamodel_relationaldescriptor_javaclass_null_on_managedType", "Metamodel processing: The javaClass field is null for the relationalDescriptor [{0}] for the managedType [{1}]." },
        { "metamodel_attribute_getmember_is_null", "The java Member is null for the Attribute [{0}] with managedType [{1}] and descriptor [{2}]." },
        { "metamodel_typeImpl_javaClass_should_not_be_null", "The metamodel TypeImpl.javaClass field should not be set to null for the Type [{0}] with name [{1}]." },
        { "jmx_mbean_classloader_in_use", "EclipseLink JMX Runtime Services is referencing the [{0}] ClassLoader at: [{1}]" },
        { "metamodel_itentifiableType_javaclass_null_cannot_set_supertype", "Metamodel processing: Unable to set the superclass Hierarchy because the javaClass field is null for the relationalDescriptor [{0}] for the identifiableType [{1}]." },
        { "metamodel_relationaldescriptor_not_fully_initialized_yet", "Metamodel processing: The relationalDescriptor [{0}] for the managedType [{1}] is not fully initialized yet - the Metamodel instance will be incomplete before at least one entityManger session login (after a full deploy)." },
        { "no_weaved_vh_method_found_verify_weaving_and_module_order", "An expected weaving method [{0}] was not found on the accessor [{2}] on the mapping [{1}] - verify that the processing order of your modules places the one containing a persistence unit ahead of modules that use it in your deployment descriptor, or disable weaving for the persistence context or the mapping using FetchType.EAGER." },
        { "proxy_connection_customizer_already_proxy_session", "{0}:{1}: proxy session with unknown properties is already opened. Closing it."},
        { "proxy_connection_customizer_opened_proxy_session",  "{0}:{1}: opened proxy session."},
        { "proxy_connection_customizer_closing_proxy_session", "{0}:{1}: closing proxy session."},
        { "releasing_invalid_lock", "A lock has been encountered where the thread: {0} is no longer active.  The lock on object class :{1} id: {2} has been forcibly released"},
        { "acquire_connection", "Connection acquired from connection pool [{0}]." },
        { "release_connection", "Connection released to connection pool [{0}]." },
        { "failover", "Connection pool [{0}] is dead, failing over to poll [{1}]." },
        { "max_time_exceeded_for_acquirerequiredlocks_wait", "MAX TIME {0} seconds EXCEEDED FOR WRITELOCKMANAGER WAIT.  Waiting on Entity type: {1}with pk: {2} currently locked by thread: {3} with the following trace:\n"},
        { "dcn_registering", "Registering for database change event notification." },
        { "dcn_change_event", "Receieved database change event [{0}]." },
        { "dcn_invalidate", "Invalidating cache key [{0}] from database change event for class [{1}]." },
        { "dcn_register_table", "Registering table [{0}] for database change event notification." },
        { "dcn_unregister", "Removing registering for database change event notification." },

        { "exception_caught_closing_statement", "Exception caught when trying to close the query statement [{0}]." },
        //MOXy fine/finer/finest
        { "schema_factory", "SchemaFactory instance: {0}" },
        { "saxparser_factory", "SAXParserFactory instance: {0}" },
        { "xpath_factory", "XPathFactory instance: {0}" },
        { "transformer_factory", "TransformerFactory instance: {0}" },
        { "documentbuilder_factory", "DocumentBuilderFactory instance: {0}" },
        { "jaxp_sec_disabled", "Xml Security disabled, no JAXP {0} external access configuration necessary." },
        { "jaxp_sec_explicit", "Detected explicitly JAXP configuration, no JAXP {0} external access configuration necessary." },
        { "jaxp_sec_prop_supported", "Property {0} is supported and has been successfully set by used JAXP implementation." },
        { "jaxp_sec_prop_not_supported", "Property {0} is not supported by used JAXP implementation." },
        { "moxy_start_marshalling", "Marshalling \"{0}\" into {1} started"},
        { "moxy_start_unmarshalling", "Unmarshalling {0} into \"{1}\" by \"{2}\" started"},
        { "moxy_read_from_moxy_json_provider", "MOXyJsonProvider.readFrom(...) is called."},
        { "moxy_write_to_moxy_json_provider", "MOXyJsonProvider.writeTo(...) is called."},
        { "moxy_set_marshaller_property", "Setting marshaller property (name/value): {0}/{1}"},
        { "moxy_set_unmarshaller_property", "Setting unmarshaller property (name/value): {0}/{1}"},
        { "moxy_set_jaxb_context_property", "Setting JAXBContext property (name/value): {0}/{1}"},
        { "invalid_tzone", "Invalid timezone conversion property {0} value: {1}.  Will attempt to resolve default." },
        { "invalid_default_tzone", "Invalid timezone conversion property {0} value: {1}.  Defaulting to UTC." },
        { "using_conversion_tzone", "ConversionManager using default zone offset: {1}."},
        { "open_pkg", "Opening package {0} in {1} to {2} for reflection access."},
        { "set_accessible", "Cannot setAccessible {0} for {1}."},
        { "set_accessible_in", "Cannot setAccessible {0} {1} in {2}."}
    };

    /**
     * Return the lookup table.
     */
    @Override
    protected Object[][] getContents() {
        return contents;
    }
}