Datasets:

---

semeru

/

code-text-java

like 3

Follow

Semeru Lab 8

[ "@", "FFDCIgnore", "(", "Exception", ".", "class", ")", "public", "DataSource", "getDataSource", "(", ")", "throws", "Exception", "{", "if", "(", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "entry", "(", "tc", ",", "\"getDataSource\"", ")", ";", "// Retrieve the data source factory from the CustomLogProperties. This Factory should be set in the JTMConfigurationProvider", "// by the jdbc component using DeclarativeServices. TxRecoveryAgentImpl gets the factory from the ConfigurationProvider and", "// then sets it into CustomLogProperties.", "ResourceFactory", "dataSourceFactory", "=", "_customLogProperties", ".", "resourceFactory", "(", ")", ";", "if", "(", "dataSourceFactory", "!=", "null", ")", "{", "if", "(", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"Using DataSourceFactory \"", "+", "dataSourceFactory", ")", ";", "}", "else", "{", "if", "(", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "exit", "(", "tc", ",", "\"getDataSource\"", ",", "\"Null ResourceFactory InternalLogException\"", ")", ";", "throw", "new", "InternalLogException", "(", "\"Failed to locate DataSource, null Resourcefactory\"", ",", "null", ")", ";", "}", "try", "{", "nonTranDataSource", "=", "(", "DataSource", ")", "dataSourceFactory", ".", "createResource", "(", "null", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "//e.printStackTrace();", "if", "(", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "exit", "(", "tc", ",", "\"getDataSource\"", ",", "\"Caught exception \"", "+", "e", "+", "\"throw InternalLogException\"", ")", ";", "throw", "new", "InternalLogException", "(", "\"Failed to locate DataSource, caught exception \"", ",", "null", ")", ";", "}", "/*\n * TEMPORARY This is waiting on fixes to DeclarativeServices which impact the jdbc component. At present it is\n * possible that the DataSource will have been set but that its associated jdbc driver service will still be initialising\n */", "// boolean refSet = false;", "// while (!refSet)", "// {", "// if (tc.isDebugEnabled())", "// Tr.debug(tc, \"getDataSource after sleep\");", "// try {", "//", "// nonTranDataSource = (DataSource) dataSourceFactory.createResource(null);", "// if (tc.isDebugEnabled())", "// Tr.debug(tc, \"Non Tran dataSource is \" + nonTranDataSource);", "// Connection conn = nonTranDataSource.getConnection();", "// if (tc.isDebugEnabled())", "// Tr.debug(tc, \"Established connection \" + conn);", "//", "// DatabaseMetaData mdata = conn.getMetaData();", "//", "// String dbName = mdata.getDatabaseProductName();", "// if (tc.isDebugEnabled())", "// Tr.debug(tc, \"Database name \" + dbName);", "//", "// String dbVersion = mdata.getDatabaseProductVersion();", "// if (tc.isDebugEnabled())", "// Tr.debug(tc, \"Database version \" + dbVersion);", "// refSet = true;", "// } catch (Exception e) {", "// // We will catch an exception if the DataSource is not yet fully formed", "// if (tc.isDebugEnabled())", "// Tr.debug(tc, \"Caught exception: \" + e);", "// }", "//", "// if (!refSet)", "// Thread.sleep(200);", "// }", "// eof TEMPORARY", "if", "(", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "exit", "(", "tc", ",", "\"getDataSource\"", ",", "nonTranDataSource", ")", ";", "return", "nonTranDataSource", ";", "}" ]

[ "Locates", "a", "DataSource", "in", "config" ]

[ "private", "void", "writeObject", "(", "ObjectOutputStream", "out", ")", "throws", "IOException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"writeObject\"", ",", "out", ")", ";", "throw", "new", "NotSerializableException", "(", "\"TemporaryTopic\"", ")", ";", "}" ]

[ "The", "writeObject", "method", "for", "serialization", "." ]

[ "public", "static", "void", "addCompleteJarEntryUrls", "(", "List", "<", "ContainerInfo", ">", "containers", ",", "Entry", "jarEntry", ",", "Collection", "<", "String", ">", "resolved", ")", "throws", "UnableToAdaptException", "{", "String", "entryIdentity", "=", "createEntryIdentity", "(", "jarEntry", ")", ";", "if", "(", "!", "entryIdentity", ".", "isEmpty", "(", ")", "&&", "!", "resolved", ".", "contains", "(", "entryIdentity", ")", ")", "{", "resolved", ".", "add", "(", "entryIdentity", ")", ";", "processMFClasspath", "(", "jarEntry", ",", "containers", ",", "resolved", ")", ";", "}", "}" ]

[ "Add", "the", "jar", "entry", "URLs", "and", "its", "class", "path", "URLs", ".", "We", "need", "deal", "with", "all", "the", "thrown", "exceptions", "so", "that", "it", "won", "t", "interrupt", "the", "caller", "s", "processing", "." ]

[ "private", "static", "Entry", "findClassPathEntry", "(", "Entry", "jarEntry", ",", "URI", "pathUri", ")", "throws", "URISyntaxException", ",", "UnableToAdaptException", "{", "URI", "relativeJarUri", "=", "new", "URI", "(", "\"/\"", ")", ".", "relativize", "(", "new", "URI", "(", "jarEntry", ".", "getPath", "(", ")", ")", ")", ";", "URI", "targetUri", "=", "null", ";", "targetUri", "=", "relativeJarUri", ".", "resolve", "(", "pathUri", ")", ";", "if", "(", "targetUri", ".", "toString", "(", ")", ".", "startsWith", "(", "\"..\"", ")", ")", "{", "Entry", "rootEntry", "=", "jarEntry", ".", "getRoot", "(", ")", ".", "adapt", "(", "Entry", ".", "class", ")", ";", "if", "(", "rootEntry", "==", "null", "||", "rootEntry", ".", "getPath", "(", ")", ".", "isEmpty", "(", ")", ")", "{", "//already at the outermost", "return", "null", ";", "}", "return", "findClassPathEntry", "(", "rootEntry", ",", "new", "URI", "(", "\"..\"", ")", ".", "relativize", "(", "targetUri", ")", ")", ";", "// <----", "}", "else", "{", "return", "jarEntry", ".", "getRoot", "(", ")", ".", "getEntry", "(", "targetUri", ".", "toString", "(", ")", ")", ";", "}", "}" ]

[ "calculate", "the", "class", "path", "entry", "based", "on", "the", "jar", "entry" ]

[ "protected", "Object", "[", "]", "purge", "(", ")", "{", "Object", "[", "]", "data", "=", "new", "Object", "[", "getCurrentNumElements", "(", ")", "]", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"LocalPool is purging \"", "+", "data", ".", "length", "+", "\" items. firstEntry: \"", "+", "firstEntry", "+", "\" lastEntry: \"", "+", "lastEntry", "+", "\" poolSize: \"", "+", "poolSize", ")", ";", "}", "if", "(", "0", "<", "data", ".", "length", ")", "{", "int", "out", "=", "0", ";", "if", "(", "lastEntry", ">=", "firstEntry", ")", "{", "for", "(", "int", "i", "=", "firstEntry", ";", "i", "<=", "lastEntry", ";", "i", "++", ")", "{", "data", "[", "out", "]", "=", "free", "[", "i", "]", ";", "free", "[", "i", "]", "=", "null", ";", "out", "++", ";", "}", "}", "else", "{", "for", "(", "int", "i", "=", "firstEntry", ";", "i", "<", "poolSize", ";", "i", "++", ")", "{", "data", "[", "out", "]", "=", "free", "[", "i", "]", ";", "free", "[", "i", "]", "=", "null", ";", "out", "++", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<=", "lastEntry", ";", "i", "++", ")", "{", "data", "[", "out", "]", "=", "free", "[", "i", "]", ";", "free", "[", "i", "]", "=", "null", ";", "out", "++", ";", "}", "}", "lastEntry", "=", "-", "1", ";", "firstEntry", "=", "-", "1", ";", "}", "return", "data", ";", "}" ]

[ "Purge", "the", "contents", "and", "hand", "them", "to", "the", "calling", "pool", "that", "owns", "this", "threadlocal", "version", "." ]

[ "@", "Override", "public", "final", "boolean", "skipCreatingBda", "(", "CDIArchive", "archive", ")", "{", "//only skip this if it is a leaf archive", "boolean", "skip", "=", "isImplicitBeanArchivesScanningDisabled", "(", "archive", ")", ";", "skip", "=", "skip", "&&", "(", "archive", ".", "getBeansXml", "(", ")", "==", "null", ")", ";", "skip", "=", "skip", "&&", "(", "!", "(", "archive", ".", "getType", "(", ")", "==", "ArchiveType", ".", "WEB_MODULE", ")", ")", ";", "return", "skip", ";", "}" ]

[ "Determine", "whether", "this", "jar", "is", "completely", "ignored", "by", "CDI", "so", "no", "need", "to", "create", "bda", "for", "it", ".", "The", "jar", "will", "be", "ignored", "if", "it", "does", "not", "contain", "beans", ".", "xml", "and", "in", "the", "server", ".", "xml", "implicit", "bean", "archive", "scanning", "is", "disabled", "." ]

[ "public", "synchronized", "void", "finalReap", "(", ")", "{", "final", "boolean", "isTraceOn", "=", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", ";", "if", "(", "isTraceOn", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "entry", "(", "tc", ",", "\"finalReap : Remote Async Results = \"", "+", "ivAllRemoteAsyncResults", ".", "size", "(", ")", ")", ";", "// Re-write the finalReap to use the LinkedHashSet, iterating thru the list removing", "// all the entries no matter if they have timed out or not. Cancel alarm if set. d623593", "if", "(", "ivFuture", "!=", "null", ")", "{", "ivIsCanceled", "=", "true", ";", "ivFuture", ".", "cancel", "(", "false", ")", ";", "ivFuture", "=", "null", ";", "}", "for", "(", "Iterator", "<", "RemoteAsyncResultImpl", ">", "iterator", "=", "ivAllRemoteAsyncResults", ".", "iterator", "(", ")", ";", "iterator", ".", "hasNext", "(", ")", ";", ")", "{", "RemoteAsyncResultImpl", "asyncResult", "=", "iterator", ".", "next", "(", ")", ";", "releaseResources", "(", "asyncResult", ")", ";", "// d690014.3", "iterator", ".", "remove", "(", ")", ";", "}", "if", "(", "isTraceOn", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "exit", "(", "tc", ",", "\"finalReap : Remote Async Results = \"", "+", "ivAllRemoteAsyncResults", ".", "size", "(", ")", ")", ";", "}" ]

[ "This", "method", "is", "invoked", "just", "before", "container", "termination", "to", "clean", "up", "server", "-", "side", "Future", "objects", "." ]

[ "public", "synchronized", "void", "add", "(", "RemoteAsyncResultImpl", "asyncResult", ")", "{", "final", "boolean", "isTraceOn", "=", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", ";", "ivAllRemoteAsyncResults", ".", "add", "(", "asyncResult", ")", ";", "if", "(", "asyncResult", ".", "ivPmiBean", "!=", "null", ")", "{", "// d690014.3", "asyncResult", ".", "ivPmiBean", ".", "asyncFutureObjectIncrement", "(", ")", ";", "}", "int", "size", "=", "ivAllRemoteAsyncResults", ".", "size", "(", ")", ";", "if", "(", "isTraceOn", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"add \"", "+", "asyncResult", "+", "\"; size=\"", "+", "size", ")", ";", "// If this is the only entry in the list, setup the alarm. d623593", "if", "(", "size", "==", "1", ")", "{", "ivFuture", "=", "ivScheduledExecutor", ".", "schedule", "(", "this", ",", "ivAlarmIntervalMillis", ",", "TimeUnit", ".", "MILLISECONDS", ")", ";", "}", "else", "if", "(", "size", ">=", "ivNearMaxResultsThreshold", ")", "{", "// d690014.1 - Remove the oldest entry if we have exceeded the maximum", "// number of results. Otherwise, issue a warning since we are near", "// the maximum.", "boolean", "warn", "=", "false", ";", "if", "(", "size", ">", "ivMaxUnclaimedResults", ")", "{", "if", "(", "!", "ivWarnedExceededMax", ")", "{", "warn", "=", "ivWarnedExceededMax", "=", "true", ";", "}", "Iterator", "<", "RemoteAsyncResultImpl", ">", "iterator", "=", "ivAllRemoteAsyncResults", ".", "iterator", "(", ")", ";", "RemoteAsyncResultImpl", "oldest", "=", "iterator", ".", "next", "(", ")", ";", "releaseResources", "(", "oldest", ")", ";", "// d690014.3", "iterator", ".", "remove", "(", ")", ";", "}", "else", "{", "if", "(", "!", "ivWarnedNearMax", ")", "{", "warn", "=", "ivWarnedNearMax", "=", "true", ";", "}", "}", "if", "(", "warn", ")", "{", "Tr", ".", "warning", "(", "tc", ",", "\"MAXIMUM_UNCLAIMED_ASYNC_RESULTS_CNTR0328W\"", ",", "size", ",", "ivMaxUnclaimedResults", ")", ";", "}", "}", "}" ]

[ "Add", "a", "new", "server", "-", "side", "Future", "object", "to", "the", "list", "to", "be", "checked", "for", "timeouts" ]

[ "public", "synchronized", "void", "remove", "(", "RemoteAsyncResultImpl", "asyncResult", ")", "{", "ivAllRemoteAsyncResults", ".", "remove", "(", "asyncResult", ")", ";", "releaseResources", "(", "asyncResult", ")", ";", "// d690014.3", "// If no server-side Future objects and an alarm is set then cancel the alarm. d623593", "if", "(", "ivAllRemoteAsyncResults", ".", "isEmpty", "(", ")", "&&", "ivFuture", "!=", "null", ")", "{", "ivFuture", ".", "cancel", "(", "false", ")", ";", "ivFuture", "=", "null", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"remove \"", "+", "asyncResult", "+", "\"; size=\"", "+", "ivAllRemoteAsyncResults", ".", "size", "(", ")", ")", ";", "}" ]

[ "Remove", "a", "server", "-", "side", "Future", "object", "from", "the", "reaper", "and", "release", "its", "resources", "." ]

[ "public", "String", "format", "(", "long", "timestamp", ")", "{", "// If the format is unknown, use the default formatter.", "if", "(", "invalidFormat", ")", "{", "return", "formatter", ".", "format", "(", "timestamp", ")", ";", "}", "try", "{", "long", "delta", "=", "timestamp", "-", "refTimestamp", ";", "// If we need to reformat", "if", "(", "delta", ">=", "pdiff", "||", "delta", "<", "ndiff", ")", "{", "StringBuffer", "refTime", "=", "new", "StringBuffer", "(", ")", ";", "refTimestamp", "=", "timestamp", ";", "formatter", ".", "format", "(", "timestamp", ",", "refTime", ",", "position", ")", ";", "refMilli", "=", "Long", ".", "parseLong", "(", "refTime", ".", "substring", "(", "position", ".", "getBeginIndex", "(", ")", ",", "position", ".", "getEndIndex", "(", ")", ")", ")", ";", "refBeginning", "=", "refTime", ".", "substring", "(", "0", ",", "position", ".", "getBeginIndex", "(", ")", ")", ";", "refEnding", "=", "refTime", ".", "substring", "(", "position", ".", "getEndIndex", "(", ")", ")", ";", "pdiff", "=", "1000", "-", "refMilli", ";", "ndiff", "=", "-", "refMilli", ";", "return", "refTime", ".", "toString", "(", ")", ";", "}", "else", "{", "StringBuffer", "sb", "=", "new", "StringBuffer", "(", ")", ";", "long", "newMilli", "=", "delta", "+", "refMilli", ";", "if", "(", "newMilli", ">=", "100", ")", "sb", ".", "append", "(", "refBeginning", ")", ".", "append", "(", "newMilli", ")", ".", "append", "(", "refEnding", ")", ";", "else", "if", "(", "newMilli", ">=", "10", ")", "sb", ".", "append", "(", "refBeginning", ")", ".", "append", "(", "'", "'", ")", ".", "append", "(", "newMilli", ")", ".", "append", "(", "refEnding", ")", ";", "else", "sb", ".", "append", "(", "refBeginning", ")", ".", "append", "(", "\"00\"", ")", ".", "append", "(", "newMilli", ")", ".", "append", "(", "refEnding", ")", ";", "return", "sb", ".", "toString", "(", ")", ";", "}", "}", "catch", "(", "Exception", "e", ")", "{", "// Throw FFDC in case anything goes wrong", "// Still generate the date via the SimpleDateFormat", "invalidFormat", "=", "true", ";", "return", "formatter", ".", "format", "(", "timestamp", ")", ";", "}", "}" ]

[ "Formats", "a", "timestamp" ]

[ "private", "void", "setName", "(", "String", "newName", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "tc", ",", "\"setName\"", ",", "newName", ")", ";", "this", ".", "_name", "=", "newName", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"setName\"", ")", ";", "}" ]

[ "Sets", "the", "name", "currently", "in", "use", "by", "this", "localization", "." ]

[ "@", "Override", "public", "boolean", "isSendAllowed", "(", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "tc", ",", "\"isSendAllowed\"", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"isSendAllowed\"", ",", "new", "Boolean", "(", "_isSendAllowed", ")", ")", ";", "return", "_isSendAllowed", ";", "}" ]

[ "Gets", "the", "current", "value", "of", "SendAllowed", "used", "by", "this", "localization", "." ]

[ "public", "void", "setSendAllowed", "(", "boolean", "newIsSendAllowedValue", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "tc", ",", "\"setSendAllowed\"", ",", "new", "Boolean", "(", "newIsSendAllowedValue", ")", ")", ";", "this", ".", "_isSendAllowed", "=", "newIsSendAllowedValue", ";", "updatePutRegistration", "(", "_isSendAllowed", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"setSendAllowed\"", ")", ";", "}" ]

[ "Sets", "the", "current", "value", "of", "SendAllowed", "used", "by", "this", "localization", "." ]

[ "public", "void", "setAlterationTime", "(", "long", "newAlterationTime", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "tc", ",", "\"setAlterationTime\"", ",", "new", "Long", "(", "newAlterationTime", ")", ")", ";", "this", ".", "_alterationTime", "=", "newAlterationTime", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"setAlterationTime\"", ")", ";", "}" ]

[ "Sets", "the", "current", "alteration", "time", "fro", "this", "localization", "." ]

[ "public", "static", "void", "rcvDeleteDurableSub", "(", "CommsByteBuffer", "request", ",", "Conversation", "conversation", ",", "int", "requestNumber", ",", "boolean", "allocatedFromBufferPool", ",", "boolean", "partOfExchange", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "tc", ",", "\"rcvDeleteDurableSub\"", ",", "new", "Object", "[", "]", "{", "request", ",", "conversation", ",", "\"\"", "+", "requestNumber", ",", "\"\"", "+", "allocatedFromBufferPool", "}", ")", ";", "ConversationState", "convState", "=", "(", "ConversationState", ")", "conversation", ".", "getAttachment", "(", ")", ";", "short", "connectionObjectID", "=", "request", ".", "getShort", "(", ")", ";", "// BIT16 ConnectionObjectId", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "SibTr", ".", "debug", "(", "tc", ",", "\"ConnectionObjectId:\"", ",", "connectionObjectID", ")", ";", "/**************************************************************/", "/* Subscription Name */", "/**************************************************************/", "String", "subscriptionName", "=", "request", ".", "getString", "(", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "SibTr", ".", "debug", "(", "tc", ",", "\"Subscription Name:\"", ",", "subscriptionName", ")", ";", "/**************************************************************/", "/* Subscription Home */", "/**************************************************************/", "String", "subscriptionHome", "=", "request", ".", "getString", "(", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "SibTr", ".", "debug", "(", "tc", ",", "\"Subscription Home:\"", ",", "subscriptionHome", ")", ";", "SICoreConnection", "connection", "=", "(", "(", "CATConnection", ")", "convState", ".", "getObject", "(", "connectionObjectID", ")", ")", ".", "getSICoreConnection", "(", ")", ";", "try", "{", "connection", ".", "deleteDurableSubscription", "(", "subscriptionName", ",", "subscriptionHome", ")", ";", "try", "{", "conversation", ".", "send", "(", "poolManager", ".", "allocate", "(", ")", ",", "JFapChannelConstants", ".", "SEG_DELETE_DURABLE_SUB_R", ",", "requestNumber", ",", "JFapChannelConstants", ".", "PRIORITY_MEDIUM", ",", "true", ",", "ThrottlingPolicy", ".", "BLOCK_THREAD", ",", "null", ")", ";", "}", "catch", "(", "SIException", "e", ")", "{", "FFDCFilter", ".", "processException", "(", "e", ",", "CLASS_NAME", "+", "\".rcvDeleteDurableSub\"", ",", "CommsConstants", ".", "STATICCATSUBSCRIPTION_DELETE_01", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "SibTr", ".", "debug", "(", "tc", ",", "e", ".", "getMessage", "(", ")", ",", "e", ")", ";", "SibTr", ".", "error", "(", "tc", ",", "\"COMMUNICATION_ERROR_SICO2025\"", ",", "e", ")", ";", "}", "}", "catch", "(", "SINotAuthorizedException", "e", ")", "{", "// No FFDC Code Needed", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "SibTr", ".", "debug", "(", "tc", ",", "e", ".", "getMessage", "(", ")", ",", "e", ")", ";", "StaticCATHelper", ".", "sendExceptionToClient", "(", "e", ",", "null", ",", "conversation", ",", "requestNumber", ")", ";", "}", "catch", "(", "SIException", "e", ")", "{", "//No FFDC code needed", "//Only FFDC if we haven't received a meTerminated event.", "if", "(", "!", "convState", ".", "hasMETerminated", "(", ")", ")", "{", "com", ".", "ibm", ".", "ws", ".", "ffdc", ".", "FFDCFilter", ".", "processException", "(", "e", ",", "CLASS_NAME", "+", "\".rcvDeleteDurableSub\"", ",", "CommsConstants", ".", "STATICCATSUBSCRIPTION_DELETE_02", ")", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "SibTr", ".", "debug", "(", "tc", ",", "e", ".", "getMessage", "(", ")", ",", "e", ")", ";", "StaticCATHelper", ".", "sendExceptionToClient", "(", "e", ",", "CommsConstants", ".", "STATICCATSUBSCRIPTION_DELETE_02", ",", "conversation", ",", "requestNumber", ")", ";", "}", "request", ".", "release", "(", "allocatedFromBufferPool", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"rcvDeleteDurableSub\"", ")", ";", "}" ]

[ "Deletes", "a", "durable", "subscription" ]

[ "public", "static", "void", "main", "(", "String", "[", "]", "args", ")", "{", "Generator", "schemaGen", "=", "new", "Generator", "(", ")", ";", "System", ".", "exit", "(", "schemaGen", ".", "createSchema", "(", "args", ")", ")", ";", "}" ]

[ "The", "runtime", "main", ".", "String", "arguments", "are", "treated", "and", "parsed", "as", "command", "line", "parameters", "." ]

[ "private", "void", "generate", "(", "List", "<", "MetaTypeInformationSpecification", ">", "metatype", ")", "{", "XMLOutputFactory", "factory", "=", "XMLOutputFactory", ".", "newInstance", "(", ")", ";", "try", "{", "PrintWriter", "writer", "=", "new", "PrintWriter", "(", "generatorOptions", ".", "getOutputFile", "(", ")", ",", "generatorOptions", ".", "getEncoding", "(", ")", ")", ";", "XMLStreamWriter", "xmlWriter", "=", "null", ";", "if", "(", "generatorOptions", ".", "getCompactOutput", "(", ")", ")", "{", "xmlWriter", "=", "new", "CompactOutputXMLStreamWriter", "(", "factory", ".", "createXMLStreamWriter", "(", "writer", ")", ")", ";", "}", "else", "{", "xmlWriter", "=", "new", "IndentingXMLStreamWriter", "(", "factory", ".", "createXMLStreamWriter", "(", "writer", ")", ",", "writer", ")", ";", "}", "SchemaWriter", "schemaWriter", "=", "new", "SchemaWriter", "(", "xmlWriter", ")", ";", "schemaWriter", ".", "setIgnoredPids", "(", "generatorOptions", ".", "getIgnoredPids", "(", ")", ")", ";", "schemaWriter", ".", "setGenerateDocumentation", "(", "true", ")", ";", "schemaWriter", ".", "setEncoding", "(", "generatorOptions", ".", "getEncoding", "(", ")", ")", ";", "schemaWriter", ".", "setLocale", "(", "generatorOptions", ".", "getLocale", "(", ")", ")", ";", "schemaWriter", ".", "setSchemaVersion", "(", "generatorOptions", ".", "getSchemaVersion", "(", ")", ")", ";", "schemaWriter", ".", "setOutputVersion", "(", "generatorOptions", ".", "getOutputVersion", "(", ")", ")", ";", "for", "(", "MetaTypeInformationSpecification", "item", ":", "metatype", ")", "{", "schemaWriter", ".", "add", "(", "item", ")", ";", "}", "schemaWriter", ".", "generate", "(", "true", ")", ";", "}", "catch", "(", "RuntimeException", "e", ")", "{", "throw", "e", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "RuntimeException", "(", "e", ")", ";", "}", "}" ]

[ "Pass", "the", "constructed", "metatypinformation", "to", "SchemaWriter", "for", "the", "actual", "generation" ]

[ "void", "setField", "(", "int", "accessor", ",", "Object", "value", ")", "{", "try", "{", "jmfPart", ".", "setValue", "(", "accessor", ",", "value", ")", ";", "}", "catch", "(", "JMFException", "e", ")", "{", "FFDCFilter", ".", "processException", "(", "e", ",", "\"setField\"", ",", "\"87\"", ",", "this", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "SibTr", ".", "debug", "(", "this", ",", "tc", ",", "\"setField failed: \"", "+", "e", ")", ";", "}", "}" ]

[ "General", "field", "access" ]

[ "void", "setIntField", "(", "int", "accessor", ",", "int", "value", ")", "{", "try", "{", "jmfPart", ".", "setInt", "(", "accessor", ",", "value", ")", ";", "}", "catch", "(", "JMFException", "e", ")", "{", "FFDCFilter", ".", "processException", "(", "e", ",", "\"setIntField\"", ",", "\"109\"", ",", "this", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "SibTr", ".", "debug", "(", "this", ",", "tc", ",", "\"setIntField failed: \"", "+", "e", ")", ";", "}", "}" ]

[ "Convenience", "access", "to", "primitive", "type", "fields" ]

[ "void", "setChoiceField", "(", "int", "accessor", ",", "int", "variant", ")", "{", "try", "{", "jmfPart", ".", "setInt", "(", "accessor", ",", "variant", ")", ";", "}", "catch", "(", "JMFException", "e", ")", "{", "FFDCFilter", ".", "processException", "(", "e", ",", "\"setChoiceField\"", ",", "\"173\"", ",", "this", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "SibTr", ".", "debug", "(", "this", ",", "tc", ",", "\"setChoiceField failed: \"", "+", "e", ")", ";", "}", "}" ]

[ "Set", "a", "choice", "field", "to", "a", "specific", "variant" ]

[ "int", "getChoiceField", "(", "int", "accessor", ")", "{", "int", "result", "=", "0", ";", "try", "{", "if", "(", "jmfPart", ".", "isPresent", "(", "accessor", ")", ")", "result", "=", "jmfPart", ".", "getInt", "(", "accessor", ")", ";", "}", "catch", "(", "JMFException", "e", ")", "{", "FFDCFilter", ".", "processException", "(", "e", ",", "\"getChoiceField\"", ",", "\"185\"", ",", "this", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "SibTr", ".", "debug", "(", "this", ",", "tc", ",", "\"getChoiceField failed: \"", "+", "e", ")", ";", "}", "return", "result", ";", "}" ]

[ "Get", "a", "choice", "field", "which", "determines", "which", "variant", "is", "set" ]

[ "void", "setPart", "(", "int", "accessor", ",", "JMFSchema", "schema", ")", "{", "try", "{", "jmfPart", ".", "setValue", "(", "accessor", ",", "jmfPart", ".", "newNativePart", "(", "schema", ")", ")", ";", "}", "catch", "(", "JMFException", "e", ")", "{", "FFDCFilter", ".", "processException", "(", "e", ",", "\"setDynamicField\"", ",", "\"196\"", ",", "this", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "SibTr", ".", "debug", "(", "this", ",", "tc", ",", "\"setDynamicField failed: \"", "+", "e", ")", ";", "}", "}" ]

[ "Set", "a", "dynamic", "field", "to", "an", "empty", "message", "of", "appropriate", "type" ]

[ "JsMsgPart", "getPart", "(", "int", "accessor", ",", "JMFSchema", "schema", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"getPart\"", ",", "new", "Object", "[", "]", "{", "accessor", ",", "schema", "}", ")", ";", "JsMsgPart", "result", "=", "null", ";", "try", "{", "if", "(", "jmfPart", ".", "isPresent", "(", "accessor", ")", ")", "result", "=", "new", "JsMsgPart", "(", "jmfPart", ".", "getNativePart", "(", "accessor", ",", "schema", ")", ")", ";", "}", "catch", "(", "JMFException", "e", ")", "{", "FFDCFilter", ".", "processException", "(", "e", ",", "\"getPart\"", ",", "\"208\"", ",", "this", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "SibTr", ".", "debug", "(", "this", ",", "tc", ",", "\"getPart failed: \"", "+", "e", ")", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "this", ",", "tc", ",", "\"getPart\"", ",", "result", ")", ";", "return", "result", ";", "}" ]

[ "Obtain", "a", "nested", "message", "part" ]

[ "int", "estimateFieldValueSize", "(", "int", "accessor", ")", "{", "int", "size", "=", "0", ";", "try", "{", "if", "(", "jmfPart", ".", "isPresent", "(", "accessor", ")", ")", "{", "size", "=", "jmfPart", ".", "estimateUnassembledValueSize", "(", "accessor", ")", ";", "}", "}", "catch", "(", "JMFException", "e", ")", "{", "FFDCFilter", ".", "processException", "(", "e", ",", "\"estimateFieldValueSize\"", ",", "\"221\"", ",", "this", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "SibTr", ".", "debug", "(", "this", ",", "tc", ",", "\"estimateFieldValueSize failed: \"", "+", "e", ")", ";", "}", "return", "size", ";", "}" ]

[ "Get", "the", "estimated", "size", "of", "the", "fluffed", "=", "up", "value", "of", "the", "field" ]

[ "public", "boolean", "isNotEMPTYlist", "(", "int", "accessor", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"isNotEMPTYlist\"", ",", "accessor", ")", ";", "// The answer is true, unless an EMPTY is found.", "boolean", "isNotAnEMPTY", "=", "true", ";", "// The field can't be an EMPTY singleton unless the part is a JMFMessageData", "// as it is impossible for Encapsulations to hold an EMPTY.", "// Note the JMF call is the reverse - i.e. isEMPTY rather than isNot", "if", "(", "jmfPart", "instanceof", "JMFMessage", ")", "{", "isNotAnEMPTY", "=", "!", "(", "(", "JMFMessage", ")", "jmfPart", ")", ".", "isEMPTYlist", "(", "accessor", ")", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "this", ",", "tc", ",", "\"isNotEMPTYlist\"", ",", "isNotAnEMPTY", ")", ";", "return", "isNotAnEMPTY", ";", "}" ]

[ "isNotEMPTYlist", "Return", "false", "if", "the", "value", "of", "the", "given", "field", "is", "one", "of", "the", "singleton", "EMPTY", "lists", "otherwise", "true", "." ]

[ "public", "static", "final", "String", "construct", "(", "Object", "object", ",", "ExternalContext", "ctx", ")", "{", "byte", "[", "]", "bytes", "=", "getAsByteArray", "(", "object", ",", "ctx", ")", ";", "if", "(", "enableCompression", "(", "ctx", ")", ")", "{", "bytes", "=", "compress", "(", "bytes", ")", ";", "}", "if", "(", "isSecure", "(", "ctx", ")", ")", "{", "bytes", "=", "encrypt", "(", "bytes", ",", "ctx", ")", ";", "}", "bytes", "=", "encode", "(", "bytes", ")", ";", "try", "{", "return", "new", "String", "(", "bytes", ",", "ZIP_CHARSET", ")", ";", "}", "catch", "(", "UnsupportedEncodingException", "e", ")", "{", "throw", "new", "FacesException", "(", "e", ")", ";", "}", "}" ]

[ "This", "fires", "during", "the", "Render", "Response", "phase", "saving", "state", "." ]

[ "public", "static", "final", "byte", "[", "]", "getAsByteArray", "(", "Object", "object", ",", "ExternalContext", "ctx", ")", "{", "ByteArrayOutputStream", "outputStream", "=", "new", "ByteArrayOutputStream", "(", ")", ";", "// get the Factory that was instantiated @ startup", "SerialFactory", "serialFactory", "=", "(", "SerialFactory", ")", "ctx", ".", "getApplicationMap", "(", ")", ".", "get", "(", "SERIAL_FACTORY", ")", ";", "if", "(", "serialFactory", "==", "null", ")", "{", "throw", "new", "NullPointerException", "(", "\"serialFactory\"", ")", ";", "}", "try", "{", "ObjectOutputStream", "writer", "=", "serialFactory", ".", "getObjectOutputStream", "(", "outputStream", ")", ";", "writer", ".", "writeObject", "(", "object", ")", ";", "byte", "[", "]", "bytes", "=", "outputStream", ".", "toByteArray", "(", ")", ";", "writer", ".", "close", "(", ")", ";", "outputStream", ".", "close", "(", ")", ";", "writer", "=", "null", ";", "outputStream", "=", "null", ";", "return", "bytes", ";", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "new", "FacesException", "(", "e", ")", ";", "}", "}" ]

[ "Performs", "serialization", "with", "the", "serialization", "provider", "created", "by", "the", "SerialFactory", "." ]

[ "public", "static", "final", "Object", "reconstruct", "(", "String", "string", ",", "ExternalContext", "ctx", ")", "{", "byte", "[", "]", "bytes", ";", "try", "{", "if", "(", "log", ".", "isLoggable", "(", "Level", ".", "FINE", ")", ")", "{", "log", ".", "fine", "(", "\"Processing state : \"", "+", "string", ")", ";", "}", "bytes", "=", "string", ".", "getBytes", "(", "ZIP_CHARSET", ")", ";", "bytes", "=", "decode", "(", "bytes", ")", ";", "if", "(", "isSecure", "(", "ctx", ")", ")", "{", "bytes", "=", "decrypt", "(", "bytes", ",", "ctx", ")", ";", "}", "if", "(", "enableCompression", "(", "ctx", ")", ")", "{", "bytes", "=", "decompress", "(", "bytes", ")", ";", "}", "return", "getAsObject", "(", "bytes", ",", "ctx", ")", ";", "}", "catch", "(", "Throwable", "e", ")", "{", "if", "(", "log", ".", "isLoggable", "(", "Level", ".", "FINE", ")", ")", "{", "log", ".", "log", "(", "Level", ".", "FINE", ",", "\"View State cannot be reconstructed\"", ",", "e", ")", ";", "}", "return", "null", ";", "}", "}" ]

[ "This", "fires", "during", "the", "Restore", "View", "phase", "restoring", "state", "." ]

[ "public", "static", "final", "Object", "getAsObject", "(", "byte", "[", "]", "bytes", ",", "ExternalContext", "ctx", ")", "{", "ByteArrayInputStream", "input", "=", "null", ";", "try", "{", "input", "=", "new", "ByteArrayInputStream", "(", "bytes", ")", ";", "// get the Factory that was instantiated @ startup", "SerialFactory", "serialFactory", "=", "(", "SerialFactory", ")", "ctx", ".", "getApplicationMap", "(", ")", ".", "get", "(", "SERIAL_FACTORY", ")", ";", "if", "(", "serialFactory", "==", "null", ")", "{", "throw", "new", "NullPointerException", "(", "\"serialFactory\"", ")", ";", "}", "ObjectInputStream", "s", "=", "null", ";", "Exception", "pendingException", "=", "null", ";", "try", "{", "s", "=", "serialFactory", ".", "getObjectInputStream", "(", "input", ")", ";", "Object", "object", "=", "null", ";", "if", "(", "System", ".", "getSecurityManager", "(", ")", "!=", "null", ")", "{", "final", "ObjectInputStream", "ois", "=", "s", ";", "object", "=", "AccessController", ".", "doPrivileged", "(", "new", "PrivilegedExceptionAction", "<", "Object", ">", "(", ")", "{", "//Put IOException and ClassNotFoundException as \"checked\" exceptions,", "//so AccessController wrap them in a PrivilegedActionException", "public", "Object", "run", "(", ")", "throws", "PrivilegedActionException", ",", "IOException", ",", "ClassNotFoundException", "{", "return", "ois", ".", "readObject", "(", ")", ";", "}", "}", ")", ";", "// Since s has the same instance as ois,", "// we don't need to close it here, rather", "// close it on the finally block related to s", "// and avoid duplicate close exceptions", "// finally", "// {", "// ois.close();", "// }", "}", "else", "{", "object", "=", "s", ".", "readObject", "(", ")", ";", "}", "return", "object", ";", "}", "catch", "(", "Exception", "e", ")", "{", "pendingException", "=", "e", ";", "throw", "new", "FacesException", "(", "e", ")", ";", "}", "finally", "{", "if", "(", "s", "!=", "null", ")", "{", "try", "{", "s", ".", "close", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "// If a previous exception is thrown ", "// ignore this, but if not, wrap it in a", "// FacesException and throw it. In this way", "// we preserve the original semantic of this", "// method, but we handle correctly the case", "// when we close a stream. Obviously, the ", "// information about this exception is lost,", "// but note that the interesting information ", "// is always on pendingException, since we", "// only do a readObject() on the outer try block.", "if", "(", "pendingException", "==", "null", ")", "{", "throw", "new", "FacesException", "(", "e", ")", ";", "}", "}", "finally", "{", "s", "=", "null", ";", "}", "}", "}", "}", "finally", "{", "if", "(", "input", "!=", "null", ")", "{", "try", "{", "input", ".", "close", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "//ignore it, because ByteArrayInputStream.close has", "//no effect, but it is better to call close and preserve", "//semantic from previous code.", "}", "finally", "{", "input", "=", "null", ";", "}", "}", "}", "}" ]

[ "Performs", "deserialization", "with", "the", "serialization", "provider", "created", "from", "the", "SerialFactory", "." ]

[ "public", "static", "void", "main", "(", "String", "[", "]", "args", ")", "throws", "UnsupportedEncodingException", "{", "byte", "[", "]", "bytes", "=", "encode", "(", "args", "[", "0", "]", ".", "getBytes", "(", "ZIP_CHARSET", ")", ")", ";", "System", ".", "out", ".", "println", "(", "new", "String", "(", "bytes", ",", "ZIP_CHARSET", ")", ")", ";", "}" ]

[ "Utility", "method", "for", "generating", "base", "64", "encoded", "strings", "." ]

[ "public", "static", "void", "initSecret", "(", "ServletContext", "ctx", ")", "{", "if", "(", "ctx", "==", "null", ")", "{", "throw", "new", "NullPointerException", "(", "\"ServletContext ctx\"", ")", ";", "}", "if", "(", "log", ".", "isLoggable", "(", "Level", ".", "FINE", ")", ")", "{", "log", ".", "fine", "(", "\"Storing SecretKey @ \"", "+", "INIT_SECRET_KEY_CACHE", ")", ";", "}", "// Create and store SecretKey on application scope", "String", "cache", "=", "ctx", ".", "getInitParameter", "(", "INIT_SECRET_KEY_CACHE", ")", ";", "if", "(", "cache", "==", "null", ")", "{", "cache", "=", "ctx", ".", "getInitParameter", "(", "INIT_SECRET_KEY_CACHE", ".", "toLowerCase", "(", ")", ")", ";", "}", "if", "(", "!", "\"false\"", ".", "equals", "(", "cache", ")", ")", "{", "String", "algorithm", "=", "findAlgorithm", "(", "ctx", ")", ";", "// you want to create this as few times as possible", "ctx", ".", "setAttribute", "(", "INIT_SECRET_KEY_CACHE", ",", "new", "SecretKeySpec", "(", "findSecret", "(", "ctx", ",", "algorithm", ")", ",", "algorithm", ")", ")", ";", "}", "if", "(", "log", ".", "isLoggable", "(", "Level", ".", "FINE", ")", ")", "{", "log", ".", "fine", "(", "\"Storing SecretKey @ \"", "+", "INIT_MAC_SECRET_KEY_CACHE", ")", ";", "}", "String", "macCache", "=", "ctx", ".", "getInitParameter", "(", "INIT_MAC_SECRET_KEY_CACHE", ")", ";", "if", "(", "macCache", "==", "null", ")", "{", "macCache", "=", "ctx", ".", "getInitParameter", "(", "INIT_MAC_SECRET_KEY_CACHE", ".", "toLowerCase", "(", ")", ")", ";", "}", "if", "(", "!", "\"false\"", ".", "equals", "(", "macCache", ")", ")", "{", "String", "macAlgorithm", "=", "findMacAlgorithm", "(", "ctx", ")", ";", "// init mac secret and algorithm ", "ctx", ".", "setAttribute", "(", "INIT_MAC_SECRET_KEY_CACHE", ",", "new", "SecretKeySpec", "(", "findMacSecret", "(", "ctx", ",", "macAlgorithm", ")", ",", "macAlgorithm", ")", ")", ";", "}", "}" ]

[ "Does", "nothing", "if", "the", "user", "has", "disabled", "the", "SecretKey", "cache", ".", "This", "is", "useful", "when", "dealing", "with", "a", "JCA", "provider", "whose", "SecretKey", "implementation", "is", "not", "thread", "safe", "." ]

[ "private", "Map", "<", "String", ",", "String", ">", "getEnvironment", "(", ")", "{", "return", "AccessController", ".", "doPrivileged", "(", "new", "PrivilegedAction", "<", "Map", "<", "String", ",", "String", ">", ">", "(", ")", "{", "@", "Override", "public", "Map", "<", "String", ",", "String", ">", "run", "(", ")", "{", "return", "System", ".", "getenv", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Get", "the", "system", "environment", "variables", "in", "a", "doPrivileged", "block", "." ]

[ "public", "String", "getDefaultParentForEntityInRealm", "(", "String", "entType", ",", "String", "realmName", ")", "throws", "WIMException", "{", "String", "defaultParent", "=", "getDefaultParent", "(", "entType", ")", ";", "if", "(", "realmName", "!=", "null", ")", "{", "validateRealmName", "(", "realmName", ")", ";", "String", "parent", "=", "null", ";", "RealmConfig", "realmConfig", "=", "getRealmConfig", "(", "realmName", ")", ";", "Map", "defaultParentsMap", "=", "realmConfig", ".", "getDefaultParentMapping", "(", ")", ";", "if", "(", "defaultParentsMap", "!=", "null", ")", "{", "parent", "=", "(", "String", ")", "defaultParentsMap", ".", "get", "(", "entType", ")", ";", "if", "(", "parent", "!=", "null", ")", "{", "defaultParent", "=", "parent", ";", "}", "}", "if", "(", "parent", "==", "null", "&&", "!", "isUniqueNameInRealm", "(", "defaultParent", ",", "realmName", ")", ")", "{", "defaultParent", "=", "null", ";", "}", "}", "return", "defaultParent", ";", "}" ]

[ "Gets", "the", "default", "parent", "node", "that", "is", "for", "the", "specified", "entity", "type", "in", "specified", "realm", "." ]

[ "public", "String", "getDefaultParent", "(", "String", "entityTypeName", ")", "{", "SupportedEntityConfig", "entityConfig", "=", "entityTypeMap", ".", "get", "(", "entityTypeName", ")", ";", "if", "(", "entityConfig", "!=", "null", ")", "{", "return", "entityConfig", ".", "getDefaultParent", "(", ")", ";", "}", "return", "null", ";", "}" ]

[ "Returns", "the", "default", "parent", "for", "the", "given", "prefixed", "entity", "type", ".", "Entity", "types", "under", "WIM", "package", "should", "not", "have", "any", "name", "space", "prefix", ".", "For", "example", "Person", "." ]

[ "private", "<", "T", ">", "boolean", "processMethod", "(", "AnnotatedMethod", "<", "T", ">", "method", ",", "Class", "<", "?", ">", "clazz", ",", "Asynchronous", "classLevelAsync", ")", "{", "FTEnablementConfig", "config", "=", "FaultToleranceCDIComponent", ".", "getEnablementConfig", "(", ")", ";", "Method", "javaMethod", "=", "method", ".", "getJavaMember", "(", ")", ";", "if", "(", "javaMethod", ".", "isBridge", "(", ")", ")", "{", "// Skip all validation for bridge methods", "// Bridge methods are created when a class overrides a method but provides more specific return or parameter types", "// (usually when implementing a generic interface)", "// In these cases, the bridge method matches the signature of the overridden method after type erasure and delegates directly to the overriding method", "// In some cases, the signature of the overriding method is valid for some microprofile annotation, but the signature of the bridge method is not", "// However, the user's code is valid, and weld seems to make sure that any interceptors get called with the real method in the InvocationContext.", "return", "false", ";", "}", "if", "(", "classLevelAsync", "!=", "null", ")", "{", "AsynchronousConfig", "asynchronous", "=", "annotationConfigFactory", ".", "createAsynchronousConfig", "(", "javaMethod", ",", "clazz", ",", "classLevelAsync", ")", ";", "asynchronous", ".", "validate", "(", ")", ";", "}", "boolean", "needsIntercepting", "=", "false", ";", "Set", "<", "Annotation", ">", "annotations", "=", "method", ".", "getAnnotations", "(", ")", ";", "for", "(", "Annotation", "annotation", ":", "annotations", ")", "{", "if", "(", "config", ".", "isFaultTolerance", "(", "annotation", ")", ")", "{", "if", "(", "config", ".", "isAnnotationEnabled", "(", "annotation", ",", "clazz", ",", "method", ".", "getJavaMember", "(", ")", ")", ")", "{", "needsIntercepting", "=", "true", ";", "if", "(", "annotation", ".", "annotationType", "(", ")", "==", "Asynchronous", ".", "class", ")", "{", "AsynchronousConfig", "asynchronous", "=", "annotationConfigFactory", ".", "createAsynchronousConfig", "(", "javaMethod", ",", "clazz", ",", "(", "Asynchronous", ")", "annotation", ")", ";", "asynchronous", ".", "validate", "(", ")", ";", "}", "else", "if", "(", "annotation", ".", "annotationType", "(", ")", "==", "Fallback", ".", "class", ")", "{", "FallbackConfig", "fallback", "=", "new", "FallbackConfig", "(", "javaMethod", ",", "clazz", ",", "(", "Fallback", ")", "annotation", ")", ";", "fallback", ".", "validate", "(", ")", ";", "}", "else", "if", "(", "annotation", ".", "annotationType", "(", ")", "==", "Retry", ".", "class", ")", "{", "RetryConfig", "retry", "=", "new", "RetryConfig", "(", "javaMethod", ",", "clazz", ",", "(", "Retry", ")", "annotation", ")", ";", "retry", ".", "validate", "(", ")", ";", "}", "else", "if", "(", "annotation", ".", "annotationType", "(", ")", "==", "Timeout", ".", "class", ")", "{", "TimeoutConfig", "timeout", "=", "new", "TimeoutConfig", "(", "javaMethod", ",", "clazz", ",", "(", "Timeout", ")", "annotation", ")", ";", "timeout", ".", "validate", "(", ")", ";", "}", "else", "if", "(", "annotation", ".", "annotationType", "(", ")", "==", "CircuitBreaker", ".", "class", ")", "{", "CircuitBreakerConfig", "circuitBreaker", "=", "new", "CircuitBreakerConfig", "(", "javaMethod", ",", "clazz", ",", "(", "CircuitBreaker", ")", "annotation", ")", ";", "circuitBreaker", ".", "validate", "(", ")", ";", "}", "else", "if", "(", "annotation", ".", "annotationType", "(", ")", "==", "Bulkhead", ".", "class", ")", "{", "BulkheadConfig", "bulkhead", "=", "new", "BulkheadConfig", "(", "javaMethod", ",", "clazz", ",", "(", "Bulkhead", ")", "annotation", ")", ";", "bulkhead", ".", "validate", "(", ")", ";", "}", "}", "else", "{", "if", "(", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"Annotation {0} on {1} was disabled and will be ignored\"", ",", "annotation", ".", "annotationType", "(", ")", ".", "getSimpleName", "(", ")", ",", "clazz", ".", "getCanonicalName", "(", ")", "+", "\".\"", "+", "method", ".", "getJavaMember", "(", ")", ".", "getName", "(", ")", ")", ";", "}", "}", "}", "}", "return", "needsIntercepting", ";", "}" ]

[ "Validate", "a", "method", "and", "return", "whether", "it", "has", "fault", "tolerance", "annotations", "which", "require", "us", "to", "add", "the", "FT", "interceptor" ]

[ "public", "static", "final", "void", "setServerName", "(", "String", "name", ")", "{", "if", "(", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"setServerName\"", ",", "name", ")", ";", "// Store the server name.", "serverName", "=", "name", ";", "}" ]

[ "Sets", "the", "name", "of", "the", "server", "." ]

[ "public", "static", "final", "boolean", "isRecoverable", "(", ")", "{", "if", "(", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "entry", "(", "tc", ",", "\"isRecoverable\"", ")", ";", "// This JTS is recoverable if there is a server name.", "// boolean result = (serverName != null);", "// JTA2 - we are recoverable if we have a working log...", "// We can have a serverName but no working log either because", "// a) the log config or store is invalid", "// b) the log config indicates no logging.", "//", "boolean", "result", "=", "false", ";", "if", "(", "_failureScopeController", "!=", "null", ")", "{", "result", "=", "(", "_failureScopeController", ".", "getTransactionLog", "(", ")", "!=", "null", ")", ";", "}", "if", "(", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "exit", "(", "tc", ",", "\"isRecoverable\"", ",", "Boolean", ".", "valueOf", "(", "result", ")", ")", ";", "return", "result", ";", "}" ]

[ "Determines", "whether", "the", "JTS", "instance", "is", "recoverable", "." ]

[ "public", "static", "final", "void", "setCurrentEpoch", "(", "int", "number", ")", "{", "if", "(", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"setCurrentEpoch\"", ",", "number", ")", ";", "currentEpoch", "=", "number", ";", "}" ]

[ "Sets", "the", "current", "epoch", "value", "for", "this", "server", "instance", "." ]

[ "public", "static", "final", "void", "setApplId", "(", "byte", "[", "]", "name", ")", "{", "if", "(", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"setApplId\"", ",", "name", ")", ";", "// Store the applId.", "applId", "=", "name", ";", "}" ]

[ "Sets", "the", "applId", "of", "the", "server", "." ]

[ "protected", "ConversionStatus", "convertCompatible", "(", "String", "rawString", ",", "Class", "<", "?", ">", "type", ")", "{", "ConversionStatus", "status", "=", "new", "ConversionStatus", "(", ")", ";", "for", "(", "PriorityConverter", "con", ":", "converters", ".", "getAll", "(", ")", ")", "{", "Type", "key", "=", "con", ".", "getType", "(", ")", ";", "if", "(", "key", "instanceof", "Class", ")", "{", "Class", "<", "?", ">", "clazz", "=", "(", "Class", "<", "?", ">", ")", "key", ";", "if", "(", "type", ".", "isAssignableFrom", "(", "clazz", ")", ")", "{", "Object", "converted", "=", "convert", "(", "rawString", ",", "key", ")", ";", "status", ".", "setConverted", "(", "converted", ")", ";", "break", ";", "}", "}", "else", "if", "(", "key", "instanceof", "TypeVariable", ")", "{", "TypeVariable", "<", "?", ">", "typeVariable", "=", "(", "TypeVariable", "<", "?", ">", ")", "key", ";", "status", "=", "convertGenericClazz", "(", "rawString", ",", "type", ",", "typeVariable", ")", ";", "if", "(", "status", ".", "isConverterFound", "(", ")", ")", "{", "break", ";", "}", "}", "}", "return", "status", ";", "}" ]

[ "Converts", "from", "String", "based", "on", "isAssignableFrom", "or", "instanceof" ]

[ "public", "<", "T", ">", "T", "[", "]", "convertArray", "(", "String", "rawString", ",", "Class", "<", "T", ">", "arrayType", ")", "{", "String", "[", "]", "elements", "=", "split", "(", "rawString", ")", ";", "T", "[", "]", "array", "=", "convertArray", "(", "elements", ",", "arrayType", ")", ";", "return", "array", ";", "}" ]

[ "Apply", "convert", "across", "an", "array" ]

[ "public", "static", "Class", "toClass", "(", "String", "type", ",", "ClassLoader", "loader", ")", "throws", "ClassNotFoundException", "{", "if", "(", "com", ".", "ibm", ".", "ejs", ".", "ras", ".", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "logger", ".", "isLoggable", "(", "Level", ".", "FINER", ")", ")", "{", "logger", ".", "logp", "(", "Level", ".", "FINER", ",", "CLASS_NAME", ",", "\"toClass(String, ClassLoader)\"", ",", "\" type= [\"", "+", "type", "+", "\"] loader= [\"", "+", "loader", "+", "\"]\"", ")", ";", "}", "Class", "c", "=", "null", ";", "int", "i0", "=", "type", ".", "indexOf", "(", "'", "'", ")", ";", "int", "dims", "=", "0", ";", "if", "(", "i0", ">", "0", ")", "{", "// This is an array. Count the dimensions", "for", "(", "int", "i", "=", "0", ";", "i", "<", "type", ".", "length", "(", ")", ";", "i", "++", ")", "{", "if", "(", "type", ".", "charAt", "(", "i", ")", "==", "'", "'", ")", "dims", "++", ";", "}", "type", "=", "type", ".", "substring", "(", "0", ",", "i0", ")", ";", "}", "else", "if", "(", "i0", "==", "0", ")", "{", "//PM12828 start", "//check for a type like this \"[Lcom.ibm.sample.TagsAttr;\" This means it is an array type.", "//a two dimensional array might look like [[Lcom.ibm.sample.TagsAttr;", "int", "bracketL", "=", "type", ".", "indexOf", "(", "\"[L\"", ")", ";", "if", "(", "bracketL", ">", "-", "1", "&&", "type", ".", "endsWith", "(", "\";\"", ")", ")", "{", "type", "=", "type", ".", "substring", "(", "bracketL", "+", "2", ",", "(", "type", ".", "length", "(", ")", "-", "1", ")", ")", ";", "dims", "+=", "(", "bracketL", "+", "1", ")", ";", "}", "}", "//PM12828 end", "if", "(", "\"boolean\"", ".", "equals", "(", "type", ")", ")", "c", "=", "boolean", ".", "class", ";", "else", "if", "(", "\"char\"", ".", "equals", "(", "type", ")", ")", "c", "=", "char", ".", "class", ";", "else", "if", "(", "\"byte\"", ".", "equals", "(", "type", ")", ")", "c", "=", "byte", ".", "class", ";", "else", "if", "(", "\"short\"", ".", "equals", "(", "type", ")", ")", "c", "=", "short", ".", "class", ";", "else", "if", "(", "\"int\"", ".", "equals", "(", "type", ")", ")", "c", "=", "int", ".", "class", ";", "else", "if", "(", "\"long\"", ".", "equals", "(", "type", ")", ")", "c", "=", "long", ".", "class", ";", "else", "if", "(", "\"float\"", ".", "equals", "(", "type", ")", ")", "c", "=", "float", ".", "class", ";", "else", "if", "(", "\"double\"", ".", "equals", "(", "type", ")", ")", "c", "=", "double", ".", "class", ";", "else", "if", "(", "\"void\"", ".", "equals", "(", "type", ")", ")", "{", "return", "Void", ".", "class", ";", "}", "else", "if", "(", "type", ".", "indexOf", "(", "'", "'", ")", "<", "0", ")", "c", "=", "loader", ".", "loadClass", "(", "type", ")", ";", "if", "(", "dims", "==", "0", ")", "return", "c", ";", "if", "(", "dims", "==", "1", ")", "return", "java", ".", "lang", ".", "reflect", ".", "Array", ".", "newInstance", "(", "c", ",", "1", ")", ".", "getClass", "(", ")", ";", "// Array of more than i dimension", "return", "java", ".", "lang", ".", "reflect", ".", "Array", ".", "newInstance", "(", "c", ",", "new", "int", "[", "dims", "]", ")", ".", "getClass", "(", ")", ";", "}" ]

[ "PM12828", "-", "need", "to", "account", "for", "a", "case", "where", "type", "is", "[", "Lcom", ".", "ibm", ".", "sample", ".", "TagsAttr", ";" ]

[ "@", "Override", "public", "Facelet", "getFacelet", "(", "URL", "url", ")", "throws", "IOException", ",", "FaceletException", ",", "FacesException", ",", "ELException", "{", "return", "_faceletCache", ".", "getFacelet", "(", "url", ")", ";", "}" ]

[ "Create", "a", "Facelet", "from", "the", "passed", "URL", ".", "This", "method", "checks", "if", "the", "cached", "Facelet", "needs", "to", "be", "refreshed", "before", "returning", ".", "If", "so", "uses", "the", "passed", "URL", "to", "build", "a", "new", "instance", ";" ]

[ "private", "String", "_removeFirst", "(", "String", "string", ",", "String", "toRemove", ")", "{", "// do exactly what String.replaceFirst(toRemove, \"\") internally does,", "// except treating the search as literal text and not as regex", "return", "Pattern", ".", "compile", "(", "toRemove", ",", "Pattern", ".", "LITERAL", ")", ".", "matcher", "(", "string", ")", ".", "replaceFirst", "(", "\"\"", ")", ";", "}" ]

[ "Removes", "the", "first", "appearance", "of", "toRemove", "in", "string", "." ]

[ "@", "Override", "protected", "void", "initialize", "(", "boolean", "reactivate", ")", "throws", "RemoteException", ",", "InvocationTargetException", "{", "final", "boolean", "isTraceOn", "=", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", ";", "if", "(", "isTraceOn", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "{", "Tr", ".", "entry", "(", "tc", ",", "\"initialize\"", ")", ";", "}", "BeanMetaData", "bmd", "=", "home", ".", "beanMetaData", ";", "ivCallbackKind", "=", "bmd", ".", "ivCallbackKind", ";", "state", "=", "PRE_CREATE", ";", "// d159152", "CallbackContextHelper", "contextHelper", "=", "new", "CallbackContextHelper", "(", "this", ")", ";", "// d630940", "try", "{", "// Disallow setRollbackOnly until create is done.", "allowRollbackOnly", "=", "false", ";", "// Set the BeanId for this MDB. Just like we do for SLSB,", "// we use the BeanId for the home bean so that the same ID", "// is used for all MDB instances. Note the ivStatelessId is", "// for the home bean, which is implemented as a SLSB.", "if", "(", "home", "!=", "null", ")", "{", "setId", "(", "home", ".", "ivStatelessId", ")", ";", "// d140003.12", "}", "// Note that the local transaction surrounds injection methods and", "// PostConstruct lifecycle callbacks.", "contextHelper", ".", "begin", "(", "CallbackContextHelper", ".", "Tx", ".", "CompatLTC", ",", "CallbackContextHelper", ".", "Contexts", ".", "CallbackBean", ")", ";", "// d630940", "InterceptorMetaData", "imd", "=", "bmd", ".", "ivInterceptorMetaData", ";", "createInterceptorsAndInstance", "(", "contextHelper", ")", ";", "// Now set the MessageDrivenContext and/or do the dependency injection.", "// Note that dependency injection must occur while in PRE_CREATE state.", "injectInstance", "(", "ivManagedObject", ",", "ivEjbInstance", ",", "this", ")", ";", "//---------------------------------------------------------", "// Now that the MessageDrivenContext is set and/or dependencies", "// injection has occured, change state to CREATING state to allow", "// additional methods to be called by the ejbCreate or", "// PostConstruct interceptor methods (e.g. getEJBObject).", "//---------------------------------------------------------", "setState", "(", "CREATING", ")", ";", "//d399469.2", "// Determine of life cycle callback to make if any.", "if", "(", "ivCallbackKind", "==", "CallbackKind", ".", "MessageDrivenBean", ")", "{", "Method", "m", "=", "bmd", ".", "ivEjbCreateMethod", ";", "//d453778", "if", "(", "m", "!=", "null", ")", "//d453778", "{", "// This is a 2.x MDB that has a ejbCreate method in it.", "try", "{", "if", "(", "isTraceOn", "&&", "// d527372", "TEBeanLifeCycleInfo", ".", "isTraceEnabled", "(", ")", ")", "{", "TEBeanLifeCycleInfo", ".", "traceEJBCallEntry", "(", "\"ejbCreate\"", ")", ";", "}", "m", ".", "invoke", "(", "ivEjbInstance", ",", "new", "Object", "[", "]", "{", "}", ")", ";", "}", "catch", "(", "InvocationTargetException", "itex", ")", "{", "//FFDCFilter.processException(itex, CLASS_NAME + \".MessageDrivenBeanO\", \"96\", this);", "// All exceptions returned through a reflect method call", "// are wrapped... making it difficult to debug a problem", "// since InovcationTargetException does not print the root", "// exception. Unwrap the 'target' exception so that the", "// client will see it as the cause of the", "// CreateFailureException. d534353.1", "Throwable", "targetEx", "=", "itex", ".", "getCause", "(", ")", ";", "if", "(", "targetEx", "==", "null", ")", "targetEx", "=", "itex", ";", "// MDB 2.x is allowed to throw application exceptions as well as", "// javax.ejb.CreateException. Continue to wrap with a CreateFailureException", "// to ensure no behavior change with prior releases.", "if", "(", "isTraceOn", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"MDB ejbCreate failure\"", ",", "targetEx", ")", ";", "}", "throw", "new", "CreateFailureException", "(", "targetEx", ")", ";", "}", "catch", "(", "Throwable", "ex", ")", "{", "//FFDCFilter.processException(ex, CLASS_NAME + \".MessageDrivenBeanO\", \"96\", this);", "// MDB 2.x is allowed to throw application exceptions as well as", "// javax.ejb.CreateException. Continue to wrap with a CreateFailureException", "// to ensure no behavior change with prior releases.", "if", "(", "isTraceOn", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"MDB ejbCreate failure\"", ",", "ex", ")", ";", "}", "throw", "new", "CreateFailureException", "(", "ex", ")", ";", "}", "finally", "{", "if", "(", "isTraceOn", "&&", "// d527372", "TEBeanLifeCycleInfo", ".", "isTraceEnabled", "(", ")", ")", "{", "TEBeanLifeCycleInfo", ".", "traceEJBCallExit", "(", "\"ejbCreate\"", ")", ";", "}", "}", "}", "}", "else", "if", "(", "ivCallbackKind", "==", "CallbackKind", ".", "InvocationContext", ")", "{", "// This is a MDB 3 that may have one or more PostConstruct interceptors", "// methods. Invoke PostContruct interceptors if there is atleast 1", "// PostConstruct interceptor.", "try", "{", "if", "(", "imd", "!=", "null", ")", "// d402681", "{", "InterceptorProxy", "[", "]", "proxies", "=", "imd", ".", "ivPostConstructInterceptors", ";", "if", "(", "proxies", "!=", "null", ")", "{", "if", "(", "isTraceOn", "&&", "// d527372", "TEBeanLifeCycleInfo", ".", "isTraceEnabled", "(", ")", ")", "{", "TEBeanLifeCycleInfo", ".", "traceEJBCallEntry", "(", "\"PostConstruct\"", ")", ";", "}", "InvocationContextImpl", "<", "?", ">", "inv", "=", "getInvocationContext", "(", ")", ";", "inv", ".", "doLifeCycle", "(", "proxies", ",", "bmd", ".", "_moduleMetaData", ")", ";", "//d450431, F743-14982", "}", "}", "}", "catch", "(", "Throwable", "t", ")", "{", "//FFDCFilter.processException(t, CLASS_NAME + \".MessageDrivenBeanO\", \"281\", this);", "// PostConstruct interceptors are allowed to throw system runtime exceptions,", "// but NOT application exceptions. Therefore, wrap the caught Throwable", "// in a javax.ejb.EJBException so that it gets handled as an unchecked", "// exception.", "if", "(", "isTraceOn", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"MDB PostConstruct failure\"", ",", "t", ")", ";", "}", "throw", "ExceptionUtil", ".", "EJBException", "(", "\"MDB PostConstruct failure\"", ",", "t", ")", ";", "}", "finally", "{", "if", "(", "isTraceOn", "&&", "// d527372", "TEBeanLifeCycleInfo", ".", "isTraceEnabled", "(", ")", "&&", "imd", "!=", "null", "&&", "imd", ".", "ivPostConstructInterceptors", "!=", "null", ")", "{", "TEBeanLifeCycleInfo", ".", "traceEJBCallExit", "(", "\"PostConstruct\"", ")", ";", "}", "}", "}", "// d367572.1 end", "//---------------------------------------------------------", "// Now that create has completed, allow setRollbackOnly to", "// be called on the SessionContext and change state to the", "// POOLED state to indicate the MDB is in the method-ready", "// pool state and message listener methods are now allowed to be", "// invoked on this MDB.", "//---------------------------------------------------------", "allowRollbackOnly", "=", "true", ";", "setState", "(", "POOLED", ")", ";", "}", "finally", "// d399469", "{", "contextHelper", ".", "complete", "(", "true", ")", ";", "}", "if", "(", "isTraceOn", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "{", "Tr", ".", "exit", "(", "tc", ",", "\"initialize\"", ")", ";", "}", "}" ]

[ "d399469", ".", "2", "-", "added", "entire", "method", "." ]

[ "@", "Override", "public", "void", "discard", "(", ")", "{", "final", "boolean", "isTraceOn", "=", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", ";", "if", "(", "isTraceOn", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "{", "Tr", ".", "entry", "(", "tc", ",", "\"discard\"", ")", ";", "}", "discarded", "=", "true", ";", "if", "(", "state", "==", "DESTROYED", ")", "{", "return", ";", "}", "setState", "(", "DESTROYED", ")", ";", "destroyHandleList", "(", ")", ";", "// Release any JCDI creational contexts that may exist. F743-29174", "this", ".", "releaseManagedObjectContext", "(", ")", ";", "if", "(", "pmiBean", "!=", "null", ")", "{", "pmiBean", ".", "discardCount", "(", ")", ";", "// F743-27070", "pmiBean", ".", "beanDestroyed", "(", ")", ";", "}", "if", "(", "isTraceOn", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "{", "Tr", ".", "exit", "(", "tc", ",", "\"discard\"", ")", ";", "}", "}" ]

[ "167937", "-", "rewrote", "entire", "method", "." ]

[ "@", "Override", "public", "final", "void", "remove", "(", ")", "throws", "RemoteException", ",", "RemoveException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"remove\"", ")", ";", "throw", "new", "InvalidBeanOStateException", "(", "StateStrs", "[", "state", "]", ",", "\"NONE\"", "+", "\": Msg Bean remove not allowed\"", ")", ";", "}" ]

[ "This", "method", "should", "never", "really", "get", "invoked", "for", "message", "driven", "beans", "there", "is", "no", "home", "interface", "on", "which", "to", "invoke", "it", "." ]

[ "@", "Override", "public", "int", "getIsolationLevel", "(", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"getIsolationLevel : \"", "+", "currentIsolationLevel", ")", ";", "return", "currentIsolationLevel", ";", "}" ]

[ "Get", "isolation", "level", "currently", "associated", "with", "this", "session", "bean", "instance", ".", "This", "is", "used", "for", "determining", "the", "isolation", "level", "to", "use", "in", "a", "bean", "managed", "transaction", "." ]

[ "@", "Override", "public", "synchronized", "UserTransaction", "getUserTransaction", "(", ")", "{", "final", "boolean", "isTraceOn", "=", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", ";", "if", "(", "isTraceOn", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "entry", "(", "tc", ",", "\"getUserTransaction\"", ")", ";", "// Calling getUserTransaction is not allowed from setMessageDrivenContext", "// per the EJB Specification. d159152", "if", "(", "(", "state", "==", "PRE_CREATE", ")", ")", "{", "IllegalStateException", "ise", ";", "ise", "=", "new", "IllegalStateException", "(", "\"MessageDrivenBean: getUserTransaction \"", "+", "\"not allowed from state = \"", "+", "getStateName", "(", "state", ")", ")", ";", "if", "(", "isTraceOn", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "exit", "(", "tc", ",", "\"getUserTransaction\"", ",", "ise", ")", ";", "throw", "ise", ";", "}", "UserTransaction", "userTransactionWrapper", "=", "UserTransactionWrapper", ".", "INSTANCE", ";", "// d631349", "if", "(", "isTraceOn", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "exit", "(", "tc", ",", "\"getUserTransaction\"", ",", "userTransactionWrapper", ")", ";", "return", "userTransactionWrapper", ";", "}" ]

[ "Get", "user", "transaction", "object", "bean", "can", "use", "to", "demarcate", "transactions" ]

[ "@", "Override", "public", "EJBHome", "getEJBHome", "(", ")", "//d116376", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"getEJBHome\"", ")", ";", "Tr", ".", "error", "(", "tc", ",", "\"METHOD_NOT_ALLOWED_CNTR0047E\"", ",", "\"MessageDrivenBeanO.getEJBHome()\"", ")", ";", "throw", "new", "IllegalStateException", "(", "\"Method Not Allowed Exception: See Message-drive Bean Component Contract section of the applicable EJB Specification.\"", ")", ";", "}" ]

[ "getEJBHome", "-", "It", "is", "illegal", "to", "call", "this", "method", "message", "-", "driven", "bean", "methods", "because", "there", "is", "no", "EJBHome", "object", "for", "message", "-", "driven", "beans", "." ]

[ "@", "Override", "public", "EJBLocalHome", "getEJBLocalHome", "(", ")", "//d116376", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"getEJBLocalHome\"", ")", ";", "Tr", ".", "error", "(", "tc", ",", "\"METHOD_NOT_ALLOWED_CNTR0047E\"", ",", "\"MessageDrivenBeanO.getEJBLocalHome()\"", ")", ";", "throw", "new", "IllegalStateException", "(", "\"Method Not Allowed Exception: See Message-drive Bean Component Contract section of the applicable EJB Specification.\"", ")", ";", "}" ]

[ "getEJBLocalHome", "-", "It", "is", "illegal", "to", "call", "this", "method", "message", "-", "driven", "bean", "methods", "because", "there", "is", "no", "EJBLocalHome", "object", "for", "message", "-", "driven", "beans", "." ]

[ "synchronized", "void", "updateRegistration", "(", "BundleContext", "ctx", ")", "{", "if", "(", "registration", "==", "null", ")", "{", "registration", "=", "ctx", ".", "registerService", "(", "KeystoreConfig", ".", "class", ",", "this", ",", "properties", ")", ";", "}", "else", "{", "registration", ".", "setProperties", "(", "properties", ")", ";", "}", "}" ]

[ "Register", "this", "as", "a", "service", "in", "the", "service", "registry", ".", "Package", "private", "." ]

[ "private", "String", "taskHelp", "(", "SecurityUtilityTask", "task", ")", "{", "StringBuffer", "taskUsage", "=", "new", "StringBuffer", "(", "NL", ")", ";", "taskUsage", ".", "append", "(", "task", ".", "getTaskHelp", "(", ")", ")", ";", "taskUsage", ".", "append", "(", "NL", ")", ";", "return", "taskUsage", ".", "toString", "(", ")", ";", "}" ]

[ "Constructs", "a", "string", "to", "represent", "the", "help", "for", "a", "particular", "task", "." ]

[ "private", "Object", "getComponentProperty", "(", "_PropertyDescriptorHolder", "propertyDescriptor", ")", "{", "Method", "readMethod", "=", "propertyDescriptor", ".", "getReadMethod", "(", ")", ";", "if", "(", "readMethod", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Component property \"", "+", "propertyDescriptor", ".", "getName", "(", ")", "+", "\" is not readable\"", ")", ";", "}", "try", "{", "return", "readMethod", ".", "invoke", "(", "_component", ",", "EMPTY_ARGS", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "FacesContext", "facesContext", "=", "_component", ".", "getFacesContext", "(", ")", ";", "throw", "new", "FacesException", "(", "\"Could not get property \"", "+", "propertyDescriptor", ".", "getName", "(", ")", "+", "\" of component \"", "+", "_component", ".", "getClientId", "(", "facesContext", ")", ",", "e", ")", ";", "}", "}" ]

[ "Execute", "the", "getter", "method", "of", "the", "specified", "property", "on", "the", "underlying", "component", "." ]

[ "private", "void", "setComponentProperty", "(", "_PropertyDescriptorHolder", "propertyDescriptor", ",", "Object", "value", ")", "{", "Method", "writeMethod", "=", "propertyDescriptor", ".", "getWriteMethod", "(", ")", ";", "if", "(", "writeMethod", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Component property \"", "+", "propertyDescriptor", ".", "getName", "(", ")", "+", "\" is not writable\"", ")", ";", "}", "try", "{", "writeMethod", ".", "invoke", "(", "_component", ",", "new", "Object", "[", "]", "{", "value", "}", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "FacesContext", "facesContext", "=", "_component", ".", "getFacesContext", "(", ")", ";", "throw", "new", "FacesException", "(", "\"Could not set property \"", "+", "propertyDescriptor", ".", "getName", "(", ")", "+", "\" of component \"", "+", "_component", ".", "getClientId", "(", "facesContext", ")", "+", "\" to value : \"", "+", "value", "+", "\" with type : \"", "+", "(", "value", "==", "null", "?", "\"null\"", ":", "value", ".", "getClass", "(", ")", ".", "getName", "(", ")", ")", ",", "e", ")", ";", "}", "}" ]

[ "Execute", "the", "setter", "method", "of", "the", "specified", "property", "on", "the", "underlying", "component", "." ]

[ "public", "EndpointInfo", "build", "(", "EndpointInfoBuilderContext", "ctx", ",", "String", "serviceImplBeanClassName", ",", "EndpointType", "endpointType", ")", "throws", "UnableToAdaptException", "{", "EndpointInfo", "endpointInfo", "=", "new", "EndpointInfo", "(", "serviceImplBeanClassName", ",", "endpointType", ")", ";", "endpointInfo", ".", "setBeanName", "(", "(", "String", ")", "ctx", ".", "getContextEnv", "(", "JaxWsConstants", ".", "ENV_ATTRIBUTE_ENDPOINT_BEAN_NAME", ")", ")", ";", "endpointInfo", ".", "setServletName", "(", "(", "String", ")", "ctx", ".", "getContextEnv", "(", "JaxWsConstants", ".", "ENV_ATTRIBUTE_ENDPOINT_SERVLET_NAME", ")", ")", ";", "invokeConfigurators", "(", "ctx", ",", "ConfigMethod", ".", "PREPARE", ",", "endpointInfo", ")", ";", "invokeConfigurators", "(", "ctx", ",", "ConfigMethod", ".", "CONFIG", ",", "endpointInfo", ")", ";", "validate", "(", "ctx", ",", "endpointInfo", ")", ";", "ctx", ".", "clearContextEnv", "(", ")", ";", "return", "endpointInfo", ";", "}" ]

[ "build", "the", "endpointInfo" ]

[ "public", "void", "addSubscriber", "(", "Handler", "handler", ")", "{", "String", "handlerId", "=", "CollectorManagerUtils", ".", "getHandlerId", "(", "handler", ")", ";", "//temporary exception for audit Source //must change later", "if", "(", "source", ".", "getSourceName", "(", ")", ".", "trim", "(", ")", ".", "equals", "(", "\"audit\"", ")", "&&", "subscribers", ".", "isEmpty", "(", ")", ")", "{", "//First subscriber, assign a buffer.", "bufferMgr", "=", "new", "BufferManagerImpl", "(", "BUFFER_SIZE", ",", "sourceId", ",", "false", ")", ";", "//Inform the source that a buffer is now available", "//and it can start sending events to this buffer.", "source", ".", "setBufferManager", "(", "this", ".", "bufferMgr", ")", ";", "}", "subscribers", ".", "add", "(", "handlerId", ")", ";", "/*\n * Inform the handler that this source/buffer/conduit is now available:\n * Synchronous Handler - Add handler as synchronous handler to the Buffer/Conduit's sync handler set\n * Asynchronous Handler - Add handler as asynchronous handler into the Buffer/Conduit\n *\n */", "if", "(", "handler", "instanceof", "SynchronousHandler", ")", "{", "bufferMgr", ".", "addSyncHandler", "(", "(", "SynchronousHandler", ")", "handler", ")", ";", "}", "else", "{", "bufferMgr", ".", "addHandler", "(", "handlerId", ")", ";", "}", "}" ]

[ "Method", "to", "add", "a", "subscriber", "to", "the", "source", "Source", "manager", "will", "allocate", "a", "buffer", "when", "the", "source", "has", "atleast", "one", "subscriber", "." ]

[ "public", "boolean", "removeSubscriber", "(", "Handler", "handler", ")", "{", "String", "handlerId", "=", "CollectorManagerUtils", ".", "getHandlerId", "(", "handler", ")", ";", "subscribers", ".", "remove", "(", "handlerId", ")", ";", "/*\n * Inform the handler that this source/buffer will no longer be available:\n * Synchronous Handler: Remove the synchronous handler from the Buffer/Conduit's sync handler set\n * Asynchronous Handler: Remove the asynchronous handler from the the Buffer/Conduit\n */", "if", "(", "handler", "instanceof", "SynchronousHandler", ")", "{", "bufferMgr", ".", "removeSyncHandler", "(", "(", "SynchronousHandler", ")", "handler", ")", ";", "}", "else", "{", "bufferMgr", ".", "removeHandler", "(", "handlerId", ")", ";", "}", "if", "(", "subscribers", ".", "isEmpty", "(", ")", ")", "{", "/*\n * Can not set bufferMgr to null (in here or in the source )if this SrcMgr belongs\n * to LogSource or TraceSource\n */", "if", "(", "!", "sourceId", ".", "contains", "(", "CollectorConstants", ".", "MESSAGES_SOURCE", ")", "&&", "!", "sourceId", ".", "contains", "(", "CollectorConstants", ".", "TRACE_SOURCE", ")", ")", "{", "/*\n * Last subscriber, unassign the buffer\n * Inform the source that buffer will no longer be available\n * and it should stop sending events to this buffer.\n */", "source", ".", "unsetBufferManager", "(", "bufferMgr", ")", ";", "bufferMgr", "=", "null", ";", "}", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Method", "to", "remove", "a", "subscriber", "from", "the", "source", "Source", "manager", "deallocate", "BufferManager", "when", "last", "subscriber", "goes", "away" ]

[ "public", "void", "handleFfdc", "(", ")", "{", "if", "(", "!", "bFfdcAlready", ")", "{", "com", ".", "ibm", ".", "ws", ".", "ffdc", ".", "FFDCFilter", ".", "processException", "(", "this", ",", "\"com.ibm.websphere.security.jwt.JwtTokenException\"", ",", "\"155\"", ",", "this", ")", ";", "bFfdcAlready", "=", "true", ";", "}", "}" ]

[ "in", "case", "we", "need", "to", "do", "the", "ffdc" ]

[ "private", "List", "<", "String", ">", "toListOfStrings", "(", "String", "headerName", ",", "List", "<", "Object", ">", "values", ")", "{", "if", "(", "values", "==", "null", ")", "{", "return", "null", ";", "}", "List", "<", "String", ">", "stringValues", "=", "new", "ArrayList", "<>", "(", "values", ".", "size", "(", ")", ")", ";", "HeaderDelegate", "<", "Object", ">", "hd", "=", "HttpUtils", ".", "getHeaderDelegate", "(", "values", ".", "get", "(", "0", ")", ")", ";", "for", "(", "Object", "value", ":", "values", ")", "{", "String", "actualValue", "=", "hd", "==", "null", "?", "value", ".", "toString", "(", ")", ":", "hd", ".", "toString", "(", "value", ")", ";", "stringValues", ".", "add", "(", "actualValue", ")", ";", "}", "return", "stringValues", ";", "}" ]

[ "This", "conversion", "is", "needed", "as", "some", "values", "may", "not", "be", "Strings" ]

[ "public", "<", "T", ">", "T", "doReadEntity", "(", "Class", "<", "T", ">", "cls", ",", "Type", "t", ",", "Annotation", "[", "]", "anns", ")", "throws", "ProcessingException", ",", "IllegalStateException", "{", "return", "doReadEntity", "(", "cls", ",", "t", ",", "anns", ",", "false", ")", ";", "}" ]

[ "convenience", "method", "for", "classes", "that", "have", "not", "been", "overwritten", "with", "liberty", "-", "specific", "changes" ]

[ "public", "static", "String", "read", "(", "Container", "container", ",", "String", "ddPath", ")", "{", "if", "(", "container", "==", "null", "||", "ddPath", "==", "null", ")", "{", "return", "\"\"", ";", "}", "Entry", "entry", "=", "container", ".", "getEntry", "(", "ddPath", ")", ";", "if", "(", "entry", "==", "null", ")", "{", "throw", "new", "IllegalStateException", "(", "ddPath", ")", ";", "}", "InputStream", "input", ";", "try", "{", "input", "=", "entry", ".", "adapt", "(", "InputStream", ".", "class", ")", ";", "}", "catch", "(", "UnableToAdaptException", "e", ")", "{", "throw", "new", "IllegalStateException", "(", "e", ")", ";", "}", "try", "{", "SAXParserFactory", "parserFactory", "=", "SAXParserFactory", ".", "newInstance", "(", ")", ";", "SAXParser", "parser", "=", "parserFactory", ".", "newSAXParser", "(", ")", ";", "XMLReader", "xmlReader", "=", "parser", ".", "getXMLReader", "(", ")", ";", "xmlReader", ".", "setEntityResolver", "(", "new", "EntityResolver", "(", ")", "{", "@", "Override", "public", "InputSource", "resolveEntity", "(", "String", "arg0", ",", "String", "arg1", ")", "throws", "SAXException", ",", "IOException", "{", "return", "new", "InputSource", "(", "new", "ByteArrayInputStream", "(", "new", "byte", "[", "0", "]", ")", ")", ";", "}", "}", ")", ";", "Source", "saxSource", "=", "new", "SAXSource", "(", "xmlReader", ",", "new", "InputSource", "(", "input", ")", ")", ";", "TransformerFactory", "transformerFactory", "=", "TransformerFactory", ".", "newInstance", "(", ")", ";", "Transformer", "transformer", "=", "transformerFactory", ".", "newTransformer", "(", ")", ";", "StringWriter", "writer", "=", "new", "StringWriter", "(", ")", ";", "Result", "result", "=", "new", "StreamResult", "(", "writer", ")", ";", "transformer", ".", "transform", "(", "saxSource", ",", "result", ")", ";", "return", "writer", ".", "toString", "(", ")", ";", "}", "catch", "(", "ParserConfigurationException", "e", ")", "{", "throw", "new", "IllegalStateException", "(", "e", ")", ";", "}", "catch", "(", "SAXException", "e", ")", "{", "throw", "new", "IllegalStateException", "(", "e", ")", ";", "}", "catch", "(", "TransformerConfigurationException", "e", ")", "{", "throw", "new", "IllegalStateException", "(", "e", ")", ";", "}", "catch", "(", "TransformerException", "e", ")", "{", "throw", "new", "IllegalStateException", "(", "e", ")", ";", "}", "finally", "{", "try", "{", "input", ".", "close", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "}", "}", "}" ]

[ "Read", "a", "deployment", "descriptor", "into", "a", "string", "." ]

[ "public", "void", "audit", "(", "String", "key", ",", "Object", "...", "params", ")", "{", "Tr", ".", "audit", "(", "tc", ",", "key", ",", "params", ")", ";", "}" ]

[ "Log", "an", "audit", "message", "." ]

[ "public", "String", "formatMessage", "(", "String", "key", ",", "Object", "...", "params", ")", "{", "return", "Tr", ".", "formatMessage", "(", "tc", ",", "key", ",", "params", ")", ";", "}" ]

[ "Format", "a", "message", "." ]

[ "public", "void", "info", "(", "String", "key", ",", "Object", "...", "params", ")", "{", "Tr", ".", "info", "(", "tc", ",", "key", ",", "params", ")", ";", "}" ]

[ "Log", "an", "informational", "message", "." ]

[ "@", "Override", "final", "public", "Object", "getConnection", "(", "final", "Subject", "requestSubject", ",", "final", "ConnectionRequestInfo", "requestInfo", ")", "throws", "ResourceException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "TRACE", ".", "isEntryEnabled", "(", ")", ")", "{", "SibTr", ".", "entry", "(", "this", ",", "TRACE", ",", "\"getConnection\"", ",", "new", "Object", "[", "]", "{", "subjectToString", "(", "requestSubject", ")", ",", "requestInfo", "}", ")", ";", "}", "// Ensure that the credentials for this request match those passed to", "// the constructor (as we don't support reauthentication)", "final", "JmsJcaUserDetails", "requestUserDetails", "=", "_managedConnectionFactory", ".", "getUserDetails", "(", "requestSubject", ",", "requestInfo", ")", ";", "if", "(", "_userDetails", "!=", "null", ")", "{", "if", "(", "!", "(", "_userDetails", ".", "equals", "(", "requestUserDetails", ")", ")", ")", "{", "throw", "new", "ResourceException", "(", "NLS", ".", "getFormattedMessage", "(", "(", "\"AUTHENTICATION_ERROR_CWSJR1103\"", ")", ",", "new", "Object", "[", "]", "{", "\"JmsJcaManagedConnection.getConnection\"", ",", "_userDetails", ".", "getUserName", "(", ")", ",", "(", "requestUserDetails", "==", "null", ")", "?", "null", ":", "requestUserDetails", ".", "getUserName", "(", ")", "}", ",", "null", ")", ")", ";", "}", "}", "else", "{", "if", "(", "!", "(", "_subject", ".", "equals", "(", "requestSubject", ")", ")", ")", "{", "throw", "new", "ResourceException", "(", "NLS", ".", "getFormattedMessage", "(", "(", "\"AUTHENTICATION_ERROR_CWSJR1117\"", ")", ",", "new", "Object", "[", "]", "{", "\"JmsJcaManagedConnection.getConnection\"", "}", ",", "null", ")", ")", ";", "}", "}", "JmsJcaSessionImpl", "session", "=", "null", ";", "if", "(", "requestInfo", "==", "null", "||", "requestInfo", "instanceof", "JmsJcaConnectionRequestInfo", ")", "{", "session", "=", "new", "JmsJcaSessionImpl", "(", "this", ",", "(", "JmsJcaConnectionRequestInfo", ")", "requestInfo", ")", ";", "_sessions", ".", "add", "(", "session", ")", ";", "}", "else", "{", "throw", "new", "ResourceAdapterInternalException", "(", "NLS", ".", "getFormattedMessage", "(", "(", "\"EXCEPTION_RECEIVED_CWSJR1101\"", ")", ",", "new", "Object", "[", "]", "{", "\"getConnection\"", ",", "JmsJcaConnectionRequestInfo", ".", "class", ".", "getName", "(", ")", ",", "requestInfo", ".", "getClass", "(", ")", ".", "getName", "(", ")", "}", ",", "null", ")", ")", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "TRACE", ".", "isEntryEnabled", "(", ")", ")", "{", "SibTr", ".", "exit", "(", "this", ",", "TRACE", ",", "\"getConnection\"", ",", "session", ")", ";", "}", "return", "session", ";", "}" ]

[ "Creates", "a", "session", "handle", "to", "this", "managed", "connection", ".", "The", "request", "information", "will", "by", "now", "contain", "a", "connection", "handle", ".", "This", "is", "passed", "along", "with", "this", "managed", "connection", "on", "the", "construction", "of", "the", "new", "session", "." ]

[ "@", "Override", "final", "public", "void", "destroy", "(", ")", "throws", "ResourceException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "TRACE", ".", "isEntryEnabled", "(", ")", ")", "{", "SibTr", ".", "entry", "(", "this", ",", "TRACE", ",", "\"destroy\"", ")", ";", "}", "// Invalidate all of the sessions", "for", "(", "final", "Iterator", "iterator", "=", "_sessions", ".", "iterator", "(", ")", ";", "iterator", ".", "hasNext", "(", ")", ";", ")", "{", "final", "Object", "object", "=", "iterator", ".", "next", "(", ")", ";", "if", "(", "object", "instanceof", "JmsJcaSessionImpl", ")", "{", "final", "JmsJcaSessionImpl", "session", "=", "(", "JmsJcaSessionImpl", ")", "object", ";", "session", ".", "invalidate", "(", ")", ";", "}", "}", "// Empty the set", "_sessions", ".", "clear", "(", ")", ";", "try", "{", "// Deregister the connection listener", "_coreConnection", ".", "removeConnectionListener", "(", "_connectionListener", ")", ";", "// Close the core connection", "// when destroy calls close connections then connection cannot be reset for future usage so force close by passing boolean true. - PM39926", "_coreConnection", ".", "close", "(", "true", ")", ";", "}", "catch", "(", "final", "SIConnectionLostException", "exception", ")", "{", "// No FFDC code needed", "// d352473", "// We are remote to the ME and the ME connection has been lost", "// we shall surpress this exception as we want the destroy to complete", "}", "catch", "(", "final", "SIConnectionDroppedException", "exception", ")", "{", "// No FFDC code needed", "// d352473", "// We are remote to the ME and the ME connection has been dropped", "// we shall surpress this exception as we want the destroy to complete", "}", "catch", "(", "final", "SIException", "exception", ")", "{", "FFDCFilter", ".", "processException", "(", "exception", ",", "CLASS_NAME", "+", "\"destroy\"", ",", "\"1:408:1.91\"", ",", "this", ")", ";", "throw", "new", "ResourceException", "(", "NLS", ".", "getFormattedMessage", "(", "\"EXCEPTION_RECEIVED_CWSJR1110\"", ",", "new", "Object", "[", "]", "{", "exception", ",", "\"createManagedConnection\"", "}", ",", "null", ")", ",", "exception", ")", ";", "}", "catch", "(", "final", "SIErrorException", "exception", ")", "{", "FFDCFilter", ".", "processException", "(", "exception", ",", "CLASS_NAME", "+", "\"destroy\"", ",", "\"1:416:1.91\"", ",", "this", ")", ";", "throw", "new", "ResourceException", "(", "NLS", ".", "getFormattedMessage", "(", "\"EXCEPTION_RECEIVED_CWSJR1110\"", ",", "new", "Object", "[", "]", "{", "exception", ",", "\"createManagedConnection\"", "}", ",", "null", ")", ",", "exception", ")", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "TRACE", ".", "isEntryEnabled", "(", ")", ")", "{", "SibTr", ".", "exit", "(", "this", ",", "TRACE", ",", "\"destroy\"", ")", ";", "}", "}" ]

[ "Destroys", "this", "managed", "connection", ".", "Called", "when", "a", "connection", "error", "has", "occurred", "or", "the", "managed", "connection", "has", "timed", "out", "in", "the", "free", "pool", ".", "Marks", "any", "associated", "sessions", "as", "invalid", ".", "Closes", "the", "associated", "core", "connection", "." ]

[ "@", "Override", "final", "public", "void", "cleanup", "(", ")", "throws", "ResourceException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "TRACE", ".", "isEntryEnabled", "(", ")", ")", "{", "SibTr", ".", "entry", "(", "this", ",", "TRACE", ",", "\"cleanup\"", ")", ";", "}", "// Invalidate all of the sessions", "for", "(", "final", "Iterator", "iterator", "=", "_sessions", ".", "iterator", "(", ")", ";", "iterator", ".", "hasNext", "(", ")", ";", ")", "{", "final", "Object", "object", "=", "iterator", ".", "next", "(", ")", ";", "if", "(", "object", "instanceof", "JmsJcaSessionImpl", ")", "{", "(", "(", "JmsJcaSessionImpl", ")", "object", ")", ".", "invalidate", "(", ")", ";", "}", "}", "_sessions", ".", "clear", "(", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "TRACE", ".", "isEntryEnabled", "(", ")", ")", "{", "SibTr", ".", "exit", "(", "this", ",", "TRACE", ",", "\"cleanup\"", ")", ";", "}", "}" ]

[ "Cleans", "up", "this", "managed", "connection", "so", "that", "it", "can", "be", "returned", "to", "the", "free", "pool", ".", "Any", "sessions", "that", "are", "still", "associated", "should", "be", "invalidated", "." ]

[ "@", "Override", "final", "public", "void", "associateConnection", "(", "Object", "object", ")", "throws", "ResourceException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "TRACE", ".", "isEntryEnabled", "(", ")", ")", "{", "SibTr", ".", "entry", "(", "this", ",", "TRACE", ",", "\"associateConnection\"", ",", "object", ")", ";", "}", "if", "(", "object", "instanceof", "JmsJcaSessionImpl", ")", "{", "final", "JmsJcaSessionImpl", "session", "=", "(", "JmsJcaSessionImpl", ")", "object", ";", "session", ".", "associate", "(", "this", ")", ";", "_sessions", ".", "add", "(", "session", ")", ";", "}", "else", "{", "throw", "new", "ResourceAdapterInternalException", "(", "NLS", ".", "getFormattedMessage", "(", "(", "\"INVALID_SESSION_CWSJR1104\"", ")", ",", "new", "Object", "[", "]", "{", "\"associateConnection\"", ",", "JmsJcaSessionImpl", ".", "class", ".", "getName", "(", ")", ",", "(", "object", "==", "null", "?", "\"null\"", ":", "object", ".", "getClass", "(", ")", ".", "getName", "(", ")", ")", "}", ",", "null", ")", ")", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "TRACE", ".", "isEntryEnabled", "(", ")", ")", "{", "SibTr", ".", "exit", "(", "this", ",", "TRACE", ",", "\"associateConnection\"", ")", ";", "}", "}" ]

[ "Associates", "the", "given", "session", "with", "this", "managed", "connection", ".", "Removes", "the", "session", "from", "its", "previous", "managed", "connection", "if", "any", "and", "adds", "it", "to", "the", "set", "for", "this", "connection", ".", "Sets", "this", "managed", "connection", "on", "the", "session", "." ]

[ "final", "void", "disassociateSession", "(", "final", "JmsJcaSessionImpl", "session", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "TRACE", ".", "isEntryEnabled", "(", ")", ")", "{", "SibTr", ".", "entry", "(", "this", ",", "TRACE", ",", "\"disassociateSession\"", ",", "session", ")", ";", "}", "_sessions", ".", "remove", "(", "session", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "TRACE", ".", "isEntryEnabled", "(", ")", ")", "{", "SibTr", ".", "exit", "(", "this", ",", "TRACE", ",", "\"disassociateSession\"", ")", ";", "}", "}" ]

[ "Dissassociates", "the", "given", "session", "from", "this", "managed", "connection", "." ]

[ "@", "Override", "final", "public", "void", "addConnectionEventListener", "(", "final", "ConnectionEventListener", "listener", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "TRACE", ".", "isEntryEnabled", "(", ")", ")", "{", "SibTr", ".", "entry", "(", "this", ",", "TRACE", ",", "\"addConnectionEventListener\"", ",", "listener", ")", ";", "}", "synchronized", "(", "_connectionListeners", ")", "{", "_connectionListeners", ".", "add", "(", "listener", ")", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "TRACE", ".", "isEntryEnabled", "(", ")", ")", "{", "SibTr", ".", "exit", "(", "this", ",", "TRACE", ",", "\"addConnectionEventListener\"", ")", ";", "}", "}" ]

[ "Adds", "a", "connection", "event", "listener", "." ]

[ "@", "Override", "final", "public", "ManagedConnectionMetaData", "getMetaData", "(", ")", "throws", "ResourceException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "TRACE", ".", "isEntryEnabled", "(", ")", ")", "{", "SibTr", ".", "entry", "(", "this", ",", "TRACE", ",", "\"getMetaData\"", ")", ";", "}", "if", "(", "_metaData", "==", "null", ")", "{", "_metaData", "=", "new", "JmsJcaManagedConnectionMetaData", "(", ")", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "TRACE", ".", "isEntryEnabled", "(", ")", ")", "{", "SibTr", ".", "exit", "(", "this", ",", "TRACE", ",", "\"getMetaData\"", ",", "_metaData", ")", ";", "}", "return", "_metaData", ";", "}" ]

[ "Returns", "the", "meta", "data", "information", "for", "this", "Jetstream", "connection", "." ]

[ "@", "Override", "final", "public", "void", "dissociateConnections", "(", ")", "throws", "ResourceException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "TRACE", ".", "isEntryEnabled", "(", ")", ")", "{", "SibTr", ".", "entry", "(", "TRACE", ",", "\"dissociateConnections\"", ")", ";", "}", "// Dissociate sessions", "for", "(", "final", "Iterator", "iterator", "=", "_sessions", ".", "iterator", "(", ")", ";", "iterator", ".", "hasNext", "(", ")", ";", ")", "{", "final", "Object", "object", "=", "iterator", ".", "next", "(", ")", ";", "if", "(", "object", "instanceof", "JmsJcaSessionImpl", ")", "{", "(", "(", "JmsJcaSessionImpl", ")", "object", ")", ".", "dissociate", "(", ")", ";", "iterator", ".", "remove", "(", ")", ";", "}", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "TRACE", ".", "isEntryEnabled", "(", ")", ")", "{", "SibTr", ".", "exit", "(", "this", ",", "TRACE", ",", "\"dissociateConnections\"", ")", ";", "}", "}" ]

[ "Dissociates", "any", "sessions", "currently", "associated", "with", "this", "managed", "connection", "." ]

[ "final", "void", "localTransactionStarted", "(", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "TRACE", ".", "isEntryEnabled", "(", ")", ")", "{", "SibTr", ".", "entry", "(", "this", ",", "TRACE", ",", "\"localTransactionStarted\"", ")", ";", "}", "final", "ConnectionEvent", "event", "=", "new", "ConnectionEvent", "(", "this", ",", "ConnectionEvent", ".", "LOCAL_TRANSACTION_STARTED", ")", ";", "// Copy list to protect against concurrent modification by listener", "final", "List", "<", "ConnectionEventListener", ">", "copy", ";", "synchronized", "(", "_connectionListeners", ")", "{", "copy", "=", "new", "ArrayList", "<", "ConnectionEventListener", ">", "(", "_connectionListeners", ")", ";", "}", "for", "(", "final", "Iterator", "iterator", "=", "copy", ".", "iterator", "(", ")", ";", "iterator", ".", "hasNext", "(", ")", ";", ")", "{", "final", "Object", "object", "=", "iterator", ".", "next", "(", ")", ";", "if", "(", "object", "instanceof", "ConnectionEventListener", ")", "{", "(", "(", "ConnectionEventListener", ")", "object", ")", ".", "localTransactionStarted", "(", "event", ")", ";", "}", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "TRACE", ".", "isEntryEnabled", "(", ")", ")", "{", "SibTr", ".", "exit", "(", "this", ",", "TRACE", ",", "\"localTransactionStarted\"", ")", ";", "}", "}" ]

[ "Called", "to", "indicate", "that", "the", "session", "associated", "with", "this", "managed", "connection", "has", "begun", "a", "local", "transaction", ".", "Notifies", "the", "connection", "event", "listeners", "." ]

[ "Key", "getSigningKey", "(", "JwtConsumerConfig", "config", ",", "JwtContext", "jwtContext", ",", "Map", "properties", ")", "throws", "KeyException", "{", "Key", "signingKey", "=", "null", ";", "if", "(", "config", "==", "null", ")", "{", "if", "(", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"JWT consumer config object is null\"", ")", ";", "}", "return", "null", ";", "}", "signingKey", "=", "getSigningKeyBasedOnSignatureAlgorithm", "(", "config", ",", "jwtContext", ",", "properties", ")", ";", "if", "(", "signingKey", "==", "null", ")", "{", "if", "(", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"A signing key could not be found\"", ")", ";", "}", "}", "return", "signingKey", ";", "}" ]

[ "Get", "the", "appropriate", "signing", "key", "based", "on", "the", "signature", "algorithm", "specified", "in", "the", "config", "." ]

[ "Key", "getSharedSecretKey", "(", "JwtConsumerConfig", "config", ")", "throws", "KeyException", "{", "if", "(", "config", "==", "null", ")", "{", "if", "(", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"JWT consumer config object is null\"", ")", ";", "}", "return", "null", ";", "}", "String", "sharedKey", "=", "config", ".", "getSharedKey", "(", ")", ";", "return", "createKeyFromSharedKey", "(", "sharedKey", ")", ";", "}" ]

[ "Creates", "a", "Key", "object", "from", "the", "shared", "key", "specified", "in", "the", "provided", "configuration", "." ]

[ "Key", "getPublicKey", "(", "String", "trustedAlias", ",", "String", "trustStoreRef", ",", "String", "signatureAlgorithm", ")", "throws", "KeyStoreServiceException", ",", "KeyException", "{", "Key", "signingKey", "=", "getPublicKeyFromKeystore", "(", "trustedAlias", ",", "trustStoreRef", ",", "signatureAlgorithm", ")", ";", "if", "(", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"Trusted alias: \"", "+", "trustedAlias", "+", "\", Truststore: \"", "+", "trustStoreRef", ")", ";", "Tr", ".", "debug", "(", "tc", ",", "\"RSAPublicKey: \"", "+", "(", "signingKey", "instanceof", "RSAPublicKey", ")", ")", ";", "}", "if", "(", "signingKey", "!=", "null", "&&", "!", "(", "signingKey", "instanceof", "RSAPublicKey", ")", ")", "{", "signingKey", "=", "null", ";", "}", "return", "signingKey", ";", "}" ]

[ "Creates", "a", "Key", "object", "from", "the", "certificate", "stored", "in", "the", "trust", "store", "and", "alias", "provided", "." ]

[ "void", "validateSignatureAlgorithmWithKey", "(", "JwtConsumerConfig", "config", ",", "Key", "key", ")", "throws", "InvalidClaimException", "{", "String", "signatureAlgorithm", "=", "config", ".", "getSignatureAlgorithm", "(", ")", ";", "if", "(", "key", "==", "null", "&&", "signatureAlgorithm", "!=", "null", "&&", "!", "signatureAlgorithm", ".", "equalsIgnoreCase", "(", "\"none\"", ")", ")", "{", "String", "msg", "=", "Tr", ".", "formatMessage", "(", "tc", ",", "\"JWT_MISSING_KEY\"", ",", "new", "Object", "[", "]", "{", "signatureAlgorithm", "}", ")", ";", "throw", "new", "InvalidClaimException", "(", "msg", ")", ";", "}", "}" ]

[ "Throws", "an", "exception", "if", "the", "provided", "key", "is", "null", "but", "the", "config", "specifies", "a", "signature", "algorithm", "other", "than", "none", "." ]

[ "boolean", "validateIssuer", "(", "String", "consumerConfigId", ",", "String", "issuers", ",", "String", "tokenIssuer", ")", "throws", "InvalidClaimException", "{", "boolean", "isIssuer", "=", "false", ";", "if", "(", "issuers", "==", "null", "||", "issuers", ".", "isEmpty", "(", ")", ")", "{", "String", "msg", "=", "Tr", ".", "formatMessage", "(", "tc", ",", "\"JWT_TRUSTED_ISSUERS_NULL\"", ",", "new", "Object", "[", "]", "{", "tokenIssuer", ",", "consumerConfigId", "}", ")", ";", "throw", "new", "InvalidClaimException", "(", "msg", ")", ";", "}", "StringTokenizer", "st", "=", "new", "StringTokenizer", "(", "issuers", ",", "\",\"", ")", ";", "while", "(", "st", ".", "hasMoreTokens", "(", ")", ")", "{", "String", "iss", "=", "st", ".", "nextToken", "(", ")", ".", "trim", "(", ")", ";", "if", "(", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"Trusted issuer: \"", "+", "iss", ")", ";", "}", "if", "(", "Constants", ".", "ALL_ISSUERS", ".", "equals", "(", "iss", ")", "||", "(", "tokenIssuer", "!=", "null", "&&", "tokenIssuer", ".", "equals", "(", "iss", ")", ")", ")", "{", "isIssuer", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "isIssuer", ")", "{", "String", "msg", "=", "Tr", ".", "formatMessage", "(", "tc", ",", "\"JWT_ISSUER_NOT_TRUSTED\"", ",", "new", "Object", "[", "]", "{", "tokenIssuer", ",", "consumerConfigId", ",", "issuers", "}", ")", ";", "throw", "new", "InvalidClaimException", "(", "msg", ")", ";", "}", "return", "isIssuer", ";", "}" ]

[ "Verifies", "that", "tokenIssuer", "is", "one", "of", "the", "values", "specified", "in", "the", "comma", "-", "separated", "issuers", "string", "." ]

[ "boolean", "validateAudience", "(", "List", "<", "String", ">", "allowedAudiences", ",", "List", "<", "String", ">", "audiences", ")", "{", "boolean", "valid", "=", "false", ";", "if", "(", "allowedAudiences", "!=", "null", "&&", "allowedAudiences", ".", "contains", "(", "Constants", ".", "ALL_AUDIENCES", ")", ")", "{", "return", "true", ";", "}", "if", "(", "allowedAudiences", "!=", "null", "&&", "audiences", "!=", "null", ")", "{", "for", "(", "String", "audience", ":", "audiences", ")", "{", "for", "(", "String", "allowedAud", ":", "allowedAudiences", ")", "{", "if", "(", "allowedAud", ".", "equals", "(", "audience", ")", ")", "{", "valid", "=", "true", ";", "break", ";", "}", "}", "}", "}", "else", "if", "(", "allowedAudiences", "==", "null", "&&", "(", "audiences", "==", "null", "||", "audiences", ".", "isEmpty", "(", ")", ")", ")", "{", "valid", "=", "true", ";", "}", "return", "valid", ";", "}" ]

[ "Verifies", "that", "at", "least", "one", "of", "the", "values", "specified", "in", "audiences", "is", "contained", "in", "the", "allowedAudiences", "list", "." ]

[ "public", "void", "readExternal", "(", "ObjectInput", "in", ")", "throws", "IOException", ",", "ClassNotFoundException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "entry", "(", "tc", ",", "\"readExternal\"", ")", ";", "try", "{", "// read magic", "short", "magic", "=", "in", ".", "readShort", "(", ")", ";", "short", "majorVersion", "=", "in", ".", "readShort", "(", ")", ";", "short", "minorVersion", "=", "in", ".", "readShort", "(", ")", ";", "if", "(", "!", "(", "magic", "==", "EXTERNAL_MAGIC", ")", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"Magic Number absent, trying default Java deserialization\"", ")", ";", "throw", "new", "IOException", "(", "\"Bean ID externalized stream format error\"", ")", ";", "}", "else", "if", "(", "!", "(", "majorVersion", "==", "MAJOR_VERSION", ")", "||", "!", "(", "minorVersion", "==", "MINOR_VERSION", ")", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"BeanID Version mismatch\"", ",", "new", "Object", "[", "]", "{", "new", "Short", "(", "majorVersion", ")", ",", "new", "Short", "(", "minorVersion", ")", "}", ")", ";", "throw", "new", "IOException", "(", "\"BeanID version mismatch\"", ")", ";", "}", "// read the interface type (HOME or REMOTE)", "byte", "ifType", "=", "in", ".", "readByte", "(", ")", ";", "if", "(", "ifType", "==", "IF_HOME", ")", "{", "_isHome", "=", "true", ";", "}", "else", "{", "_isHome", "=", "false", ";", "}", "//89554", "// read the bean name", "byte", "[", "]", "j2eeNameBytes", "=", "readExternalJ2EEName", "(", "in", ")", ";", "// read the serialized primary key", "pkey", "=", "readExternalPKey", "(", "in", ",", "j2eeNameBytes", ")", ";", "// TAKE CARE! We don't have a container reference so can't", "// restore transient fields.", "// This is ok as long", "// as rest of container restores BeanIds using the deserialise", "// method. Since readExternal", "// is a new addition", "// this can be no different to the behaviour that would have been", "// observed when using", "// the default serialization.", "}", "finally", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "exit", "(", "tc", ",", "\"readExternal\"", ")", ";", "}", "}" ]

[ "readExternal", "is", "called", "by", "Java", "serialization", "when", "readObject", "is", "called", "on", "an", "ObjectInputStream", "for", "an", "object", "of", "class", "BeanId", ".", "It", "must", "read", "the", "values", "in", "the", "same", "sequence", "and", "with", "the", "same", "types", "as", "written", "by", "writeExternal", "." ]

[ "private", "Serializable", "readExternalPKey", "(", "ObjectInput", "in", ",", "byte", "[", "]", "j2eeNameBytes", ")", "throws", "java", ".", "io", ".", "IOException", ",", "ClassNotFoundException", "{", "int", "pkeyLength", "=", "in", ".", "readInt", "(", ")", ";", "byte", "[", "]", "pkeyBytes", "=", "new", "byte", "[", "pkeyLength", "]", ";", "//d164415 start", "int", "bytesRead", "=", "0", ";", "for", "(", "int", "offset", "=", "0", ";", "offset", "<", "pkeyLength", ";", "offset", "+=", "bytesRead", ")", "{", "bytesRead", "=", "in", ".", "read", "(", "pkeyBytes", ",", "offset", ",", "pkeyLength", "-", "offset", ")", ";", "if", "(", "bytesRead", "==", "-", "1", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"readExternalKey encountered end of stream\"", ")", ";", "throw", "new", "IOException", "(", "\"end of input stream while reading primary key\"", ")", ";", "}", "}", "//d164415 end", "//", "// What we are trying to do here is to get the j2eename of the", "// bean in question. The reason we want to do this, we have get", "// the ClassLoader of the bean before we attempt to deserialize", "// the primary key. The container ClassLoader is no longer aware", "// of the bean classes.", "// This path may be traversed on a call to keyToObject. In that", "// situation, the thread's context ClassLoader is of no use. So we", "// have to use some static methods to access the container and get", "// the specific ClassLoader for the bean", "//", "final", "EJSContainer", "container", "=", "EJSContainer", ".", "getDefaultContainer", "(", ")", ";", "J2EEName", "j2eename", "=", "container", ".", "getJ2EENameFactory", "(", ")", ".", "create", "(", "j2eeNameBytes", ")", ";", "ByteArrayInputStream", "bais", "=", "new", "ByteArrayInputStream", "(", "pkeyBytes", ")", ";", "//", "// Use a ObjectInputStream, it can then use the bean's ClassLoader", "// to resolve the primary key class.", "//", "ClassLoader", "loader", "=", "EJSContainer", ".", "getClassLoader", "(", "j2eename", ")", ";", "ObjectInputStream", "pkeyStream", "=", "container", ".", "getEJBRuntime", "(", ")", ".", "createObjectInputStream", "(", "bais", ",", "loader", ")", ";", "// RTC71814", "Serializable", "key", "=", "(", "Serializable", ")", "pkeyStream", ".", "readObject", "(", ")", ";", "return", "key", ";", "}" ]

[ "Private", "helper", "method", "for", "readExternal", "-", "reads", "the", "Serialized", "primary", "key", "." ]

[ "public", "void", "writeExternal", "(", "ObjectOutput", "out", ")", "throws", "IOException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "entry", "(", "tc", ",", "\"writeExternal\"", ")", ";", "try", "{", "// write magic", "out", ".", "writeShort", "(", "EXTERNAL_MAGIC", ")", ";", "out", ".", "writeShort", "(", "MAJOR_VERSION", ")", ";", "out", ".", "writeShort", "(", "MINOR_VERSION", ")", ";", "// write the interface type (HOME or REMOTE)", "if", "(", "_isHome", ")", "{", "out", ".", "writeByte", "(", "IF_HOME", ")", ";", "}", "else", "{", "out", ".", "writeByte", "(", "IF_REMOTE", ")", ";", "}", "//89554", "// write the Java EE name", "writeExternalJ2EEName", "(", "out", ")", ";", "// write the external primary key", "writeExternalPKey", "(", "out", ")", ";", "out", ".", "flush", "(", ")", ";", "}", "finally", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "exit", "(", "tc", ",", "\"writeExternal\"", ")", ";", "}", "}" ]

[ "writeExternal", "is", "called", "by", "Java", "serialization", "when", "writeObject", "is", "called", "on", "an", "ObjectOutputStream", "for", "an", "object", "of", "class", "BeanId", "." ]

[ "private", "void", "writeExternalPKey", "(", "ObjectOutput", "out", ")", "throws", "java", ".", "io", ".", "IOException", "{", "// write the serialized primary key - can't mix eternaized stream", "// and writeObject so convert to bytes...", "ByteArrayOutputStream", "baos", "=", "new", "ByteArrayOutputStream", "(", ")", ";", "ObjectOutputStream", "pkeyStream", "=", "new", "ObjectOutputStream", "(", "baos", ")", ";", "pkeyStream", ".", "writeObject", "(", "pkey", ")", ";", "pkeyStream", ".", "flush", "(", ")", ";", "pkeyStream", ".", "close", "(", ")", ";", "byte", "[", "]", "pkeyBytes", "=", "baos", ".", "toByteArray", "(", ")", ";", "out", ".", "writeInt", "(", "pkeyBytes", ".", "length", ")", ";", "out", ".", "write", "(", "pkeyBytes", ")", ";", "}" ]

[ "Private", "helper", "method", "for", "writeExternal", "-", "writes", "the", "primary", "key" ]

[ "public", "static", "UIComponent", "getCompositeComponentParent", "(", "UIComponent", "component", ")", "{", "if", "(", "component", "==", "null", ")", "{", "return", "null", ";", "}", "UIComponent", "parent", "=", "component", ";", "do", "{", "parent", "=", "parent", ".", "getParent", "(", ")", ";", "if", "(", "parent", "!=", "null", "&&", "UIComponent", ".", "isCompositeComponent", "(", "parent", ")", ")", "{", "return", "parent", ";", "}", "}", "while", "(", "parent", "!=", "null", ")", ";", "return", "null", ";", "}" ]

[ "search", "for", "the", "nearest", "parent", "composite", "component", "if", "no", "parent", "is", "found", "it", "has", "to", "return", "null!" ]

[ "protected", "StateHelper", "getStateHelper", "(", "boolean", "create", ")", "{", "if", "(", "_stateHelper", "!=", "null", ")", "{", "return", "_stateHelper", ";", "}", "if", "(", "create", ")", "{", "_stateHelper", "=", "new", "_DeltaStateHelper", "(", "this", ")", ";", "}", "return", "_stateHelper", ";", "}" ]

[ "returns", "a", "delta", "state", "saving", "enabled", "state", "helper", "for", "the", "current", "component" ]

[ "private", "static", "Boolean", "_getHonorCurrentComponentAttributes", "(", "FacesContext", "facesContext", ")", "{", "// performance note: we cache value in facesContext.attributes because", "// 1) methods pushComponentToEL, popComponentFromEl, getCurrentComponent a getCurrentCompositeComponent", "// can use that value", "// 2) getExternalContext().getInitParameter has undetermined performance. In typical JSF app, there", "// are one or two wrappers around external context; servletContext.getInitParameter has also unknown ", "// implementation and performance", "Map", "<", "Object", ",", "Object", ">", "attributes", "=", "facesContext", ".", "getAttributes", "(", ")", ";", "Boolean", "paramValue", "=", "(", "Boolean", ")", "attributes", ".", "get", "(", "HONOR_CURRENT_COMPONENT_ATTRIBUTES_PARAM_NAME", ")", ";", "if", "(", "paramValue", "==", "null", ")", "{", "String", "param", "=", "facesContext", ".", "getExternalContext", "(", ")", ".", "getInitParameter", "(", "HONOR_CURRENT_COMPONENT_ATTRIBUTES_PARAM_NAME", ")", ";", "paramValue", "=", "Boolean", ".", "valueOf", "(", "(", "param", "!=", "null", "&&", "Boolean", ".", "valueOf", "(", "param", ")", ".", "booleanValue", "(", ")", ")", ")", ";", "attributes", ".", "put", "(", "HONOR_CURRENT_COMPONENT_ATTRIBUTES_PARAM_NAME", ",", "paramValue", ")", ";", "}", "return", "paramValue", ";", "}" ]

[ "Gets", "value", "of", "javax", ".", "faces", ".", "HONOR_CURRENT_COMPONENT_ATTRIBUTES", "parameter", "cached", "in", "facesContext", ".", "attributes", "or", "resolves", "that", "param", "and", "caches", "its", "value", "in", "facesContext", ".", "attributes", "." ]

[ "@", "Override", "public", "void", "processPartial", "(", "PhaseId", "phaseId", ")", "{", "assertNotReleased", "(", ")", ";", "UIViewRoot", "viewRoot", "=", "_facesContext", ".", "getViewRoot", "(", ")", ";", "if", "(", "phaseId", "==", "PhaseId", ".", "APPLY_REQUEST_VALUES", "||", "phaseId", "==", "PhaseId", ".", "PROCESS_VALIDATIONS", "||", "phaseId", "==", "PhaseId", ".", "UPDATE_MODEL_VALUES", ")", "{", "processPartialExecute", "(", "viewRoot", ",", "phaseId", ")", ";", "}", "else", "if", "(", "phaseId", "==", "PhaseId", ".", "RENDER_RESPONSE", ")", "{", "processPartialRendering", "(", "viewRoot", ",", "phaseId", ")", ";", "}", "}" ]

[ "process", "the", "partial", "response", "allowed", "phase", "ids", "according", "to", "the", "spec" ]

[ "public", "static", "Locale", "localeForString", "(", "String", "localeString", ")", "{", "if", "(", "localeString", "==", "null", "||", "localeString", ".", "isEmpty", "(", ")", ")", "{", "return", "null", ";", "}", "Locale", "locale", ";", "String", "[", "]", "localeParts", "=", "localeString", ".", "split", "(", "\"_\"", ")", ";", "switch", "(", "localeParts", ".", "length", ")", "{", "case", "1", ":", "locale", "=", "new", "Locale", "(", "localeParts", "[", "0", "]", ")", ";", "break", ";", "case", "2", ":", "locale", "=", "new", "Locale", "(", "localeParts", "[", "0", "]", ",", "localeParts", "[", "1", "]", ")", ";", "break", ";", "default", ":", "// Use default for 3 and above, merge the parts back and put them all in the varient", "StringBuilder", "varient", "=", "new", "StringBuilder", "(", "localeParts", "[", "2", "]", ")", ";", "for", "(", "int", "i", "=", "3", ";", "i", "<", "localeParts", ".", "length", ";", "i", "++", ")", "{", "varient", ".", "append", "(", "\"_\"", ")", ";", "varient", ".", "append", "(", "localeParts", "[", "i", "]", ")", ";", "}", "locale", "=", "new", "Locale", "(", "localeParts", "[", "0", "]", ",", "localeParts", "[", "1", "]", ",", "varient", ".", "toString", "(", ")", ")", ";", "break", ";", "}", "return", "locale", ";", "}" ]

[ "Creates", "a", "locale", "based", "on", "a", "String", "of", "the", "form", "language_country_variant", "either", "of", "the", "last", "two", "parts", "can", "be", "omitted", "." ]

[ "public", "Iterable", "<", "ServerInstanceLogRecordList", ">", "getLogLists", "(", "RepositoryPointer", "after", ",", "LogQueryBean", "query", ")", "throws", "LogRepositoryException", "{", "logger", ".", "entering", "(", "thisClass", ",", "\"getLogLists\"", ",", "new", "Object", "[", "]", "{", "after", ",", "query", "}", ")", ";", "RemoteAllResults", "lists", "=", "readLogLists", "(", "query", ",", "after", ")", ";", "ArrayList", "<", "ServerInstanceLogRecordList", ">", "result", "=", "new", "ArrayList", "<", "ServerInstanceLogRecordList", ">", "(", ")", ";", "if", "(", "lists", "!=", "null", ")", "{", "boolean", "firstInstance", "=", "true", ";", "for", "(", "RemoteInstanceDetails", "indicator", ":", "lists", ".", "getLogLists", "(", ")", ")", "{", "result", ".", "add", "(", "getLogListForServerInstance", "(", "indicator", ",", "firstInstance", "?", "after", ":", "null", ")", ")", ";", "firstInstance", "=", "false", ";", "}", "}", "logger", ".", "exiting", "(", "thisClass", ",", "\"getLogLists\"", ",", "result", ")", ";", "return", "result", ";", "}" ]

[ "returns", "log", "records", "from", "the", "repository", "that", "are", "beyond", "a", "given", "repository", "location", "according", "to", "the", "criteria", "specified", "by", "the", "log", "query", "bean", "." ]

[ "private", "void", "validatePossibleEndpoint", "(", "String", "possibleEndpoint", ")", "throws", "IllegalArgumentException", "{", "if", "(", "!", "possibleEndpoint", ".", "contains", "(", "\":\"", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "RESTClientMessagesUtil", ".", "getMessage", "(", "RESTClientMessagesUtil", ".", "INVALID_ENDPOINT", ",", "possibleEndpoint", ")", ")", ";", "}", "String", "[", "]", "components", "=", "possibleEndpoint", ".", "split", "(", "\":\"", ")", ";", "if", "(", "components", ".", "length", "!=", "2", ")", "{", "throw", "new", "IllegalArgumentException", "(", "RESTClientMessagesUtil", ".", "getMessage", "(", "RESTClientMessagesUtil", ".", "INVALID_ENDPOINT", ",", "possibleEndpoint", ")", ")", ";", "}", "try", "{", "Integer", ".", "valueOf", "(", "components", "[", "1", "]", ")", ";", "}", "catch", "(", "NumberFormatException", "e", ")", "{", "throw", "new", "IllegalArgumentException", "(", "RESTClientMessagesUtil", ".", "getMessage", "(", "RESTClientMessagesUtil", ".", "INVALID_ENDPOINT", ",", "possibleEndpoint", ")", ")", ";", "}", "}" ]

[ "Validate", "the", "possible", "endpoint", "String", "." ]

[ "private", "Set", "<", "String", ">", "validatePathAndRetrievePathParams", "(", "ValidationHelper", "helper", ",", "Context", "context", ",", "String", "pathStr", ")", "{", "String", "pathToCheck", "=", "pathStr", ";", "Set", "<", "String", ">", "pathParameters", "=", "new", "HashSet", "<", "String", ">", "(", ")", ";", "while", "(", "pathToCheck", ".", "contains", "(", "\"{\"", ")", ")", "{", "if", "(", "!", "pathToCheck", ".", "contains", "(", "\"}\"", ")", ")", "{", "final", "String", "message", "=", "Tr", ".", "formatMessage", "(", "tc", ",", "\"pathItemInvalidFormat\"", ",", "pathStr", ")", ";", "helper", ".", "addValidationEvent", "(", "new", "ValidationEvent", "(", "ValidationEvent", ".", "Severity", ".", "ERROR", ",", "context", ".", "getLocation", "(", ")", ",", "message", ")", ")", ";", "return", "pathParameters", ";", "}", "int", "firstIndex", "=", "pathToCheck", ".", "indexOf", "(", "\"{\"", ")", ";", "int", "lastIndex", "=", "pathToCheck", ".", "indexOf", "(", "\"}\"", ")", ";", "if", "(", "firstIndex", ">", "lastIndex", ")", "{", "final", "String", "message", "=", "Tr", ".", "formatMessage", "(", "tc", ",", "\"pathItemInvalidFormat\"", ",", "pathStr", ")", ";", "helper", ".", "addValidationEvent", "(", "new", "ValidationEvent", "(", "ValidationEvent", ".", "Severity", ".", "ERROR", ",", "context", ".", "getLocation", "(", ")", ",", "message", ")", ")", ";", "return", "pathParameters", ";", "}", "String", "parameter", "=", "pathToCheck", ".", "substring", "(", "firstIndex", "+", "1", ",", "lastIndex", ")", ";", "if", "(", "parameter", ".", "isEmpty", "(", ")", "||", "parameter", ".", "contains", "(", "\"{\"", ")", "||", "parameter", ".", "contains", "(", "\"/\"", ")", ")", "{", "final", "String", "message", "=", "Tr", ".", "formatMessage", "(", "tc", ",", "\"pathItemInvalidFormat\"", ",", "pathStr", ")", ";", "helper", ".", "addValidationEvent", "(", "new", "ValidationEvent", "(", "ValidationEvent", ".", "Severity", ".", "ERROR", ",", "context", ".", "getLocation", "(", ")", ",", "message", ")", ")", ";", "return", "pathParameters", ";", "}", "pathParameters", ".", "add", "(", "parameter", ")", ";", "pathToCheck", "=", "pathToCheck", ".", "substring", "(", "lastIndex", "+", "1", ")", ";", "}", "if", "(", "pathToCheck", ".", "contains", "(", "\"}\"", ")", ")", "{", "final", "String", "message", "=", "Tr", ".", "formatMessage", "(", "tc", ",", "\"pathItemInvalidFormat\"", ",", "pathStr", ")", ";", "helper", ".", "addValidationEvent", "(", "new", "ValidationEvent", "(", "ValidationEvent", ".", "Severity", ".", "ERROR", ",", "context", ".", "getLocation", "(", ")", ",", "message", ")", ")", ";", "return", "pathParameters", ";", "}", "return", "pathParameters", ";", "}" ]

[ "Validate", "the", "path", "and", "extract", "path", "parameters" ]

[ "public", "CompositeEnumeration", "<", "T", ">", "add", "(", "Enumeration", "<", "T", ">", "enumeration", ")", "{", "// optimise out empty enumerations up front", "if", "(", "enumeration", ".", "hasMoreElements", "(", ")", ")", "enumerations", ".", "add", "(", "enumeration", ")", ";", "return", "this", ";", "}" ]

[ "Fluent", "method", "for", "chaining", "additions", "of", "subsequent", "enumerations", "." ]

[ "public", "synchronized", "void", "incrementUseCount", "(", ")", "throws", "SIConnectionUnavailableException", ",", "SIConnectionDroppedException", ",", "SIErrorException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"incrementUseCount\"", ")", ";", "// Check if this ordering conext instance is \"dead\". If it is, then this order context has been closed and", "// we need to obtain a new proxy id for it.", "if", "(", "dead", ")", "{", "setOrderingContextProxyId", "(", ")", ";", "dead", "=", "false", ";", "}", "useCount", "++", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "SibTr", ".", "debug", "(", "this", ",", "tc", ",", "\"Use count is now: \"", "+", "useCount", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "this", ",", "tc", ",", "\"incrementUseCount\"", ")", ";", "}" ]

[ "This", "method", "will", "increment", "the", "use", "count", "on", "this", "order", "context", "." ]

[ "public", "synchronized", "void", "decrementUseCount", "(", ")", "throws", "SIConnectionDroppedException", ",", "SIErrorException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"decrementUseCount\"", ")", ";", "useCount", "--", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "SibTr", ".", "debug", "(", "this", ",", "tc", ",", "\"Use count is now: \"", "+", "useCount", ")", ";", "// Now check the use count. If it is 0, we should close the order contex so that the server", "// side code can release the resources held by it.", "if", "(", "useCount", "==", "0", ")", "{", "close", "(", ")", ";", "dead", "=", "true", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "this", ",", "tc", ",", "\"decrementUseCount\"", ")", ";", "}" ]

[ "This", "method", "will", "decrement", "the", "use", "count", "on", "this", "order", "context", "." ]

[ "public", "void", "close", "(", ")", "throws", "SIConnectionDroppedException", ",", "SIErrorException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"close\"", ")", ";", "queue", "=", "null", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "SibTr", ".", "debug", "(", "this", ",", "tc", ",", "\"Returning order context to the order context pool\"", ")", ";", "final", "ConnectionProxy", "cp", "=", "getConnectionProxy", "(", ")", ";", "cp", ".", "addOrderContext", "(", "getProxyID", "(", ")", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "this", ",", "tc", ",", "\"close\"", ")", ";", "}" ]

[ "This", "method", "will", "close", "the", "ordering", "context", ".", "This", "method", "should", "ideally", "be", "called", "by", "the", "API", "application", ".", "But", "at", "present", "it", "is", "called", "by", "us", "when", "the", "use", "count", "is", "0", ".", "The", "order", "context", "is", "only", "returned", "to", "the", "connection", "pool", "of", "free", "order", "contexts", "as", "this", "avoids", "an", "exchange", "with", "the", "server", "which", "is", "costly", "." ]

[ "public", "void", "associateWithQueue", "(", "Queue", "queueToAssociate", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"associateWithQueue\"", ",", "queueToAssociate", ")", ";", "this", ".", "queue", "=", "queueToAssociate", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "this", ",", "tc", ",", "\"associateWithQueue\"", ")", ";", "}" ]

[ "Called", "by", "a", "proxy", "queue", "to", "associate", "itself", "with", "this", "ordering", "context", "." ]

[ "private", "String", "getMessage", "(", "String", "key", ",", "Object", "...", "args", ")", "{", "String", "message", "=", "messages", ".", "getString", "(", "key", ")", ";", "return", "(", "args", ".", "length", "==", "0", ")", "?", "message", ":", "MessageFormat", ".", "format", "(", "message", ",", "args", ")", ";", "}" ]

[ "Get", "a", "formatted", "message", "." ]

[ "private", "final", "JsMessage", "restoreJsMessage", "(", "byte", "[", "]", "buffer", ",", "Object", "store", ")", "throws", "MessageRestoreFailedException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "tc", ",", "\"restoreJsMessage\"", ",", "buffer", ")", ";", "JsMessage", "newMsg", "=", "null", ";", "String", "className", ";", "int", "offset", "=", "0", ";", "/* The buffer contains: */", "/* the message class name */", "/* the list of JMF schema ids needed to decode the message */", "/* the message itself */", "// Trace the first 256 bytes just in case we get passed rubbish", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "SibTr", ".", "debug", "(", "tc", ",", "\"Start of buffer: \"", ",", "SibTr", ".", "formatBytes", "(", "buffer", ",", "0", ",", "256", ")", ")", ";", "// Extract the classname from the buffer", "int", "temp", "=", "ArrayUtil", ".", "readInt", "(", "buffer", ",", "offset", ")", ";", "// the length of the class name", "offset", "+=", "ArrayUtil", ".", "INT_SIZE", ";", "try", "{", "className", "=", "getClassName", "(", "buffer", ",", "offset", ",", "temp", ")", ";", "// the class name itself", "}", "catch", "(", "RuntimeException", "e", ")", "{", "FFDCFilter", ".", "processException", "(", "e", ",", "\"com.ibm.ws.sib.mfp.impl.JsMessageFactoryImpl.restoreJsMessage\"", ",", "\"573\"", ",", "this", ",", "new", "Object", "[", "]", "{", "MfpConstants", ".", "DM_BUFFER", ",", "buffer", ",", "0", ",", "buffer", ".", "length", "}", ")", ";", "// This is a disaster - presumably the buffer is garbage - so we have to throw the exception on", "throw", "new", "MessageRestoreFailedException", "(", "e", ")", ";", "}", "offset", "+=", "temp", ";", "// Extract the message schema ids from the buffer, & ensure the schemas are available.", "offset", "=", "ensureSchemasAvailable", "(", "buffer", ",", "offset", ",", "store", ")", ";", "try", "{", "/* Create a new JMO from the remaining buffer */", "JsMsgObject", "newJmo", "=", "new", "JsMsgObject", "(", "JsHdrAccess", ".", "schema", ",", "JsPayloadAccess", ".", "schema", ",", "buffer", ",", "offset", ",", "buffer", ".", "length", "-", "offset", ")", ";", "/* Get the class for the appropriate specialization */", "Class", "msgClass", "=", "Class", ".", "forName", "(", "className", ")", ";", "/* Now create the new JsMessage and set the JMO */", "newMsg", "=", "(", "JsMessage", ")", "msgClass", ".", "newInstance", "(", ")", ";", "(", "(", "JsMessageImpl", ")", "newMsg", ")", ".", "setJmo", "(", "newJmo", ")", ";", "/* Set the approxLength as we know it */", "(", "(", "JsMessageImpl", ")", "newMsg", ")", ".", "setApproximateLength", "(", "newJmo", ".", "getOriginalLength", "(", ")", ")", ";", "}", "catch", "(", "ClassNotFoundException", "e1", ")", "{", "FFDCFilter", ".", "processException", "(", "e1", ",", "\"com.ibm.ws.sib.mfp.impl.JsMessageFactoryImpl.restore\"", ",", "\"534\"", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "SibTr", ".", "debug", "(", "tc", ",", "\"Exception \"", "+", "e1", ".", "toString", "(", ")", "+", "\" finding class \"", "+", "className", ")", ";", "throw", "new", "MessageRestoreFailedException", "(", "e1", ")", ";", "}", "catch", "(", "MessageDecodeFailedException", "e2", ")", "{", "/* No need to FFDC this as JsMsgObject will already have done so */", "// No FFDC code needed", "throw", "new", "MessageRestoreFailedException", "(", "e2", ")", ";", "}", "catch", "(", "Exception", "e3", ")", "{", "/* Any other exceptions from instantiation should never happen */", "FFDCFilter", ".", "processException", "(", "e3", ",", "\"com.ibm.ws.sib.mfp.impl.JsMessageFactoryImpl.restore\"", ",", "\"545\"", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "SibTr", ".", "debug", "(", "tc", ",", "\"Exception \"", "+", "e3", ".", "toString", "(", ")", "+", "\" instantiating class \"", "+", "className", ")", ";", "throw", "new", "MessageRestoreFailedException", "(", "e3", ")", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"restoreJsMessage\"", ")", ";", "return", "newMsg", ";", "}" ]

[ "Restore", "a", "JsMessage", "of", "any", "specializaton", "from", "a", "flattenned", "copy", ".", "Since", "SIB0112b", "this", "method", "is", "only", "called", "by", "the", "preceding", "restoreJsMessage", "method", "so", "it", "is", "marked", "private", "." ]

[ "private", "final", "static", "int", "ensureSchemasAvailable", "(", "byte", "[", "]", "buffer", ",", "int", "offset", ",", "Object", "store", ")", "throws", "MessageRestoreFailedException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "tc", ",", "\"ensureSchemasAvailable\"", ",", "new", "Object", "[", "]", "{", "offset", ",", "store", "}", ")", ";", "// If we have a message store we need to ensure all the schemas we'll", "// need to decode the message are restored from the store.", "int", "temp", "=", "ArrayUtil", ".", "readInt", "(", "buffer", ",", "offset", ")", ";", "// the number of encoding Ids", "offset", "+=", "ArrayUtil", ".", "INT_SIZE", ";", "long", "[", "]", "decodeIds", "=", "new", "long", "[", "temp", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "temp", ";", "i", "++", ")", "{", "decodeIds", "[", "i", "]", "=", "ArrayUtil", ".", "readLong", "(", "buffer", ",", "offset", ")", ";", "// each encoding schema id", "offset", "+=", "ArrayUtil", ".", "LONG_SIZE", ";", "}", "if", "(", "store", "!=", "null", "&&", "decodeIds", ".", "length", ">", "0", ")", "{", "if", "(", "!", "(", "store", "instanceof", "MessageStore", ")", ")", "throw", "new", "IllegalArgumentException", "(", "\"store is not a MessageStore instance\"", ")", ";", "SchemaStore", ".", "loadSchemas", "(", "(", "MessageStore", ")", "store", ",", "decodeIds", ")", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"ensureSchemasAvailable\"", ",", "offset", ")", ";", "return", "offset", ";", "}" ]

[ "Utility", "method", "to", "extract", "the", "schema", "ids", "from", "a", "message", "buffer", "and", "if", "a", "message", "store", "is", "supplied", "check", "that", "all", "the", "necessary", "schemas", "are", "available", "." ]