Datasets:

---

semeru

/

code-text-java

like 3

Follow

Semeru Lab 8

[ "private", "final", "JsMessage", "createSpecialisedMessage", "(", "JsMsgObject", "jmo", ")", "{", "JsMessage", "message", "=", "null", ";", "/* For an API message, we need to return an instance of the appropriate */", "/* specialisation. */", "if", "(", "jmo", ".", "getChoiceField", "(", "JsHdrAccess", ".", "API", ")", "==", "JsHdrAccess", ".", "IS_API_DATA", ")", "{", "/* If it is a JMS message, get the right specialisation */", "if", "(", "jmo", ".", "getField", "(", "JsHdrAccess", ".", "MESSAGETYPE", ")", ".", "equals", "(", "MessageType", ".", "JMS", ".", "toByte", "(", ")", ")", ")", "{", "message", "=", "getJmsFactory", "(", ")", ".", "createInboundJmsMessage", "(", "jmo", ",", "(", "(", "Byte", ")", "jmo", ".", "getField", "(", "JsHdrAccess", ".", "SUBTYPE", ")", ")", ".", "intValue", "(", ")", ")", ";", "}", "}", "/* If it isn't an API message, just return a JsMessageImpl */", "else", "{", "message", "=", "new", "JsMessageImpl", "(", "jmo", ")", ";", "}", "return", "message", ";", "}" ]

[ "Returns", "a", "new", "JsMessage", "instance", "of", "the", "subclass", "appropriate", "to", "the", "message", "content", "." ]

[ "private", "int", "bytesToInt", "(", "byte", "[", "]", "bytes", ")", "{", "int", "result", "=", "-", "1", ";", "if", "(", "bytes", ".", "length", ">=", "4", ")", "{", "result", "=", "(", "(", "bytes", "[", "0", "]", "&", "0xff", ")", "<<", "24", ")", "+", "(", "(", "bytes", "[", "1", "]", "&", "0xff", ")", "<<", "16", ")", "+", "(", "(", "bytes", "[", "2", "]", "&", "0xff", ")", "<<", "8", ")", "+", "(", "bytes", "[", "3", "]", "&", "0xff", ")", ";", "}", "return", "result", ";", "}" ]

[ "A", "helper", "function", "which", "extracts", "an", "int", "from", "a", "byte", "array", "representation" ]

[ "private", "String", "getTopic", "(", "ServiceEvent", "serviceEvent", ")", "{", "StringBuilder", "topic", "=", "new", "StringBuilder", "(", "SERVICE_EVENT_TOPIC_PREFIX", ")", ";", "switch", "(", "serviceEvent", ".", "getType", "(", ")", ")", "{", "case", "ServiceEvent", ".", "REGISTERED", ":", "topic", ".", "append", "(", "\"REGISTERED\"", ")", ";", "break", ";", "case", "ServiceEvent", ".", "MODIFIED", ":", "topic", ".", "append", "(", "\"MODIFIED\"", ")", ";", "break", ";", "case", "ServiceEvent", ".", "UNREGISTERING", ":", "topic", ".", "append", "(", "\"UNREGISTERING\"", ")", ";", "break", ";", "default", ":", "return", "null", ";", "}", "return", "topic", ".", "toString", "(", ")", ";", "}" ]

[ "Determine", "the", "appropriate", "topic", "to", "use", "for", "the", "Service", "Event", "." ]

[ "public", "synchronized", "void", "updateFilters", "(", "NotificationFilter", "[", "]", "filtersArray", ")", "{", "filters", ".", "clear", "(", ")", ";", "if", "(", "filtersArray", "!=", "null", ")", "Collections", ".", "addAll", "(", "filters", ",", "filtersArray", ")", ";", "}" ]

[ "Override", "the", "list", "of", "filters", "with", "given", "array", "." ]

[ "@", "Override", "public", "synchronized", "boolean", "isNotificationEnabled", "(", "Notification", "notification", ")", "{", "if", "(", "filters", ".", "isEmpty", "(", ")", ")", "{", "//Allow all", "return", "true", ";", "}", "final", "Iterator", "<", "NotificationFilter", ">", "i", "=", "filters", ".", "iterator", "(", ")", ";", "while", "(", "i", ".", "hasNext", "(", ")", ")", "{", "if", "(", "i", ".", "next", "(", ")", ".", "isNotificationEnabled", "(", "notification", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Handle", "notification", "filtering", "according", "to", "stored", "filters", "." ]

[ "public", "Boolean", "getApplicationExceptionRollback", "(", "Throwable", "t", ")", "// F743-14982", "{", "Class", "<", "?", ">", "klass", "=", "t", ".", "getClass", "(", ")", ";", "ApplicationException", "ae", "=", "getApplicationException", "(", "klass", ")", ";", "Boolean", "rollback", "=", "null", ";", "if", "(", "ae", "!=", "null", ")", "{", "rollback", "=", "ae", ".", "rollback", "(", ")", ";", "}", "// Prior to EJB 3.1, the specification did not explicitly state that", "// application exception status was inherited, so for efficiency, we", "// assumed it did not. The EJB 3.1 specification clarified this but", "// used a different default.", "else", "if", "(", "!", "ContainerProperties", ".", "EE5Compatibility", ")", "// F743-14982CdRv", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"searching for inherited application exception for \"", "+", "klass", ".", "getName", "(", ")", ")", ";", "}", "for", "(", "Class", "<", "?", ">", "superClass", "=", "klass", ".", "getSuperclass", "(", ")", ";", "superClass", "!=", "Throwable", ".", "class", ";", "superClass", "=", "superClass", ".", "getSuperclass", "(", ")", ")", "{", "ae", "=", "getApplicationException", "(", "superClass", ")", ";", "if", "(", "ae", "!=", "null", ")", "{", "// The exception class itself has already been checked.", "// If a super-class indicates that application exception", "// status is not inherited, then the exception is not", "// an application exception, so leave rollback null.", "if", "(", "ae", ".", "inherited", "(", ")", ")", "{", "rollback", "=", "ae", ".", "rollback", "(", ")", ";", "}", "break", ";", "}", "}", "}", "return", "rollback", ";", "}" ]

[ "Gets", "the", "application", "exception", "and", "rollback", "status", "of", "the", "specified", "exception", "." ]

[ "private", "ApplicationException", "getApplicationException", "(", "Class", "<", "?", ">", "klass", ")", "// F743-14982", "{", "ApplicationException", "result", "=", "null", ";", "if", "(", "ivApplicationExceptionMap", "!=", "null", ")", "{", "result", "=", "ivApplicationExceptionMap", ".", "get", "(", "klass", ".", "getName", "(", ")", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", "&&", "result", "!=", "null", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"found application-exception for \"", "+", "klass", ".", "getName", "(", ")", "+", "\", rollback=\"", "+", "result", ".", "rollback", "(", ")", "+", "\", inherited=\"", "+", "result", ".", "inherited", "(", ")", ")", ";", "}", "}", "if", "(", "result", "==", "null", ")", "{", "result", "=", "klass", ".", "getAnnotation", "(", "ApplicationException", ".", "class", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", "&&", "result", "!=", "null", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"found ApplicationException for \"", "+", "klass", ".", "getName", "(", ")", "+", "\", rollback=\"", "+", "result", ".", "rollback", "(", ")", "+", "\", inherited=\"", "+", "result", ".", "inherited", "(", ")", ")", ";", "}", "}", "return", "result", ";", "}" ]

[ "Gets", "the", "application", "exception", "status", "of", "the", "specified", "exception", "class", "from", "either", "the", "deployment", "descriptor", "or", "from", "the", "annotation", "." ]

[ "@", "Override", "public", "ComponentMetaData", "[", "]", "getComponentMetaDatas", "(", ")", "{", "ComponentMetaData", "[", "]", "initializedComponentMetaDatas", "=", "null", ";", "synchronized", "(", "ivEJBApplicationMetaData", ")", "{", "initializedComponentMetaDatas", "=", "new", "ComponentMetaData", "[", "ivNumFullyInitializedBeans", "]", ";", "int", "i", "=", "0", ";", "for", "(", "BeanMetaData", "bmd", ":", "ivBeanMetaDatas", ".", "values", "(", ")", ")", "{", "if", "(", "bmd", ".", "fullyInitialized", ")", "{", "initializedComponentMetaDatas", "[", "i", "++", "]", "=", "bmd", ";", "}", "}", "}", "return", "initializedComponentMetaDatas", ";", "}" ]

[ "Return", "an", "Array", "of", "fully", "initialized", "ComponentMetaDatas", "for", "this", "modules", "." ]

[ "public", "String", "toDumpString", "(", ")", "{", "// Get the New Line separator from the Java system property.", "String", "newLine", "=", "AccessController", ".", "doPrivileged", "(", "new", "SystemGetPropertyPrivileged", "(", "\"line.separator\"", ",", "\"\\n\"", ")", ")", ";", "StringBuilder", "sb", "=", "new", "StringBuilder", "(", "toString", "(", ")", ")", ";", "String", "indent", "=", "\" \"", ";", "sb", ".", "append", "(", "newLine", "+", "newLine", "+", "\"--- Dump EJBModuleMetaDataImpl fields ---\"", ")", ";", "if", "(", "ivName", "!=", "null", ")", "{", "sb", ".", "append", "(", "newLine", "+", "indent", "+", "\"Module name = \"", "+", "ivName", ")", ";", "}", "else", "{", "sb", ".", "append", "(", "newLine", "+", "indent", "+", "\"Module name = null\"", ")", ";", "}", "// F743-25385", "if", "(", "ivLogicalName", "!=", "null", ")", "{", "sb", ".", "append", "(", "newLine", "+", "indent", "+", "\"Module logical name = \"", "+", "ivLogicalName", ")", ";", "}", "else", "{", "sb", ".", "append", "(", "newLine", "+", "indent", "+", "\"Module logical name = null\"", ")", ";", "}", "sb", ".", "append", "(", "newLine", "+", "indent", "+", "\"Module version = \"", "+", "ivModuleVersion", ")", ";", "if", "(", "getApplicationMetaData", "(", ")", "!=", "null", ")", "{", "sb", ".", "append", "(", "newLine", "+", "indent", "+", "\"Application metadata = \"", "+", "getApplicationMetaData", "(", ")", ")", ";", "}", "else", "{", "sb", ".", "append", "(", "newLine", "+", "indent", "+", "\"Application metadata = null\"", ")", ";", "}", "sb", ".", "append", "(", "newLine", "+", "indent", "+", "\"Beans = \"", "+", "ivBeanMetaDatas", ".", "keySet", "(", ")", ")", ";", "if", "(", "ivApplicationExceptionMap", "!=", "null", ")", "{", "sb", ".", "append", "(", "newLine", "+", "indent", "+", "\"Application Exception map contents:\"", ")", ";", "for", "(", "Map", ".", "Entry", "<", "String", ",", "ApplicationException", ">", "entry", ":", "ivApplicationExceptionMap", ".", "entrySet", "(", ")", ")", "{", "// F743-14982", "ApplicationException", "value", "=", "entry", ".", "getValue", "(", ")", ";", "sb", ".", "append", "(", "newLine", "+", "indent", "+", "indent", "+", "\"Exception: \"", "+", "entry", ".", "getKey", "(", ")", "+", "\", rollback = \"", "+", "value", ".", "rollback", "(", ")", "+", "\", inherited = \"", "+", "value", ".", "inherited", "(", ")", ")", ";", "}", "}", "else", "{", "sb", ".", "append", "(", "newLine", "+", "indent", "+", "\"Application Exception map = null\"", ")", ";", "}", "sb", ".", "append", "(", "newLine", "+", "indent", "+", "\"SFSB failover = \"", "+", "ivSfsbFailover", ")", ";", "if", "(", "ivFailoverInstanceId", "!=", "null", ")", "{", "sb", ".", "append", "(", "newLine", "+", "indent", "+", "\"Failover instance ID = \"", "+", "ivFailoverInstanceId", ")", ";", "}", "else", "{", "sb", ".", "append", "(", "newLine", "+", "indent", "+", "\"Failover instance ID = null\"", ")", ";", "}", "sb", ".", "append", "(", "newLine", "+", "indent", "+", "\"Fully initialized bean count = \"", "+", "ivNumFullyInitializedBeans", ")", ";", "sb", ".", "append", "(", "newLine", "+", "indent", "+", "\"JCDIHelper = \"", "+", "ivJCDIHelper", ")", ";", "sb", ".", "append", "(", "newLine", "+", "indent", "+", "\"UseExtendedSetRollbackOnlyBehavior = \"", "+", "ivUseExtendedSetRollbackOnlyBehavior", ")", ";", "sb", ".", "append", "(", "newLine", "+", "indent", "+", "\"VersionedBaseName = \"", "+", "ivVersionedAppBaseName", "+", "\"#\"", "+", "ivVersionedModuleBaseName", ")", ";", "// F54184", "toString", "(", "sb", ",", "newLine", ",", "indent", ")", ";", "sb", ".", "append", "(", "newLine", "+", "\"--- End EJBModuleMetaDataImpl fields ---\"", ")", ";", "sb", ".", "append", "(", "newLine", ")", ";", "return", "sb", ".", "toString", "(", ")", ";", "}" ]

[ "Return", "a", "String", "with", "EJB", "Container", "s", "module", "level", "runtime", "config", "data" ]

[ "public", "void", "addApplicationEventListener", "(", "EJBApplicationEventListener", "listener", ")", "// F743-26072", "{", "final", "boolean", "isTraceOn", "=", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", ";", "if", "(", "isTraceOn", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"addApplicationEventListener: \"", "+", "listener", ")", ";", "if", "(", "ivApplicationEventListeners", "==", "null", ")", "{", "ivApplicationEventListeners", "=", "new", "ArrayList", "<", "EJBApplicationEventListener", ">", "(", ")", ";", "}", "ivApplicationEventListeners", ".", "add", "(", "listener", ")", ";", "}" ]

[ "Adds", "a", "new", "application", "even", "listener", "to", "be", "notified", "when", "an", "application", "has", "fully", "started", "or", "will", "begin", "stopping", "." ]

[ "public", "void", "addAutomaticTimerBean", "(", "AutomaticTimerBean", "timerBean", ")", "// d604213", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"addAutomaticTimerBean: \"", "+", "timerBean", ".", "getBeanMetaData", "(", ")", ".", "j2eeName", ")", ";", "if", "(", "ivAutomaticTimerBeans", "==", "null", ")", "{", "ivAutomaticTimerBeans", "=", "new", "ArrayList", "<", "AutomaticTimerBean", ">", "(", ")", ";", "}", "ivHasNonPersistentAutomaticTimers", "|=", "timerBean", ".", "getNumNonPersistentTimers", "(", ")", ">", "0", ";", "ivHasPersistentAutomaticTimers", "|=", "timerBean", ".", "getNumPersistentTimers", "(", ")", ">", "0", ";", "ivAutomaticTimerBeans", ".", "add", "(", "timerBean", ")", ";", "}" ]

[ "Adds", "a", "list", "of", "timer", "method", "metadata", "for", "a", "bean", "belonging", "to", "this", "application", ".", "This", "method", "will", "only", "be", "called", "for", "beans", "that", "contain", "automatic", "timers", "." ]

[ "public", "void", "freeResourcesAfterAllBeansInitialized", "(", "BeanMetaData", "bmd", ")", "{", "final", "boolean", "isTraceOn", "=", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", ";", "if", "(", "isTraceOn", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "entry", "(", "tc", ",", "\"freeResourcesAfterAllBeansInitialized: \"", "+", "bmd", ".", "j2eeName", "+", "\", \"", "+", "(", "ivNumFullyInitializedBeans", "+", "1", ")", "+", "\"/\"", "+", "ivBeanMetaDatas", ".", "size", "(", ")", ")", ";", "ivNumFullyInitializedBeans", "++", ";", "boolean", "freeResources", "=", "ivNumFullyInitializedBeans", "==", "ivBeanMetaDatas", ".", "size", "(", ")", ";", "// Free the resources if all beans have been initialized.", "if", "(", "freeResources", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"all beans are initialized in module name = \"", "+", "ivName", "+", "\", freeing resources no longer needed\"", ")", ";", "}", "// Since all beans are initialized, free any map no longer needed.", "ivInterceptorMap", "=", "null", ";", "ivInterceptorBindingMap", "=", "null", ";", "// d611747", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "exit", "(", "tc", ",", "\"freeResourcesAfterAllBeansInitialized\"", ")", ";", "}" ]

[ "d462512", "-", "log", "orphan", "warning", "message", "." ]

[ "@", "Override", "public", "void", "setVersionedModuleBaseName", "(", "String", "appBaseName", ",", "String", "modBaseName", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"ModuleName = \"", "+", "ivName", "+", "\", VersionedBaseName = \"", "+", "appBaseName", "+", "\"#\"", "+", "modBaseName", ")", ";", "if", "(", "ivInitData", "==", "null", ")", "{", "throw", "new", "IllegalStateException", "(", "\"ModuleMetaData has finished creation.\"", ")", ";", "}", "if", "(", "appBaseName", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"appBaseName is null\"", ")", ";", "}", "if", "(", "modBaseName", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"modBaseName is null\"", ")", ";", "}", "ivEJBApplicationMetaData", ".", "validateVersionedModuleBaseName", "(", "appBaseName", ",", "modBaseName", ")", ";", "ivVersionedAppBaseName", "=", "appBaseName", ";", "ivVersionedModuleBaseName", "=", "modBaseName", ";", "}" ]

[ "F54184", "F54184", ".", "2" ]

[ "private", "void", "addElement", "(", "String", "value", ")", "{", "if", "(", "null", "==", "value", ")", "{", "return", ";", "}", "this", ".", "num_items", "++", ";", "this", ".", "genericValues", ".", "add", "(", "value", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"addElement: \"", "+", "value", "+", "\" num: \"", "+", "this", ".", "num_items", ")", ";", "}", "}" ]

[ "Add", "the", "given", "element", "to", "the", "generic", "no", "-", "key", "storage", ".", "The", "value", "must", "be", "in", "lowercase", "form", "by", "the", "time", "of", "this", "call", "." ]

[ "private", "void", "addElement", "(", "String", "key", ",", "String", "value", ")", "{", "this", ".", "num_items", "++", ";", "List", "<", "String", ">", "vals", "=", "this", ".", "values", ".", "get", "(", "key", ")", ";", "if", "(", "null", "==", "vals", ")", "{", "vals", "=", "new", "LinkedList", "<", "String", ">", "(", ")", ";", "}", "if", "(", "null", "==", "value", ")", "{", "vals", ".", "add", "(", "\"\\\"\\\"\"", ")", ";", "}", "else", "{", "vals", ".", "add", "(", "value", ")", ";", "}", "this", ".", "values", ".", "put", "(", "key", ",", "vals", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"addElement: \"", "+", "key", "+", "\"=\"", "+", "value", "+", "\" num: \"", "+", "this", ".", "num_items", ")", ";", "}", "}" ]

[ "Add", "the", "given", "key", "=", "value", "pair", "into", "storage", ".", "Both", "key", "and", "value", "must", "be", "in", "lowercase", "form", ".", "If", "this", "key", "already", "exists", "then", "this", "value", "will", "be", "appended", "to", "the", "existing", "values", "." ]

[ "private", "void", "parse", "(", "String", "input", ")", "{", "char", "[", "]", "data", "=", "input", ".", "toCharArray", "(", ")", ";", "int", "start", "=", "0", ";", "int", "hard_stop", "=", "data", ".", "length", "-", "1", ";", "while", "(", "start", "<", "data", ".", "length", ")", "{", "if", "(", "this", ".", "mySep", "==", "data", "[", "start", "]", ")", "{", "start", "++", ";", "continue", ";", "}", "// look for the '=', end of data, or the separator", "int", "end", "=", "start", ";", "String", "key", "=", "null", ";", "boolean", "insideQuotes", "=", "false", ";", "while", "(", "end", "<", "data", ".", "length", ")", "{", "boolean", "extract", "=", "false", ";", "if", "(", "'", "'", "==", "data", "[", "end", "]", ")", "{", "insideQuotes", "=", "!", "insideQuotes", ";", "}", "else", "if", "(", "this", ".", "mySep", "==", "data", "[", "end", "]", ")", "{", "extract", "=", "true", ";", "end", "--", ";", "}", "else", "if", "(", "'", "'", "==", "data", "[", "end", "]", ")", "{", "// found a key", "key", "=", "extractString", "(", "data", ",", "start", ",", "end", "-", "1", ")", ";", "end", "++", ";", "// past the '='", "start", "=", "end", ";", "continue", ";", "}", "// if we're on the last character then always extract and quit", "if", "(", "end", "==", "hard_stop", ")", "{", "extract", "=", "true", ";", "}", "// if we need to, extract the value and continue", "if", "(", "extract", ")", "{", "String", "value", "=", "extractString", "(", "data", ",", "start", ",", "end", ")", ";", "if", "(", "null", "==", "key", ")", "{", "addElement", "(", "value", ")", ";", "}", "else", "{", "addElement", "(", "key", ",", "value", ")", ";", "}", "// at this point, end is pointing to the last char of the val", "end", "=", "end", "+", "2", ";", "// jump past delim", "start", "=", "end", ";", "if", "(", "!", "insideQuotes", ")", "{", "break", ";", "// out of while", "}", "continue", ";", "}", "end", "++", ";", "}", "}", "}" ]

[ "Parse", "the", "input", "string", "for", "all", "value", "possibilities", "." ]

[ "private", "String", "extractString", "(", "char", "[", "]", "data", ",", "int", "start", ",", "int", "end", ")", "{", "// skip leading whitespace and quotes", "while", "(", "start", "<", "end", "&&", "(", "'", "'", "==", "data", "[", "start", "]", "||", "'", "'", "==", "data", "[", "start", "]", "||", "'", "'", "==", "data", "[", "start", "]", ")", ")", "{", "start", "++", ";", "}", "// ignore trailing whitespace and quotes", "while", "(", "end", ">=", "start", "&&", "(", "'", "'", "==", "data", "[", "end", "]", "||", "'", "'", "==", "data", "[", "end", "]", "||", "'", "'", "==", "data", "[", "end", "]", ")", ")", "{", "end", "--", ";", "}", "// check for nothing but whitespace", "if", "(", "end", "<", "start", ")", "{", "return", "null", ";", "}", "int", "len", "=", "end", "-", "start", "+", "1", ";", "String", "rc", "=", "Normalizer", ".", "normalize", "(", "new", "String", "(", "data", ",", "start", ",", "len", ")", ",", "Normalizer", ".", "NORMALIZE_LOWER", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"extractString: [\"", "+", "rc", "+", "\"]\"", ")", ";", "}", "return", "rc", ";", "}" ]

[ "Extract", "a", "string", "from", "the", "input", "array", "based", "on", "the", "start", "and", "end", "markers", ".", "This", "will", "strip", "off", "any", "leading", "and", "trailing", "white", "space", "or", "quotes", "." ]

[ "public", "boolean", "add", "(", "String", "inputValue", ")", "{", "String", "value", "=", "Normalizer", ".", "normalize", "(", "inputValue", ",", "Normalizer", ".", "NORMALIZE_LOWER", ")", ";", "if", "(", "!", "contains", "(", "this", ".", "genericValues", ",", "value", ")", ")", "{", "addElement", "(", "value", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Add", "the", "generic", "value", "to", "this", "handler", "with", "no", "required", "key", "." ]

[ "public", "boolean", "add", "(", "String", "inputKey", ",", "String", "inputValue", ")", "{", "String", "key", "=", "Normalizer", ".", "normalize", "(", "inputKey", ",", "Normalizer", ".", "NORMALIZE_LOWER", ")", ";", "String", "value", "=", "Normalizer", ".", "normalize", "(", "inputValue", ",", "Normalizer", ".", "NORMALIZE_LOWER", ")", ";", "if", "(", "!", "contains", "(", "this", ".", "values", ".", "get", "(", "key", ")", ",", "value", ")", ")", "{", "addElement", "(", "key", ",", "value", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Add", "the", "given", "key", "=", "value", "pair", "to", "this", "handler", "." ]

[ "private", "boolean", "remove", "(", "List", "<", "String", ">", "list", ",", "String", "item", ")", "{", "if", "(", "null", "!=", "list", ")", "{", "if", "(", "list", ".", "remove", "(", "item", ")", ")", "{", "this", ".", "num_items", "--", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Remove", "the", "given", "item", "from", "the", "input", "list", "if", "present", "and", "update", "the", "item", "counter", "appropriately", "." ]

[ "public", "boolean", "remove", "(", "String", "inputKey", ",", "String", "inputValue", ")", "{", "String", "key", "=", "Normalizer", ".", "normalize", "(", "inputKey", ",", "Normalizer", ".", "NORMALIZE_LOWER", ")", ";", "String", "value", "=", "Normalizer", ".", "normalize", "(", "inputValue", ",", "Normalizer", ".", "NORMALIZE_LOWER", ")", ";", "boolean", "rc", "=", "remove", "(", "this", ".", "values", ".", "get", "(", "key", ")", ",", "value", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"remove: \"", "+", "key", "+", "\"=\"", "+", "value", "+", "\" rc=\"", "+", "rc", ")", ";", "}", "return", "rc", ";", "}" ]

[ "Remove", "this", "specific", "key", "=", "value", "pair", "from", "storage", ".", "If", "this", "key", "exists", "with", "other", "values", "then", "those", "will", "not", "be", "touched", "only", "the", "target", "value", "." ]

[ "public", "boolean", "remove", "(", "String", "inputValue", ")", "{", "String", "value", "=", "Normalizer", ".", "normalize", "(", "inputValue", ",", "Normalizer", ".", "NORMALIZE_LOWER", ")", ";", "boolean", "rc", "=", "remove", "(", "this", ".", "genericValues", ",", "value", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"remove: \"", "+", "value", "+", "\" rc=\"", "+", "rc", ")", ";", "}", "return", "rc", ";", "}" ]

[ "Remove", "the", "target", "value", "from", "the", "generic", "no", "-", "key", "storage", "." ]

[ "public", "int", "removeKey", "(", "String", "inputKey", ")", "{", "String", "key", "=", "Normalizer", ".", "normalize", "(", "inputKey", ",", "Normalizer", ".", "NORMALIZE_LOWER", ")", ";", "int", "num_removed", "=", "0", ";", "List", "<", "String", ">", "vals", "=", "this", ".", "values", ".", "remove", "(", "key", ")", ";", "if", "(", "null", "!=", "vals", ")", "{", "num_removed", "=", "vals", ".", "size", "(", ")", ";", "}", "this", ".", "num_items", "-=", "num_removed", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"removeKey: key=\"", "+", "key", "+", "\" \"", "+", "num_removed", ")", ";", "}", "return", "num_removed", ";", "}" ]

[ "Remove", "an", "entire", "key", "from", "storage", "regardless", "of", "how", "many", "values", "it", "may", "contain", "." ]

[ "private", "boolean", "contains", "(", "List", "<", "String", ">", "list", ",", "String", "item", ")", "{", "return", "(", "null", "==", "list", ")", "?", "false", ":", "list", ".", "contains", "(", "item", ")", ";", "}" ]

[ "Query", "whether", "the", "target", "list", "contains", "the", "item", "." ]

[ "public", "boolean", "containsKey", "(", "String", "inputKey", ")", "{", "String", "key", "=", "Normalizer", ".", "normalize", "(", "inputKey", ",", "Normalizer", ".", "NORMALIZE_LOWER", ")", ";", "List", "<", "String", ">", "list", "=", "this", ".", "values", ".", "get", "(", "key", ")", ";", "boolean", "rc", "=", "(", "null", "==", "list", ")", "?", "false", ":", "!", "list", ".", "isEmpty", "(", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"containsKey: key=\"", "+", "inputKey", "+", "\" rc=\"", "+", "rc", ")", ";", "}", "return", "rc", ";", "}" ]

[ "Query", "whether", "the", "target", "key", "exists", "with", "any", "values", "in", "this", "handler", "." ]

[ "public", "Iterator", "<", "String", ">", "getValues", "(", "String", "inputKey", ")", "{", "String", "key", "=", "Normalizer", ".", "normalize", "(", "inputKey", ",", "Normalizer", ".", "NORMALIZE_LOWER", ")", ";", "List", "<", "String", ">", "vals", "=", "this", ".", "values", ".", "get", "(", "key", ")", ";", "if", "(", "null", "!=", "vals", ")", "{", "return", "vals", ".", "iterator", "(", ")", ";", "}", "return", "new", "LinkedList", "<", "String", ">", "(", ")", ".", "iterator", "(", ")", ";", "}" ]

[ "Access", "an", "iterator", "of", "all", "values", "for", "the", "target", "key", "." ]

[ "public", "String", "marshall", "(", ")", "{", "if", "(", "0", "==", "this", ".", "num_items", ")", "{", "return", "\"\"", ";", "}", "boolean", "shouldPrepend", "=", "false", ";", "StringBuilder", "output", "=", "new", "StringBuilder", "(", "10", "*", "this", ".", "num_items", ")", ";", "// walk through the list of simple values (no key=value) first", "Iterator", "<", "String", ">", "i", "=", "this", ".", "genericValues", ".", "iterator", "(", ")", ";", "while", "(", "i", ".", "hasNext", "(", ")", ")", "{", "if", "(", "shouldPrepend", ")", "{", "output", ".", "append", "(", "this", ".", "mySep", ")", ";", "output", ".", "append", "(", "'", "'", ")", ";", "}", "output", ".", "append", "(", "i", ".", "next", "(", ")", ")", ";", "shouldPrepend", "=", "true", ";", "}", "// now walk through the list of key=value pairs, where value may actually", "// be multiple values", "i", "=", "this", ".", "values", ".", "keySet", "(", ")", ".", "iterator", "(", ")", ";", "while", "(", "i", ".", "hasNext", "(", ")", ")", "{", "String", "key", "=", "i", ".", "next", "(", ")", ";", "List", "<", "String", ">", "vals", "=", "this", ".", "values", ".", "get", "(", "key", ")", ";", "if", "(", "null", "==", "vals", ")", "continue", ";", "int", "size", "=", "vals", ".", "size", "(", ")", ";", "if", "(", "0", "==", "size", ")", "{", "// ignore an empty key", "continue", ";", "}", "if", "(", "shouldPrepend", ")", "{", "output", ".", "append", "(", "this", ".", "mySep", ")", ";", "output", ".", "append", "(", "'", "'", ")", ";", "}", "output", ".", "append", "(", "key", ")", ";", "output", ".", "append", "(", "'", "'", ")", ";", "if", "(", "1", "==", "size", ")", "{", "output", ".", "append", "(", "vals", ".", "get", "(", "0", ")", ")", ";", "}", "else", "{", "// multiple values need to be quote wrapped", "shouldPrepend", "=", "false", ";", "output", ".", "append", "(", "'", "'", ")", ";", "for", "(", "int", "count", "=", "0", ";", "count", "<", "size", ";", "count", "++", ")", "{", "if", "(", "shouldPrepend", ")", "{", "output", ".", "append", "(", "this", ".", "mySep", ")", ";", "output", ".", "append", "(", "'", "'", ")", ";", "}", "output", ".", "append", "(", "vals", ".", "get", "(", "count", ")", ")", ";", "shouldPrepend", "=", "true", ";", "}", "output", ".", "append", "(", "'", "'", ")", ";", "}", "shouldPrepend", "=", "true", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"marshalling [\"", "+", "output", ".", "toString", "(", ")", "+", "\"]\"", ")", ";", "}", "return", "output", ".", "toString", "(", ")", ";", "}" ]

[ "Take", "the", "current", "data", "in", "this", "handler", "and", "create", "the", "properly", "formatted", "string", "that", "would", "represent", "the", "header", "." ]

[ "public", "void", "clear", "(", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"Clearing this header handler: \"", "+", "this", ")", ";", "}", "this", ".", "num_items", "=", "0", ";", "this", ".", "values", ".", "clear", "(", ")", ";", "this", ".", "genericValues", ".", "clear", "(", ")", ";", "}" ]

[ "Clear", "everything", "out", "of", "storage", "for", "this", "handler", "." ]

[ "protected", "void", "proddle", "(", ")", "throws", "SIConnectionDroppedException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"proddle\"", ")", ";", "boolean", "useThisThread", "=", "false", ";", "synchronized", "(", "priorityQueue", ")", "{", "synchronized", "(", "this", ")", "{", "if", "(", "idle", ")", "{", "useThisThread", "=", "isWorkAvailable", "(", ")", ";", "idle", "=", "!", "useThisThread", ";", "}", "}", "}", "if", "(", "useThisThread", ")", "{", "doWork", "(", "false", ")", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "this", ",", "tc", ",", "\"proddle\"", ")", ";", "}" ]

[ "being", "F176003", "F181603", ".", "2", "D192359" ]

[ "public", "void", "complete", "(", "NetworkConnection", "vc", ",", "IOWriteRequestContext", "wctx", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"complete\"", ",", "new", "Object", "[", "]", "{", "vc", ",", "wctx", "}", ")", ";", "if", "(", "connection", ".", "isLoggingIOEvents", "(", ")", ")", "connection", ".", "getConnectionEventRecorder", "(", ")", ".", "logDebug", "(", "\"complete method invoked on write context \"", "+", "System", ".", "identityHashCode", "(", "wctx", ")", ")", ";", "try", "{", "doWork", "(", "true", ")", ";", "}", "catch", "(", "SIConnectionDroppedException", "connectionDroppedException", ")", "{", "// No FFDC code needed", "// This has been thrown because the priority queue was purged (most likely on another thread).", "// The exception is thrown to prevent threads in this method looping forever or hanging if the", "// conneciton is invalidate on another thread. Therefore we simply swallow this exception and", "// allow the thread to exit this method.", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "SibTr", ".", "debug", "(", "this", ",", "tc", ",", "\"Caught SIConnectionDroppedException, Priority Queue has been purged\"", ")", ";", "}", "catch", "(", "Error", "error", ")", "{", "FFDCFilter", ".", "processException", "(", "error", ",", "\"com.ibm.ws.sib.jfapchannel.impl.ConnectionWriteCompletedCallback\"", ",", "JFapChannelConstants", ".", "CONNWRITECOMPCALLBACK_COMPLETE_03", ",", "connection", ".", "getDiagnostics", "(", "true", ")", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEventEnabled", "(", ")", ")", "SibTr", ".", "exception", "(", "this", ",", "tc", ",", "error", ")", ";", "// It might appear slightly odd for this code to catch Error (especially since the JDK docs say", "// that Error means that something has gone so badly wrong that you should abandon all hope).", "// This code makes one final stab at putting out some diagnostics about what happened (if we", "// propagate the Error up to the TCP Channel, it is sometimes lost) and closing down the", "// connection. I figured that we might as well try to do something - as we can hardly make", "// things worse... (famous last words)", "connection", ".", "invalidate", "(", "false", ",", "error", ",", "\"Error caught in ConnectionWriteCompletedCallback.complete()\"", ")", ";", "// Re-throw the error to ensure that it causes the maximum devastation.", "// The JVM is probably very ill if an Error is thrown so attempt no recovery.", "throw", "error", ";", "}", "catch", "(", "RuntimeException", "runtimeException", ")", "{", "FFDCFilter", ".", "processException", "(", "runtimeException", ",", "\"com.ibm.ws.sib.jfapchannel.impl.ConnectionWriteCompletedCallback\"", ",", "JFapChannelConstants", ".", "CONNWRITECOMPCALLBACK_COMPLETE_04", ",", "connection", ".", "getDiagnostics", "(", "true", ")", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEventEnabled", "(", ")", ")", "SibTr", ".", "exception", "(", "this", ",", "tc", ",", "runtimeException", ")", ";", "// We can reasonably try to recover from a runtime exception by invalidating the associated", "// connection. This should drive the underlying TCP/IP socket to be closed.", "connection", ".", "invalidate", "(", "false", ",", "runtimeException", ",", "\"RuntimeException caught in ConnectionWriteCompletedCallback.complete()\"", ")", ";", "// Don't throw the RuntimeException on as we risk blowing away part of the TCP channel.", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "this", ",", "tc", ",", "\"complete\"", ")", ";", "}" ]

[ "begin", "F181603", ".", "2", "D192359" ]

[ "private", "void", "doWork", "(", "boolean", "hasWritten", ")", "throws", "SIConnectionDroppedException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"doWork\"", ",", "Boolean", ".", "valueOf", "(", "hasWritten", ")", ")", ";", "final", "BlockingQueue", "<", "Pair", "<", "SendListener", ",", "Conversation", ">", ">", "readySendCallbacks", "=", "new", "LinkedBlockingQueue", "<", "Pair", "<", "SendListener", ",", "Conversation", ">", ">", "(", ")", ";", "boolean", "hasGoneAsync", "=", "false", ";", "do", "{", "boolean", "hasMoreWork", ";", "do", "{", "if", "(", "hasWritten", ")", "{", "sendCallbacks", ".", "drainTo", "(", "readySendCallbacks", ")", ";", "}", "hasWritten", "=", "false", ";", "hasMoreWork", "=", "false", ";", "synchronized", "(", "priorityQueue", ")", "{", "synchronized", "(", "this", ")", "{", "if", "(", "!", "isWorkAvailable", "(", ")", ")", "break", ";", "}", "}", "final", "WsByteBuffer", "writeBuffer", "=", "getWriteContextBuffer", "(", ")", ";", "writeBuffer", ".", "clear", "(", ")", ";", "if", "(", "dequeueTransmissionData", "(", "writeBuffer", ")", ")", "{", "synchronized", "(", "connectionClosedLock", ")", "{", "if", "(", "!", "connectionClosed", ")", "{", "writeBuffer", ".", "flip", "(", ")", ";", "if", "(", "connection", ".", "isLoggingIOEvents", "(", ")", ")", "connection", ".", "getConnectionEventRecorder", "(", ")", ".", "logDebug", "(", "\"invoking writeCtx.write() on context \"", "+", "System", ".", "identityHashCode", "(", "writeCtx", ")", "+", "\" to write all data with no timeout\"", ")", ";", "final", "NetworkConnection", "vc", "=", "writeCtx", ".", "write", "(", "IOWriteRequestContext", ".", "WRITE_ALL_DATA", ",", "this", ",", "false", ",", "IOWriteRequestContext", ".", "NO_TIMEOUT", ")", ";", "hasGoneAsync", "=", "(", "vc", "==", "null", ")", ";", "hasWritten", "=", "true", ";", "hasMoreWork", "=", "!", "hasGoneAsync", ";", "}", "}", "}", "}", "while", "(", "hasMoreWork", ")", ";", "}", "while", "(", "!", "hasGoneAsync", "&&", "!", "switchToIdle", "(", ")", ")", ";", "// This thread is no longer tasked with writing activity, so it is now safe to notify the \"ready\" send listeners -", "// i.e. those whose messages have been completely sent.", "// (It was not safe to do so prior to this point, as the listeners may create more messages to be sent, which", "// could end in deadlock if this thread were still tasked with the writing.)", "notifyReadySendListeners", "(", "readySendCallbacks", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "this", ",", "tc", ",", "\"doWork\"", ")", ";", "}" ]

[ "Looks", "to", "initiate", "write", "operations", "to", "write", "all", "available", "data", "from", "the", "priority", "queue", "to", "the", "network", ".", "Continues", "until", "all", "data", "has", "been", "sent", "or", "until", "the", "return", "from", "a", "write", "call", "indicates", "its", "completion", "will", "be", "asynchronous", ".", "Once", "it", "has", "finished", "writing", "on", "this", "thread", "calls", "the", "registered", "send", "listeners", "for", "all", "messages", "that", "have", "been", "completely", "sent", "." ]

[ "private", "void", "notifyReadySendListeners", "(", "BlockingQueue", "<", "Pair", "<", "SendListener", ",", "Conversation", ">", ">", "readySendCallbacks", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"notifyReadySendListeners\"", ",", "readySendCallbacks", ")", ";", "try", "{", "for", "(", "Pair", "<", "SendListener", ",", "Conversation", ">", "callback", ":", "readySendCallbacks", ")", "{", "callback", ".", "left", ".", "dataSent", "(", "callback", ".", "right", ")", ";", "}", "}", "catch", "(", "Throwable", "t", ")", "{", "FFDCFilter", ".", "processException", "(", "t", ",", "\"com.ibm.ws.sib.jfapchannel.impl.ConnectionWriteCompletedCallback\"", ",", "JFapChannelConstants", ".", "CONNWRITECOMPCALLBACK_COMPLETE_01", ",", "connection", ".", "getDiagnostics", "(", "true", ")", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "SibTr", ".", "debug", "(", "tc", ",", "\"exception invoking send listener data sent\"", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEventEnabled", "(", ")", ")", "SibTr", ".", "exception", "(", "tc", ",", "t", ")", ";", "connection", ".", "invalidate", "(", "true", ",", "t", ",", "\"send listener threw exception\"", ")", ";", "// D224570", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "this", ",", "tc", ",", "\"notifyReadySendListeners\"", ")", ";", "}" ]

[ "Call", "send", "listener", "callback", "for", "each", "entry", "in", "the", "given", "queue", ".", "Any", "exception", "thrown", "from", "a", "listener", "s", "callback", "will", "cause", "the", "connection", "to", "be", "invalidated", "." ]

[ "private", "boolean", "switchToIdle", "(", ")", "throws", "SIConnectionDroppedException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"switchToIdle\"", ")", ";", "final", "boolean", "noMoreWork", ";", "synchronized", "(", "priorityQueue", ")", "{", "synchronized", "(", "this", ")", "{", "noMoreWork", "=", "!", "isWorkAvailable", "(", ")", ";", "idle", "=", "noMoreWork", ";", "}", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "this", ",", "tc", ",", "\"switchToIdle\"", ",", "Boolean", ".", "valueOf", "(", "noMoreWork", ")", ")", ";", "return", "noMoreWork", ";", "}" ]

[ "Switch", "the", "idle", "flag", "back", "to", "true", "provided", "that", "there", "is", "no", "work", "available", "." ]

[ "private", "WsByteBuffer", "getWriteContextBuffer", "(", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"getWriteContextBuffer\"", ")", ";", "WsByteBuffer", "writeBuffer", "=", "getSoleWriteContextBuffer", "(", ")", ";", "if", "(", "firstInvocation", ".", "compareAndSet", "(", "true", ",", "false", ")", "||", "(", "writeBuffer", "==", "null", ")", ")", "{", "final", "int", "writeBufferSize", "=", "Integer", ".", "parseInt", "(", "RuntimeInfo", ".", "getProperty", "(", "\"com.ibm.ws.sib.jfapchannel.DEFAULT_WRITE_BUFFER_SIZE\"", ",", "\"\"", "+", "JFapChannelConstants", ".", "DEFAULT_WRITE_BUFFER_SIZE", ")", ")", ";", "if", "(", "(", "writeBuffer", "!=", "null", ")", "&&", "(", "!", "writeBuffer", ".", "isDirect", "(", ")", "||", "writeBuffer", ".", "capacity", "(", ")", "<", "writeBufferSize", ")", ")", "{", "writeBuffer", ".", "release", "(", ")", ";", "writeBuffer", "=", "null", ";", "}", "if", "(", "writeBuffer", "==", "null", ")", "{", "writeBuffer", "=", "WsByteBufferPool", ".", "getInstance", "(", ")", ".", "allocateDirect", "(", "writeBufferSize", ")", ";", "// F196678.10", "writeCtx", ".", "setBuffer", "(", "writeBuffer", ")", ";", "}", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "this", ",", "tc", ",", "\"getWriteContextBuffer\"", ",", "writeBuffer", ")", ";", "return", "writeBuffer", ";", "}" ]

[ "Returns", "the", "single", "WsByteBuffer", "set", "in", "writeCtx", "ensuring", "that", "it", "is", "a", "direct", "byte", "buffer", "and", "is", "of", "sufficient", "capacity", "." ]

[ "private", "WsByteBuffer", "getSoleWriteContextBuffer", "(", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"getSoleWriteContextBuffer\"", ")", ";", "WsByteBuffer", "writeBuffer", "=", "null", ";", "final", "WsByteBuffer", "[", "]", "writeBuffers", "=", "writeCtx", ".", "getBuffers", "(", ")", ";", "if", "(", "writeBuffers", "!=", "null", ")", "{", "final", "int", "writeBuffersSize", "=", "writeBuffers", ".", "length", ";", "if", "(", "writeBuffersSize", ">", "0", ")", "{", "writeBuffer", "=", "writeBuffers", "[", "0", "]", ";", "if", "(", "writeBuffersSize", ">", "1", ")", "{", "writeCtx", ".", "setBuffer", "(", "writeBuffer", ")", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<", "writeBuffersSize", ";", "i", "++", ")", "{", "if", "(", "writeBuffers", "[", "i", "]", "!=", "null", ")", "writeBuffers", "[", "i", "]", ".", "release", "(", ")", ";", "}", "}", "}", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "this", ",", "tc", ",", "\"getSoleWriteContextBuffer\"", ",", "writeBuffer", ")", ";", "return", "writeBuffer", ";", "}" ]

[ "Returns", "the", "first", "WsByteBuffer", "set", "in", "writeCtx", "ensuring", "that", "it", "is", "the", "sole", "byte", "buffer", "set", "in", "writeCtx", "and", "releasing", "any", "other", "byte", "buffers", "that", "had", "been", "registered", "there", "." ]

[ "protected", "void", "physicalCloseNotification", "(", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"physicalCloseNotification\"", ")", ";", "synchronized", "(", "connectionClosedLock", ")", "{", "connectionClosed", "=", "true", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "this", ",", "tc", ",", "\"physicalCloseNotification\"", ")", ";", "}" ]

[ "Register", "notification", "that", "the", "physical", "underlying", "connection", "has", "been", "closed", "." ]

[ "private", "boolean", "isWorkAvailable", "(", ")", "throws", "SIConnectionDroppedException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"isWorkAvailable\"", ")", ";", "final", "boolean", "isWork", ";", "if", "(", "terminate", ")", "{", "isWork", "=", "false", ";", "}", "else", "{", "isWork", "=", "(", "partiallySentTransmission", "!=", "null", ")", "||", "!", "priorityQueue", ".", "isEmpty", "(", ")", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "this", ",", "tc", ",", "\"isWorkAvailable\"", ",", "Boolean", ".", "valueOf", "(", "isWork", ")", ")", ";", "return", "isWork", ";", "}" ]

[ "Returns", "true", "iff", "there", "is", "more", "work", "available", "to", "be", "processed", "." ]

[ "public", "static", "boolean", "addWarToServer", "(", "LibertyServer", "targetServer", ",", "String", "targetDir", ",", "String", "warName", ",", "String", "[", "]", "warPackageNames", ",", "boolean", "addWarResources", ")", "throws", "Exception", "{", "String", "earName", "=", "null", ";", "boolean", "addEarResources", "=", "DO_NOT_ADD_RESOURCES", ";", "String", "jarName", "=", "null", ";", "boolean", "addJarResources", "=", "DO_NOT_ADD_RESOURCES", ";", "String", "[", "]", "jarPackageNames", "=", "null", ";", "return", "addToServer", "(", "targetServer", ",", "targetDir", ",", "earName", ",", "addEarResources", ",", "warName", ",", "warPackageNames", ",", "addWarResources", ",", "jarName", ",", "jarPackageNames", ",", "addJarResources", ")", ";", "}" ]

[ "Package", "a", "WAR", "and", "add", "it", "to", "a", "server", "." ]

[ "public", "static", "boolean", "addToServer", "(", "LibertyServer", "targetServer", ",", "String", "targetDir", ",", "String", "earName", ",", "boolean", "addEarResources", ",", "String", "warName", ",", "String", "[", "]", "warPackageNames", ",", "boolean", "addWarResources", ",", "String", "jarName", ",", "String", "[", "]", "jarPackageNames", ",", "boolean", "addJarResources", ")", "throws", "Exception", "{", "if", "(", "warName", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"A war name must be specified.\"", ")", ";", "}", "if", "(", "targetServer", ".", "isStarted", "(", ")", ")", "{", "String", "appName", "=", "warName", ".", "substring", "(", "0", ",", "warName", ".", "indexOf", "(", "\".war\"", ")", ")", ";", "if", "(", "!", "targetServer", ".", "getInstalledAppNames", "(", "appName", ")", ".", "isEmpty", "(", ")", ")", "{", "return", "false", ";", "}", "}", "JavaArchive", "jar", ";", "if", "(", "jarName", "==", "null", ")", "{", "jar", "=", "null", ";", "}", "else", "{", "jar", "=", "createJar", "(", "jarName", ",", "jarPackageNames", ",", "addJarResources", ")", ";", "// throws Exception", "}", "WebArchive", "war", "=", "createWar", "(", "warName", ",", "warPackageNames", ",", "addWarResources", ",", "jar", ")", ";", "// throws Exception", "EnterpriseArchive", "ear", ";", "if", "(", "earName", "==", "null", ")", "{", "ear", "=", "null", ";", "}", "else", "{", "ear", "=", "createEar", "(", "earName", ",", "addEarResources", ",", "war", ")", ";", "// throws Exception", "}", "if", "(", "ear", "!=", "null", ")", "{", "ShrinkHelper", ".", "exportToServer", "(", "targetServer", ",", "targetDir", ",", "ear", ")", ";", "// throws Exception", "}", "else", "{", "ShrinkHelper", ".", "exportToServer", "(", "targetServer", ",", "targetDir", ",", "war", ")", ";", "// throws Exception", "}", "return", "true", ";", "}" ]

[ "Conditionally", "package", "a", "JAR", "WAR", "and", "EAR", "and", "add", "them", "to", "a", "server", "." ]

[ "public", "boolean", "couldContainAnnotationsOnClassDef", "(", "DataInput", "in", ",", "Set", "<", "String", ">", "byteCodeAnnotationsNames", ")", "throws", "IOException", "{", "/* According to Java VM Spec, each .class file contains\n * a single class or interface definition. The structure\n * definition is shown below:\n\n ClassFile {\n u4 magic;\n u2 minor_version;\n u2 major_version;\n u2 constant_pool_count;\n cp_info constant_pool[constant_pool_count-1];\n u2 access_flags;\n u2 this_class;\n u2 super_class;\n u2 interfaces_count;\n u2 interfaces[interfaces_count];\n u2 fields_count;\n field_info fields[fields_count];\n u2 methods_count;\n method_info methods[methods_count];\n u2 attributes_count;\n attribute_info attributes[attributes_count];\n }\n\n * u1 = readUnsignedByte \n * u2 = readUnsignedShort\n * u4 = readInt\n * \n */", "int", "magic", "=", "in", ".", "readInt", "(", ")", ";", "//u4", "if", "(", "magic", "!=", "0xCAFEBABE", ")", "{", "//the file is not recognized as a class file ", "return", "false", ";", "}", "//u2 but since in java does not exists unsigned,", "//store on a bigger value", "int", "minorVersion", "=", "in", ".", "readUnsignedShort", "(", ")", ";", "//u2", "int", "majorVersion", "=", "in", ".", "readUnsignedShort", "(", ")", ";", "//u2", "if", "(", "majorVersion", "<", "49", ")", "{", "//Compiled with jdk 1.4, so does not have annotations", "return", "false", ";", "}", "//constantsPoolCount is the number of entries + 1", "//The index goes from 1 to constantsPoolCount-1", "int", "constantsPoolCount", "=", "in", ".", "readUnsignedShort", "(", ")", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<", "constantsPoolCount", ";", "i", "++", ")", "{", "// Format:", "// cp_info {", "// u1 tag;", "// u1 info[];", "// }", "int", "tag", "=", "in", ".", "readUnsignedByte", "(", ")", ";", "switch", "(", "tag", ")", "{", "case", "CP_INFO_UTF8", ":", "//u2 length", "//u1 bytes[length]", "//Check if the string is a annotation reference", "//name", "String", "name", "=", "in", ".", "readUTF", "(", ")", ";", "if", "(", "byteCodeAnnotationsNames", ".", "contains", "(", "name", ")", ")", "{", "return", "true", ";", "}", "break", ";", "case", "CP_INFO_CLASS", ":", "//ignore", "//u2 name_index", "in", ".", "readUnsignedShort", "(", ")", ";", "break", ";", "case", "CP_INFO_FIELD_REF", ":", "//ignore", "case", "CP_INFO_METHOD_REF", ":", "//ignore", "case", "CP_INFO_INTERFACE_REF", ":", "//ignore", "//u2 class_index", "//u2 name_and_type_index", "in", ".", "readUnsignedShort", "(", ")", ";", "in", ".", "readUnsignedShort", "(", ")", ";", "break", ";", "case", "CP_INFO_STRING", ":", "//ignore", "//u2 string_index", "in", ".", "readUnsignedShort", "(", ")", ";", "break", ";", "case", "CP_INFO_INTEGER", ":", "//ignore", "case", "CP_INFO_FLOAT", ":", "//ignore", "//u4 bytes", "in", ".", "readInt", "(", ")", ";", "break", ";", "case", "CP_INFO_LONG", ":", "//ignore", "case", "CP_INFO_DOUBLE", ":", "//ignore", "//u4 high_bytes", "//u4 low_bytes", "in", ".", "readInt", "(", ")", ";", "in", ".", "readInt", "(", ")", ";", "// this tag takes two entries in the constants pool", "i", "++", ";", "break", ";", "case", "CP_INFO_NAME_AND_TYPE", ":", "//ignore", "//u2 name_index", "//u2 descriptor_index", "in", ".", "readUnsignedShort", "(", ")", ";", "in", ".", "readUnsignedShort", "(", ")", ";", "break", ";", "case", "CP_INFO_METHOD_HANDLE", ":", "// Ignore", "// u1 reference_kind", "// u2 reference_index", "in", ".", "readUnsignedByte", "(", ")", ";", "in", ".", "readUnsignedShort", "(", ")", ";", "break", ";", "case", "CP_INFO_METHOD_TYPE", ":", "// Ignore", "// u2 descriptor_index", "in", ".", "readUnsignedShort", "(", ")", ";", "break", ";", "case", "CP_INFO_INVOKE_DYNAMIC", ":", "// Ignore", "// u2 bootstrap_method_attr_index;", "// u2 name_and_type_index;", "in", ".", "readUnsignedShort", "(", ")", ";", "in", ".", "readUnsignedShort", "(", ")", ";", "break", ";", "default", ":", "// THIS SHOULD NOT HAPPEN! Log error info", "// and break for loop, because from this point", "// we are reading corrupt data.", "if", "(", "log", ".", "isLoggable", "(", "Level", ".", "WARNING", ")", ")", "{", "log", ".", "warning", "(", "\"Unknown tag in constants pool: \"", "+", "tag", ")", ";", "}", "i", "=", "constantsPoolCount", ";", "break", ";", "}", "}", "return", "false", ";", "}" ]

[ "Checks", "if", "the", ".", "class", "file", "referenced", "by", "the", "DataInput", "could", "contain", "the", "annotation", "names", "available", "in", "the", "set", "." ]

[ "public", "Properties", "getProperties", "(", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"getProperties\"", ")", ";", "return", "this", ".", "sslProperties", ";", "}" ]

[ "Access", "the", "current", "properties", "for", "this", "context", "." ]

[ "public", "void", "setProperties", "(", "Properties", "sslProps", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"setProperties\"", ")", ";", "this", ".", "sslProperties", "=", "sslProps", ";", "}" ]

[ "Set", "the", "properties", "for", "this", "thread", "context", "." ]

[ "public", "boolean", "getSetSignerOnThread", "(", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"getSetSignerOnThread: \"", "+", "this", ".", "setSignerOnThread", ")", ";", "return", "this", ".", "setSignerOnThread", ";", "}" ]

[ "Query", "whether", "the", "signer", "flag", "is", "set", "on", "this", "context", "." ]

[ "public", "boolean", "getAutoAcceptBootstrapSigner", "(", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"getAutoAcceptBootstrapSigner: \"", "+", "this", ".", "autoAcceptBootstrapSigner", ")", ";", "return", "this", ".", "autoAcceptBootstrapSigner", ";", "}" ]

[ "Query", "whether", "the", "autoaccept", "bootstrap", "signer", "flag", "is", "set", "on", "this", "context", "." ]

[ "public", "Map", "<", "String", ",", "Object", ">", "getInboundConnectionInfo", "(", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"getInboundConnectionInfo\"", ")", ";", "return", "this", ".", "inboundConnectionInfo", ";", "}" ]

[ "Access", "the", "inbound", "connection", "info", "object", "for", "this", "context", "." ]

[ "public", "void", "setAutoAcceptBootstrapSigner", "(", "boolean", "flag", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"setAutoAcceptBootstrapSigner -> \"", "+", "flag", ")", ";", "this", ".", "autoAcceptBootstrapSigner", "=", "flag", ";", "}" ]

[ "Set", "the", "autoaccept", "bootstrap", "signer", "flag", "on", "this", "context", "to", "the", "input", "value", "." ]

[ "public", "boolean", "getAutoAcceptBootstrapSignerWithoutStorage", "(", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"getAutoAcceptBootstrapSignerWithoutStorage: \"", "+", "this", ".", "autoAcceptBootstrapSignerWithoutStorage", ")", ";", "return", "this", ".", "autoAcceptBootstrapSignerWithoutStorage", ";", "}" ]

[ "Query", "whether", "the", "autoaccept", "bootstrap", "signer", "without", "storage", "flag", "is", "set", "on", "this", "context", "." ]

[ "public", "void", "setAutoAcceptBootstrapSignerWithoutStorage", "(", "boolean", "flag", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"setAutoAcceptBootstrapSignerWithoutStorage -> \"", "+", "flag", ")", ";", "this", ".", "autoAcceptBootstrapSignerWithoutStorage", "=", "flag", ";", "}" ]

[ "Set", "the", "autoaccept", "bootstrap", "signer", "without", "storage", "flag", "to", "the", "input", "value", "." ]

[ "public", "void", "setSetSignerOnThread", "(", "boolean", "flag", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"setSetSignerOnThread: \"", "+", "flag", ")", ";", "this", ".", "setSignerOnThread", "=", "flag", ";", "}" ]

[ "Set", "the", "signer", "flag", "on", "this", "context", "to", "the", "input", "value", "." ]

[ "public", "X509Certificate", "[", "]", "getSignerChain", "(", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"getSignerChain\"", ")", ";", "return", "signer", "==", "null", "?", "null", ":", "signer", ".", "clone", "(", ")", ";", "}" ]

[ "Query", "the", "signer", "chain", "set", "on", "this", "context", "." ]

[ "public", "void", "setSignerChain", "(", "X509Certificate", "[", "]", "signerChain", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"setSignerChain\"", ")", ";", "this", ".", "signer", "=", "signerChain", "==", "null", "?", "null", ":", "signerChain", ".", "clone", "(", ")", ";", "}" ]

[ "Set", "the", "signer", "chain", "on", "this", "context", "to", "the", "input", "value", "." ]

[ "public", "void", "setInboundConnectionInfo", "(", "Map", "<", "String", ",", "Object", ">", "connectionInfo", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"setInboundConnectionInfo\"", ")", ";", "this", ".", "inboundConnectionInfo", "=", "connectionInfo", ";", "}" ]

[ "Set", "the", "inbound", "connection", "info", "on", "this", "context", "to", "the", "input", "value", "." ]

[ "public", "Map", "<", "String", ",", "Object", ">", "getOutboundConnectionInfo", "(", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"getOutboundConnectionInfo\"", ")", ";", "return", "this", ".", "outboundConnectionInfo", ";", "}" ]

[ "Query", "the", "outbound", "connection", "info", "map", "of", "this", "context", "." ]

[ "public", "void", "setOutboundConnectionInfo", "(", "Map", "<", "String", ",", "Object", ">", "connectionInfo", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"setOutboundConnectionInfo\"", ")", ";", "this", ".", "outboundConnectionInfo", "=", "connectionInfo", ";", "}" ]

[ "Set", "the", "outbound", "connection", "info", "of", "this", "context", "to", "the", "input", "value", "." ]

[ "public", "Map", "<", "String", ",", "Object", ">", "getOutboundConnectionInfoInternal", "(", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"getOutboundConnectionInfoInternal\"", ")", ";", "return", "this", ".", "outboundConnectionInfoInternal", ";", "}" ]

[ "Get", "the", "internal", "outbound", "connection", "info", "object", "for", "this", "context", "." ]

[ "public", "void", "setOutboundConnectionInfoInternal", "(", "Map", "<", "String", ",", "Object", ">", "connectionInfo", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"setOutboundConnectionInfoInternal :\"", "+", "connectionInfo", ")", ";", "this", ".", "outboundConnectionInfoInternal", "=", "connectionInfo", ";", "}" ]

[ "Set", "the", "internal", "outbound", "connection", "info", "object", "for", "this", "context", "." ]

[ "protected", "byte", "[", "]", "serializeObject", "(", "Serializable", "theObject", ")", "throws", "IOException", "{", "ByteArrayOutputStream", "baos", "=", "new", "ByteArrayOutputStream", "(", ")", ";", "ObjectOutputStream", "oout", "=", "new", "ObjectOutputStream", "(", "baos", ")", ";", "oout", ".", "writeObject", "(", "theObject", ")", ";", "byte", "[", "]", "data", "=", "baos", ".", "toByteArray", "(", ")", ";", "baos", ".", "close", "(", ")", ";", "oout", ".", "close", "(", ")", ";", "return", "data", ";", "}" ]

[ "This", "method", "is", "used", "to", "serialized", "an", "object", "saved", "into", "a", "table", "BLOB", "field", "." ]

[ "public", "void", "setPuName", "(", "String", "puName", ")", "{", "// re-initialize puName only if it has not been set to avoid", "// overriding valid relative puName defined in annotation/dd.", "if", "(", "ivPuName", "==", "null", "||", "ivPuName", ".", "length", "(", ")", "==", "0", ")", "// d442457", "{", "ivPuName", "=", "puName", ";", "reComputeHashCode", "(", ")", ";", "// d416151.3.9", "}", "}" ]

[ "Persistence", "unit", "name", "setter", "." ]

[ "private", "void", "reComputeHashCode", "(", ")", "{", "ivCurHashCode", "=", "(", "ivAppName", "!=", "null", "?", "ivAppName", ".", "hashCode", "(", ")", ":", "0", ")", "// d437828", "+", "(", "ivModJarName", "!=", "null", "?", "ivModJarName", ".", "hashCode", "(", ")", ":", "0", ")", "+", "(", "ivPuName", "!=", "null", "?", "ivPuName", ".", "hashCode", "(", ")", ":", "0", ")", ";", "}" ]

[ "Compute", "and", "cache", "the", "current", "hashCode", "." ]

[ "public", "ChildChannelDataImpl", "createChild", "(", ")", "{", "String", "childName", "=", "this", ".", "name", "+", "CHILD_STRING", "+", "nextChildId", "(", ")", ";", "ChildChannelDataImpl", "child", "=", "new", "ChildChannelDataImpl", "(", "childName", ",", "this", ")", ";", "this", ".", "children", ".", "add", "(", "child", ")", ";", "return", "child", ";", "}" ]

[ "Create", "a", "child", "data", "object", ".", "Add", "it", "to", "the", "list", "of", "children", "and", "return", "it", "." ]

[ "private", "static", "ReadableLogRecord", "read", "(", "ByteBuffer", "viewBuffer", ",", "long", "expectedSequenceNumber", ",", "ByteBuffer", "sourceBuffer", ")", "{", "ReadableLogRecord", "logRecord", "=", "null", ";", "int", "absolutePosition", "=", "sourceBuffer", ".", "position", "(", ")", "+", "viewBuffer", ".", "position", "(", ")", ";", "// Read the record magic number field.", "final", "byte", "[", "]", "magicNumberBuffer", "=", "new", "byte", "[", "RECORD_MAGIC_NUMBER", ".", "length", "]", ";", "viewBuffer", ".", "get", "(", "magicNumberBuffer", ")", ";", "int", "recordLength", "=", "0", ";", "if", "(", "Arrays", ".", "equals", "(", "magicNumberBuffer", ",", "RECORD_MAGIC_NUMBER", ")", ")", "{", "long", "recordSequenceNumber", "=", "viewBuffer", ".", "getLong", "(", ")", ";", "if", "(", "recordSequenceNumber", ">=", "expectedSequenceNumber", ")", "{", "// The record sequence is consistent with the expected sequence number supplied by the", "// caller. So skip over the actual log record data in this record so that", "// we can check the tail sequence number.", "recordLength", "=", "viewBuffer", ".", "getInt", "(", ")", ";", "// Preserve the current byte cursor position so that we can reset back to it later. ", "// Move the byte cursor to the first byte after the record data.", "final", "int", "recordDataPosition", "=", "viewBuffer", ".", "position", "(", ")", ";", "viewBuffer", ".", "position", "(", "recordDataPosition", "+", "recordLength", ")", ";", "// Read the repeated record sequence number", "final", "long", "tailSequenceNumber", "=", "viewBuffer", ".", "getLong", "(", ")", ";", "// Because are are only looking for sequence numbers larger than expected the only assurance that we", "// have not read garbage following the magic number is that the first and tail sequence numbers are equal.", "// Note its still possible garbage is in the data but that can't be helped without changing the log format.", "// It will be discovered later no doubt!", "if", "(", "tailSequenceNumber", "==", "recordSequenceNumber", ")", "{", "// Return the buffer's pointer to the start of", "// the record's data prior to creating a new", "// ReadableLogRecord to return to the caller.", "viewBuffer", ".", "position", "(", "recordDataPosition", ")", ";", "logRecord", "=", "new", "ReadableLogRecord", "(", "viewBuffer", ",", "absolutePosition", ",", "tailSequenceNumber", ")", ";", "// Advance the original buffer's position to the end of this record. This ensures that", "// the next ReadableLogRecord or WritableLogRecord constructed will read or write the", "// next record in the file.", "sourceBuffer", ".", "position", "(", "absolutePosition", "+", "HEADER_SIZE", "+", "recordLength", ")", ";", "}", "}", "}", "return", "logRecord", ";", "}" ]

[ "careful", "with", "trace", "in", "this", "method", "as", "it", "is", "called", "many", "times", "from", "doByteByByteScanning" ]

[ "private", "static", "ReadableLogRecord", "doByteByByteScanning", "(", "ByteBuffer", "sourceBuffer", ",", "long", "expectedSequenceNumber", ")", "{", "if", "(", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "entry", "(", "tc", ",", "\"doByteByByteScanning\"", ",", "new", "Object", "[", "]", "{", "sourceBuffer", ",", "new", "Long", "(", "expectedSequenceNumber", ")", "}", ")", ";", "ReadableLogRecord", "logRecord", "=", "null", ";", "ByteBuffer", "viewBuffer", "=", "sourceBuffer", ".", "slice", "(", ")", ";", "// If there is a partial write, or a missing record, the next valid record will be at least LogRecord.HEADER_SIZE", "// forward from the current position so skip to that in the viewBuffer and start from there.", "for", "(", "int", "position", "=", "LogRecord", ".", "HEADER_SIZE", ";", "position", "+", "LogRecord", ".", "HEADER_SIZE", "<", "viewBuffer", ".", "limit", "(", ")", ";", "// its possible we will be able to find a record in the remainder ", "position", "++", ")", "{", "viewBuffer", ".", "position", "(", "position", ")", ";", "// Peak 2 bytes to get RC in RCRD before bothering to try parse a Record.", "// This saves stack frames and avoids some Exceptions which should help with startup times", "byte", "peak", "=", "viewBuffer", ".", "get", "(", "position", ")", ";", "if", "(", "peak", "==", "82", ")", "// 'R'", "{", "peak", "=", "viewBuffer", ".", "get", "(", "position", "+", "1", ")", ";", "if", "(", "peak", "==", "67", ")", "// C - its a kinda magic, worth having a go.", "{", "try", "{", "logRecord", "=", "read", "(", "viewBuffer", ",", "expectedSequenceNumber", ",", "sourceBuffer", ")", ";", "if", "(", "logRecord", "!=", "null", ")", "break", ";", "// we found a valid record, sourceBuffer position has been updated", "}", "catch", "(", "RuntimeException", "e", ")", "{", "// No FFDC code needed", "// continue till the end of the loop", "}", "}", "}", "}", "if", "(", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "exit", "(", "tc", ",", "\"doByteByByteScanning\"", ",", "logRecord", ")", ";", "return", "logRecord", ";", "}" ]

[ "careful", "with", "trace", "in", "this", "methods", "loop" ]

[ "public", "synchronized", "boolean", "add", "(", "String", "key", ",", "T", "value", ")", "{", "if", "(", "key", ".", "length", "(", ")", ">", "3", "&&", "key", ".", "endsWith", "(", "WILDCARD", ")", "&&", "key", ".", "charAt", "(", "key", ".", "length", "(", ")", "-", "2", ")", "!=", "'", "'", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Unsupported use of wildcard in key \"", "+", "key", ")", ";", "}", "// Find the key in the structure (build out to it)", "Node", "<", "T", ">", "current", "=", "internalFind", "(", "key", ",", "false", ")", ";", "// Return false if the key already exists", "if", "(", "current", ".", "getValue", "(", ")", "!=", "null", ")", "return", "false", ";", "// Set the value and return true", "current", ".", "setValue", "(", "value", ")", ";", "return", "true", ";", "}" ]

[ "Add", "a", "new", "value", "using", "the", "given", "key", "." ]

[ "public", "void", "compact", "(", ")", "{", "// Bare-bones iterator: no filter, don't bother with package strings", "for", "(", "NodeIterator", "<", "T", ">", "i", "=", "this", ".", "getNodeIterator", "(", ")", ";", "i", ".", "hasNext", "(", ")", ";", ")", "{", "NodeIndex", "<", "T", ">", "n", "=", "i", ".", "next", "(", ")", ";", "if", "(", "n", ".", "node", ".", "exactKids", "!=", "null", ")", "n", ".", "node", ".", "exactKids", ".", "trimToSize", "(", ")", ";", "}", "}" ]

[ "Compact", "any", "empty", "space", "after", "a", "read", "-", "only", "trie", "has", "been", "constructed" ]

[ "public", "String", "dump", "(", ")", "{", "StringBuilder", "s", "=", "new", "StringBuilder", "(", ")", ";", "int", "c", "=", "0", ";", "// we need the flavor of iterator that does build up a package string so we can", "// include it in the generated string", "s", ".", "append", "(", "nl", ")", ";", "for", "(", "NodeIterator", "<", "T", ">", "i", "=", "this", ".", "getNodeIterator", "(", "null", ")", ";", "i", ".", "hasNext", "(", ")", ";", ")", "{", "NodeIndex", "<", "T", ">", "n", "=", "i", ".", "next", "(", ")", ";", "c", "++", ";", "s", ".", "append", "(", "'", "'", ")", ".", "append", "(", "n", ".", "pkg", ")", ".", "append", "(", "\" = \"", ")", ".", "append", "(", "n", ".", "node", ".", "getValue", "(", ")", ")", ".", "append", "(", "nl", ")", ";", "}", "s", ".", "append", "(", "\"\\t---> \"", ")", ".", "append", "(", "c", ")", ".", "append", "(", "\" elements\"", ")", ";", "return", "s", ".", "toString", "(", ")", ";", "}" ]

[ "Debugging", "during", "test", "dump", "for", "FFDC" ]

[ "NodeIterator", "<", "T", ">", "getNodeIterator", "(", "Filter", "<", "T", ">", "filter", ")", "{", "return", "new", "NodeIterator", "<", "T", ">", "(", "root", ",", "filter", ",", "true", ")", ";", "}" ]

[ "Get", "an", "internal", "iterator", "for", "nodes", "that", "allows", "filtering", "based", "on", "packages", "or", "values", "." ]

[ "public", "void", "modifed", "(", "ServiceReference", "<", "ResourceFactory", ">", "ref", ")", "{", "String", "[", "]", "newInterfaces", "=", "getServiceInterfaces", "(", "ref", ")", ";", "if", "(", "!", "Arrays", ".", "equals", "(", "interfaces", ",", "newInterfaces", ")", ")", "{", "unregister", "(", ")", ";", "register", "(", "ref", ",", "newInterfaces", ")", ";", "}", "else", "{", "registration", ".", "setProperties", "(", "getServiceProperties", "(", "ref", ")", ")", ";", "}", "}" ]

[ "Notification", "that", "the", "properties", "for", "the", "ResourceFactory", "changed", "." ]

[ "@", "Override", "public", "List", "<", "PersistenceProvider", ">", "getPersistenceProviders", "(", ")", "{", "// try to get the context classloader first, if that fails, use the loader", "// that loaded this class", "ClassLoader", "cl", "=", "PrivClassLoader", ".", "get", "(", "null", ")", ";", "if", "(", "cl", "==", "null", ")", "{", "cl", "=", "PrivClassLoader", ".", "get", "(", "HybridPersistenceActivator", ".", "class", ")", ";", "}", "// Query the provider cache per-classloader", "List", "<", "PersistenceProvider", ">", "nonOSGiProviders", "=", "providerCache", ".", "get", "(", "cl", ")", ";", "// Get all providers not registered in OSGi. These will be any third-party providers", "// available to the application classloader.", "if", "(", "nonOSGiProviders", "==", "null", ")", "{", "nonOSGiProviders", "=", "new", "ArrayList", "<", "PersistenceProvider", ">", "(", ")", ";", "try", "{", "List", "<", "Object", ">", "providers", "=", "ProviderLocator", ".", "getServices", "(", "PersistenceProvider", ".", "class", ".", "getName", "(", ")", ",", "getClass", "(", ")", ",", "cl", ")", ";", "for", "(", "Iterator", "<", "Object", ">", "provider", "=", "providers", ".", "iterator", "(", ")", ";", "provider", ".", "hasNext", "(", ")", ";", ")", "{", "Object", "o", "=", "provider", ".", "next", "(", ")", ";", "if", "(", "o", "instanceof", "PersistenceProvider", ")", "{", "nonOSGiProviders", ".", "add", "(", "(", "PersistenceProvider", ")", "o", ")", ";", "}", "}", "// load the providers into the provider cache for the context (or current) classloader", "providerCache", ".", "put", "(", "cl", ",", "nonOSGiProviders", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "PersistenceException", "(", "\"Failed to load provider from META-INF/services\"", ",", "e", ")", ";", "}", "}", "List", "<", "PersistenceProvider", ">", "combinedProviders", "=", "new", "ArrayList", "<", "PersistenceProvider", ">", "(", "nonOSGiProviders", ")", ";", "combinedProviders", ".", "addAll", "(", "super", ".", "getPersistenceProviders", "(", ")", ")", ";", "return", "combinedProviders", ";", "}" ]

[ "This", "method", "returns", "a", "combination", "of", "those", "persistence", "providers", "available", "from", "the", "application", "classloader", "in", "addition", "to", "those", "in", "the", "OSGi", "service", "registry", ".", "OSGi", "providers", "are", "not", "cached", "and", "should", "not", "be", "cached", "because", "bundles", "can", "be", "moved", "in", "and", "out", "of", "the", "system", "and", "it", "is", "the", "job", "of", "the", "the", "service", "tracker", "to", "maintain", "them", "." ]

[ "@", "Override", "public", "boolean", "add", "(", "Object", "o", ")", "{", "ConnectorProperty", "connectorPropertyToAdd", "=", "(", "ConnectorProperty", ")", "o", ";", "String", "nameToAdd", "=", "connectorPropertyToAdd", ".", "getName", "(", ")", ";", "ConnectorProperty", "connectorProperty", "=", "null", ";", "String", "name", "=", "null", ";", "Enumeration", "<", "Object", ">", "e", "=", "this", ".", "elements", "(", ")", ";", "while", "(", "e", ".", "hasMoreElements", "(", ")", ")", "{", "connectorProperty", "=", "(", "ConnectorProperty", ")", "e", ".", "nextElement", "(", ")", ";", "name", "=", "connectorProperty", ".", "getName", "(", ")", ";", "if", "(", "name", ".", "equals", "(", "nameToAdd", ")", ")", "{", "if", "(", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "String", "value", "=", "(", "String", ")", "connectorPropertyToAdd", ".", "getValue", "(", ")", ";", "if", "(", "!", "value", ".", "equals", "(", "\"\"", ")", ")", "{", "if", "(", "name", ".", "equals", "(", "\"UserName\"", ")", "||", "name", ".", "equals", "(", "\"Password\"", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"DUPLICATE_USERNAME_PASSWORD_CONNECTOR_PROPERTY_J2CA0103\"", ",", "new", "Object", "[", "]", "{", "(", "ConnectorProperty", ")", "o", "}", ")", ";", "}", "else", "{", "Tr", ".", "warning", "(", "tc", ",", "\"DUPLICATE_CONNECTOR_PROPERTY_J2CA0308\"", ",", "new", "Object", "[", "]", "{", "(", "ConnectorProperty", ")", "o", "}", ")", ";", "}", "}", "}", "return", "true", ";", "}", "}", "return", "super", ".", "add", "(", "o", ")", ";", "}" ]

[ "override", "the", "Vector", "add", "method", "to", "not", "add", "duplicate", "entries", ".", "That", "is", "entries", "with", "the", "same", "name", "." ]

[ "public", "String", "findConnectorPropertyString", "(", "String", "desiredPropertyName", ",", "String", "defaultValue", ")", "{", "String", "retVal", "=", "defaultValue", ";", "String", "name", "=", "null", ";", "ConnectorProperty", "property", "=", "null", ";", "Enumeration", "<", "Object", ">", "e", "=", "this", ".", "elements", "(", ")", ";", "while", "(", "e", ".", "hasMoreElements", "(", ")", ")", "{", "property", "=", "(", "ConnectorProperty", ")", "e", ".", "nextElement", "(", ")", ";", "name", "=", "property", ".", "getName", "(", ")", ";", "if", "(", "name", ".", "equals", "(", "desiredPropertyName", ")", ")", "{", "retVal", "=", "(", "String", ")", "property", ".", "getValue", "(", ")", ";", "}", "}", "return", "retVal", ";", "}" ]

[ "Given", "this", "ConnectorProperties", "Vector", "find", "the", "String", "identified", "by", "the", "input", "desiredPropertyName", ".", "If", "not", "found", "return", "the", "defaultValue", "." ]

[ "public", "void", "handleMessage", "(", "MessageItem", "msgItem", ")", "throws", "SIResourceException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"handleMessage\"", ",", "new", "Object", "[", "]", "{", "msgItem", "}", ")", ";", "JsMessage", "jsMsg", "=", "msgItem", ".", "getMessage", "(", ")", ";", "int", "priority", "=", "jsMsg", ".", "getPriority", "(", ")", ".", "intValue", "(", ")", ";", "Reliability", "reliability", "=", "jsMsg", ".", "getReliability", "(", ")", ";", "StreamSet", "streamSet", "=", "getStreamSetForMessage", "(", "jsMsg", ")", ";", "if", "(", "streamSet", "==", "null", ")", "{", "handleNewStreamID", "(", "msgItem", ")", ";", "}", "else", "{", "TargetStream", "targetStream", "=", "null", ";", "synchronized", "(", "streamSet", ")", "{", "targetStream", "=", "(", "TargetStream", ")", "streamSet", ".", "getStream", "(", "priority", ",", "reliability", ")", ";", "if", "(", "targetStream", "==", "null", ")", "{", "targetStream", "=", "createStream", "(", "streamSet", ",", "priority", ",", "reliability", ",", "streamSet", ".", "getPersistentData", "(", "priority", ",", "reliability", ")", ")", ";", "}", "}", "// Update the stateStream with this message", "// The stateStream itself will do Gap detection", "// Note that the message cannot be written to the MsgStore or", "// delivered to the ConsumerDispatcher until the stream is", "// in order. The TargetStream calls back into this class", "// using the deliverOrderedMessages() method to do this once", "// it has an ordered stream", "targetStream", ".", "writeValue", "(", "msgItem", ")", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"handleMessage\"", ")", ";", "}" ]

[ "Handle", "a", "new", "message", "by", "inserting", "it", "in", "to", "the", "appropriate", "target", "stream", ".", "If", "the", "stream", "ID", "in", "the", "message", "is", "a", "new", "one", "a", "flush", "query", "will", "be", "sent", "to", "the", "source", ".", "If", "the", "ID", "has", "been", "seen", "before", "but", "the", "specific", "stream", "is", "not", "found", "a", "new", "one", "will", "be", "created", "and", "added", "to", "the", "stream", "set", "." ]

[ "public", "void", "handleSilence", "(", "MessageItem", "msgItem", ")", "throws", "SIResourceException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"handleSilence\"", ",", "new", "Object", "[", "]", "{", "msgItem", "}", ")", ";", "JsMessage", "jsMsg", "=", "msgItem", ".", "getMessage", "(", ")", ";", "int", "priority", "=", "jsMsg", ".", "getPriority", "(", ")", ".", "intValue", "(", ")", ";", "Reliability", "reliability", "=", "jsMsg", ".", "getReliability", "(", ")", ";", "StreamSet", "streamSet", "=", "getStreamSetForMessage", "(", "jsMsg", ")", ";", "if", "(", "streamSet", "!=", "null", ")", "{", "TargetStream", "targetStream", "=", "null", ";", "synchronized", "(", "streamSet", ")", "{", "targetStream", "=", "(", "TargetStream", ")", "streamSet", ".", "getStream", "(", "priority", ",", "reliability", ")", ";", "}", "if", "(", "targetStream", "!=", "null", ")", "{", "// Update the stateStream with Silence", "targetStream", ".", "writeSilence", "(", "msgItem", ")", ";", "}", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"handleSilence\"", ")", ";", "}" ]

[ "Handle", "a", "filtered", "message", "by", "inserting", "it", "in", "to", "the", "appropriate", "target", "stream", "as", "Silence", ".", "Since", "we", "only", "need", "to", "do", "this", "on", "exisiting", "TargetStreams", "if", "the", "streamSet", "or", "stream", "are", "null", "we", "give", "up" ]

[ "private", "void", "handleNewStreamID", "(", "ControlMessage", "cMsg", ")", "throws", "SIResourceException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "tc", ",", "\"handleNewStreamID\"", ",", "new", "Object", "[", "]", "{", "cMsg", "}", ")", ";", "handleNewStreamID", "(", "cMsg", ",", "null", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"handleNewStreamID\"", ")", ";", "}" ]

[ "Handle", "a", "new", "stream", "ID", "from", "a", "control", "message" ]

[ "private", "void", "handleNewStreamID", "(", "AbstractMessage", "aMessage", ",", "MessageItem", "msgItem", ")", "throws", "SIResourceException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "tc", ",", "\"handleNewStreamID\"", ",", "new", "Object", "[", "]", "{", "aMessage", ",", "msgItem", "}", ")", ";", "SIBUuid12", "streamID", "=", "aMessage", ".", "getGuaranteedStreamUUID", "(", ")", ";", "// Synchronize to resolve race between multiple messages on same", "// stream. Can't actually happen until multihop, e.g. messages on", "// same stream arrive simultaneously from multiple cellules.", "synchronized", "(", "flushMap", ")", "{", "// Otherwise, create a new flush query record and proceed", "FlushQueryRecord", "entry", "=", "flushMap", ".", "get", "(", "streamID", ")", ";", "if", "(", "(", "entry", "!=", "null", ")", "&&", "(", "msgItem", "!=", "null", ")", ")", "{", "// Since the entry already exists, somebody else already", "// started the timer so all we have to do is cache the", "// message for replay later.", "entry", ".", "append", "(", "msgItem", ")", ";", "}", "else", "{", "// Otherwise, new entry:", "// 1. Create a request ID and flush record, store it in the map.", "// 2. Create and send an \"are you flushed\".", "// 3. Start an alarm to repeat \"are you flushed\" a set number of", "// times.", "SIBUuid8", "sourceMEUuid", "=", "aMessage", ".", "getGuaranteedSourceMessagingEngineUUID", "(", ")", ";", "SIBUuid12", "destID", "=", "aMessage", ".", "getGuaranteedTargetDestinationDefinitionUUID", "(", ")", ";", "SIBUuid8", "busID", "=", "aMessage", ".", "getGuaranteedCrossBusSourceBusUUID", "(", ")", ";", "// Create and store the request record", "long", "reqID", "=", "messageProcessor", ".", "nextTick", "(", ")", ";", "entry", "=", "new", "FlushQueryRecord", "(", "sourceMEUuid", ",", "destID", ",", "busID", ",", "msgItem", ",", "reqID", ")", ";", "flushMap", ".", "put", "(", "streamID", ",", "entry", ")", ";", "// Create and send the query", "// TODO: create a proper srcID here", "upControl", ".", "sendAreYouFlushedMessage", "(", "sourceMEUuid", ",", "destID", ",", "busID", ",", "reqID", ",", "streamID", ")", ";", "// Start the alarm. The context for the alarm is the stream id, which", "// we can use to look up the FlushQueryRecord if the alarm expires.", "entry", ".", "resend", "=", "am", ".", "create", "(", "GDConfig", ".", "FLUSH_QUERY_INTERVAL", ",", "this", ",", "streamID", ")", ";", "}", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"handleNewStreamID\"", ")", ";", "}" ]

[ "Handle", "a", "new", "stream", "ID", "and", "cache", "a", "MessageItem", "for", "replay", "later", ".", "msgItem", "can", "be", "null", "for", "example", "if", "this", "was", "triggered", "by", "a", "control", "message", "." ]

[ "private", "StreamSet", "addNewStreamSet", "(", "SIBUuid12", "streamID", ",", "SIBUuid8", "sourceMEUuid", ",", "SIBUuid12", "remoteDestUuid", ",", "SIBUuid8", "remoteBusUuid", ",", "String", "linkTarget", ")", "throws", "SIRollbackException", ",", "SIConnectionLostException", ",", "SIIncorrectCallException", ",", "SIResourceException", ",", "SIErrorException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "tc", ",", "\"addNewStreamSet\"", ",", "new", "Object", "[", "]", "{", "streamID", ",", "sourceMEUuid", ",", "remoteDestUuid", ",", "remoteBusUuid", ",", "linkTarget", "}", ")", ";", "StreamSet", "streamSet", "=", "null", ";", "try", "{", "LocalTransaction", "tran", "=", "txManager", ".", "createLocalTransaction", "(", "false", ")", ";", "Transaction", "msTran", "=", "txManager", ".", "resolveAndEnlistMsgStoreTransaction", "(", "tran", ")", ";", "//create a persistent stream set", "streamSet", "=", "new", "StreamSet", "(", "streamID", ",", "sourceMEUuid", ",", "remoteDestUuid", ",", "remoteBusUuid", ",", "protocolItemStream", ",", "txManager", ",", "0", ",", "destination", ".", "isLink", "(", ")", "?", "StreamSet", ".", "Type", ".", "LINK_TARGET", ":", "StreamSet", ".", "Type", ".", "TARGET", ",", "tran", ",", "linkTarget", ")", ";", "protocolItemStream", ".", "addItem", "(", "streamSet", ",", "msTran", ")", ";", "tran", ".", "commit", "(", ")", ";", "synchronized", "(", "streamSets", ")", "{", "streamSets", ".", "put", "(", "streamID", ",", "streamSet", ")", ";", "sourceMap", ".", "put", "(", "streamID", ",", "sourceMEUuid", ")", ";", "}", "}", "catch", "(", "OutOfCacheSpace", "e", ")", "{", "// No FFDC code needed", "SibTr", ".", "exception", "(", "tc", ",", "e", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"addNewStreamSet\"", ",", "e", ")", ";", "throw", "new", "SIResourceException", "(", "e", ")", ";", "}", "catch", "(", "MessageStoreException", "e", ")", "{", "// MessageStoreException shouldn't occur so FFDC.", "FFDCFilter", ".", "processException", "(", "e", ",", "\"com.ibm.ws.sib.processor.gd.TargetStreamManager.addNewStreamSet\"", ",", "\"1:471:1.69\"", ",", "this", ")", ";", "SibTr", ".", "exception", "(", "tc", ",", "e", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"addNewStreamSet\"", ",", "e", ")", ";", "throw", "new", "SIResourceException", "(", "e", ")", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"addNewStreamSet\"", ",", "streamSet", ")", ";", "return", "streamSet", ";", "}" ]

[ "Create", "a", "new", "StreamSet", "for", "a", "given", "streamID", "and", "sourceCellule", "." ]

[ "private", "TargetStream", "createStream", "(", "StreamSet", "streamSet", ",", "int", "priority", ",", "Reliability", "reliability", ",", "long", "completedPrefix", ")", "throws", "SIResourceException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "tc", ",", "\"createStream\"", ",", "new", "Object", "[", "]", "{", "streamSet", ",", "Integer", ".", "valueOf", "(", "priority", ")", ",", "reliability", ",", "Long", ".", "valueOf", "(", "completedPrefix", ")", "}", ")", ";", "TargetStream", "stream", "=", "null", ";", "stream", "=", "createStream", "(", "streamSet", ",", "priority", ",", "reliability", ")", ";", "stream", ".", "setCompletedPrefix", "(", "completedPrefix", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"createStream\"", ")", ";", "return", "stream", ";", "}" ]

[ "Create", "a", "new", "TargetStream", "and", "initialize", "it", "with", "a", "given", "completed", "prefix", ".", "Always", "called", "with", "streamSet", "lock" ]

[ "private", "TargetStream", "createStream", "(", "StreamSet", "streamSet", ",", "int", "priority", ",", "Reliability", "reliability", ")", "throws", "SIResourceException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "tc", ",", "\"createStream\"", ",", "new", "Object", "[", "]", "{", "streamSet", ",", "Integer", ".", "valueOf", "(", "priority", ")", ",", "reliability", "}", ")", ";", "TargetStream", "stream", "=", "null", ";", "if", "(", "reliability", ".", "compareTo", "(", "Reliability", ".", "BEST_EFFORT_NONPERSISTENT", ")", "<=", "0", ")", "{", "stream", "=", "new", "ExpressTargetStream", "(", "deliverer", ",", "streamSet", ".", "getRemoteMEUuid", "(", ")", ",", "streamSet", ".", "getStreamID", "(", ")", ")", ";", "}", "else", "{", "//Warning - this assumes that ASSURED is always the highest Reliability", "//and that UNKNOWN is always the lowest (0).", "stream", "=", "new", "GuaranteedTargetStream", "(", "deliverer", ",", "upControl", ",", "am", ",", "streamSet", ",", "priority", ",", "//priority", "reliability", ",", "//reliability", "new", "ArrayList", "(", ")", ",", "messageProcessor", ")", ";", "}", "streamSet", ".", "setStream", "(", "priority", ",", "reliability", ",", "stream", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"createStream\"", ",", "stream", ")", ";", "return", "stream", ";", "}" ]

[ "Create", "a", "new", "TargetStream", "in", "the", "given", "StreamSet" ]

[ "public", "void", "handleFlushedMessage", "(", "ControlFlushed", "cMsg", ")", "throws", "SIResourceException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"handleFlushedMessage\"", ",", "new", "Object", "[", "]", "{", "cMsg", "}", ")", ";", "SIBUuid12", "streamID", "=", "cMsg", ".", "getGuaranteedStreamUUID", "(", ")", ";", "forceFlush", "(", "streamID", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"handleFlushedMessage\"", ")", ";", "}" ]

[ "Handle", "a", "ControlFlushed", "message", ".", "Flush", "any", "existing", "streams", "and", "throw", "away", "any", "cached", "messages", "." ]

[ "public", "void", "forceFlush", "(", "SIBUuid12", "streamID", ")", "throws", "SIResourceException", ",", "SIResourceException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"forceFlush\"", ",", "new", "Object", "[", "]", "{", "streamID", "}", ")", ";", "// Synchronize to resolve racing messages.", "synchronized", "(", "flushMap", ")", "{", "FlushQueryRecord", "entry", "=", "flushMap", ".", "remove", "(", "streamID", ")", ";", "// Remove the entry (we may not have even had", "// one), then clean up any existing stream state. Also, make", "// sure we turn off the alarm if there IS an entry. Note that", "// an alarm will always be present if an entry exists.", "if", "(", "entry", "!=", "null", ")", "entry", ".", "resend", ".", "cancel", "(", ")", ";", "flush", "(", "streamID", ")", ";", "}", "//If all the inbound stream sets are empty, queue the destination that the", "//inbound streams are for to the asynch deletion thread, incase any cleanup", "//of the destination is required. If not, the asynch deletion thread will do", "//nothing.", "// if (isEmpty())", "// {", "// DestinationManager destinationManager = messageProcessor.getDestinationManager();", "// BaseDestinationHandler destinationHandler = protocolItemStream.getDestinationHandler();", "// destinationManager.markDestinationAsCleanUpPending(destinationHandler);", "// }", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"forceFlush\"", ")", ";", "}" ]

[ "Flush", "any", "existing", "streams", "and", "throw", "away", "any", "cached", "messages", "." ]

[ "public", "void", "requestFlushAtSource", "(", "SIBUuid8", "source", ",", "SIBUuid12", "destID", ",", "SIBUuid8", "busID", ",", "SIBUuid12", "stream", ",", "boolean", "indoubtDiscard", ")", "throws", "SIException", ",", "SIResourceException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"requestFlushAtSource\"", ",", "new", "Object", "[", "]", "{", "source", ",", "stream", "}", ")", ";", "// Synchronize here to avoid races (not that we expect any)", "synchronized", "(", "flushMap", ")", "{", "if", "(", "flushMap", ".", "containsKey", "(", "stream", ")", ")", "{", "// Already a request on the way so ignore.", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"requestFlushAtSource\"", ")", ";", "return", ";", "}", "// Ok, new entry:", "// 1. Create a request ID and flush record, store it in the map.", "// 2. Create and send an \"request flush\".", "// 3. Start an alarm to repeat \"request flush\" a set number of", "// times.", "// Create and store the request record", "long", "reqID", "=", "messageProcessor", ".", "nextTick", "(", ")", ";", "FlushQueryRecord", "entry", "=", "new", "FlushQueryRecord", "(", "source", ",", "destID", ",", "busID", ",", "reqID", ")", ";", "flushMap", ".", "put", "(", "stream", ",", "entry", ")", ";", "// Create and send the query", "upControl", ".", "sendRequestFlushMessage", "(", "source", ",", "destID", ",", "busID", ",", "reqID", ",", "stream", ",", "indoubtDiscard", ")", ";", "// Start the alarm. The context for the alarm is the stream ID,", "// which we can use to look up the FlushQueryRecord if the alarm", "// expires.", "entry", ".", "resend", "=", "am", ".", "create", "(", "GDConfig", ".", "REQUEST_FLUSH_INTERVAL", ",", "this", ",", "stream", ")", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"requestFlushAtSource\"", ")", ";", "}" ]

[ "Send", "a", "request", "to", "flush", "a", "stream", ".", "The", "originator", "of", "the", "stream", "and", "the", "ID", "for", "the", "stream", "must", "be", "known", ".", "This", "method", "is", "public", "because", "it", "s", "not", "clear", "who", "s", "going", "to", "call", "this", "yet", "." ]

[ "public", "void", "handleSilenceMessage", "(", "ControlSilence", "cMsg", ")", "throws", "SIResourceException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"handleSilenceMessage\"", ",", "new", "Object", "[", "]", "{", "cMsg", "}", ")", ";", "int", "priority", "=", "cMsg", ".", "getPriority", "(", ")", ".", "intValue", "(", ")", ";", "Reliability", "reliability", "=", "cMsg", ".", "getReliability", "(", ")", ";", "SIBUuid12", "streamID", "=", "cMsg", ".", "getGuaranteedStreamUUID", "(", ")", ";", "StreamSet", "streamSet", "=", "getStreamSetForMessage", "(", "cMsg", ")", ";", "if", "(", "streamSet", "==", "null", ")", "{", "//if this is a new stream ID, send a flush query", "handleNewStreamID", "(", "cMsg", ")", ";", "}", "else", "{", "TargetStream", "targetStream", "=", "null", ";", "synchronized", "(", "streamSet", ")", "{", "targetStream", "=", "(", "TargetStream", ")", "streamSet", ".", "getStream", "(", "priority", ",", "reliability", ")", ";", "if", "(", "targetStream", "==", "null", ")", "{", "//if the specific stream does not exist, create it", "targetStream", "=", "createStream", "(", "streamSet", ",", "priority", ",", "reliability", ",", "streamSet", ".", "getPersistentData", "(", "priority", ",", "reliability", ")", ")", ";", "}", "}", "// Update the statestream with this information", "targetStream", ".", "writeSilence", "(", "cMsg", ")", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"handleSilenceMessage\"", ")", ";", "}" ]

[ "Handle", "a", "ControlSilence", "message", "." ]

[ "public", "void", "reconstituteStreamSet", "(", "StreamSet", "streamSet", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"reconstituteStreamSet\"", ",", "streamSet", ")", ";", "synchronized", "(", "streamSets", ")", "{", "streamSets", ".", "put", "(", "streamSet", ".", "getStreamID", "(", ")", ",", "streamSet", ")", ";", "sourceMap", ".", "put", "(", "streamSet", ".", "getStreamID", "(", ")", ",", "streamSet", ".", "getRemoteMEUuid", "(", ")", ")", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"reconstituteStreamSet\"", ")", ";", "}" ]

[ "Restore", "a", "StreamSet", "to", "a", "previous", "state" ]

[ "public", "void", "alarm", "(", "Object", "alarmContext", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"alarm\"", ",", "alarmContext", ")", ";", "// Alarm context should be an sid, make it so.", "SIBUuid12", "sid", "=", "(", "SIBUuid12", ")", "alarmContext", ";", "// synchronized here in case we're racing with an answer to our", "// query.", "synchronized", "(", "flushMap", ")", "{", "// See if the query record is still around", "FlushQueryRecord", "entry", "=", "flushMap", ".", "get", "(", "sid", ")", ";", "if", "(", "entry", "!=", "null", ")", "{", "// Query still active, see if we need to restart.", "entry", ".", "attempts", "--", ";", "if", "(", "entry", ".", "attempts", ">", "0", ")", "{", "// Yup, resend the query and reset the alarm. If", "// entry.cached is null, then this is a \"request flush\"", "// rather than an \"are you flushed\".", "try", "{", "if", "(", "entry", ".", "cache", "==", "null", ")", "{", "upControl", ".", "sendRequestFlushMessage", "(", "entry", ".", "source", ",", "entry", ".", "destId", ",", "entry", ".", "busId", ",", "entry", ".", "requestID", ",", "sid", ",", "false", ")", ";", "//TODO check indoubtDiscard", "}", "else", "{", "upControl", ".", "sendAreYouFlushedMessage", "(", "entry", ".", "source", ",", "entry", ".", "destId", ",", "entry", ".", "busId", ",", "entry", ".", "requestID", ",", "sid", ")", ";", "}", "}", "catch", "(", "SIResourceException", "e", ")", "{", "// No FFDC code needed", "// If we run out of resources, then give up on the query", "// and log an error. This is probably only important for", "// \"request flush\" queries.", "flushMap", ".", "remove", "(", "sid", ")", ";", "// TODO: actually, this should be an admin message.", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEventEnabled", "(", ")", ")", "SibTr", ".", "event", "(", "tc", ",", "\"Flush query failed for stream: \"", "+", "sid", ")", ";", "}", "}", "else", "{", "// Nope, didn't work. Remove the query record, log the event,", "// and exit.", "flushMap", ".", "remove", "(", "sid", ")", ";", "// TODO: actually, this should be an admin message.", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEventEnabled", "(", ")", ")", "SibTr", ".", "event", "(", "tc", ",", "\"Flush query expired for stream: \"", "+", "sid", ")", ";", "}", "}", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"alarm\"", ")", ";", "}" ]

[ "This", "method", "is", "called", "when", "an", "alarm", "expires", "for", "an", "are", "you", "flushed", "or", "flush", "request", "query", "." ]

[ "public", "boolean", "isEmpty", "(", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "{", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"isEmpty\"", ")", ";", "SibTr", ".", "exit", "(", "tc", ",", "\"isEmpty\"", ",", "new", "Object", "[", "]", "{", "Boolean", ".", "valueOf", "(", "streamSets", ".", "isEmpty", "(", ")", ")", ",", "Boolean", ".", "valueOf", "(", "flushedStreamSets", ".", "isEmpty", "(", ")", ")", ",", "streamSets", ",", "this", "}", ")", ";", "}", "// Don't report empty until any pending flushes have completed.", "// Otherwise we may run into a race with an async delete thread", "// for the destination.", "return", "(", "streamSets", ".", "isEmpty", "(", ")", "&&", "flushedStreamSets", ".", "isEmpty", "(", ")", ")", ";", "}" ]

[ "Determine", "if", "there", "are", "any", "unflushed", "target", "streams", "to", "the", "destination" ]

[ "public", "void", "queryUnflushedStreams", "(", ")", "throws", "SIResourceException", "{", "synchronized", "(", "streamSets", ")", "{", "for", "(", "Iterator", "i", "=", "streamSets", ".", "iterator", "(", ")", ";", "i", ".", "hasNext", "(", ")", ";", ")", "{", "StreamSet", "next", "=", "(", "StreamSet", ")", "i", ".", "next", "(", ")", ";", "// Note the use of -1 for the request ID. This guarantees", "// that we won't accidentally overlap with a request", "// in the local request map.", "upControl", ".", "sendAreYouFlushedMessage", "(", "next", ".", "getRemoteMEUuid", "(", ")", ",", "next", ".", "getDestUuid", "(", ")", ",", "next", ".", "getBusUuid", "(", ")", ",", "-", "1", ",", "next", ".", "getStreamID", "(", ")", ")", ";", "}", "}", "}" ]

[ "Sends", "an", "are", "you", "flushed", "query", "to", "the", "source", "of", "any", "unflushed", "streams", ".", "We", "use", "this", "to", "determine", "when", "it", "s", "safe", "to", "delete", "a", "destination", "with", "possibly", "indoubt", "messages", "." ]

[ "private", "boolean", "validateAutomaticTimer", "(", "BeanMetaData", "bmd", ")", "{", "if", "(", "bmd", ".", "timedMethodInfos", "==", "null", "||", "methodId", ">", "bmd", ".", "timedMethodInfos", ".", "length", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"validateAutomaticTimer: ivMethodId=\"", "+", "methodId", "+", "\" > \"", "+", "Arrays", ".", "toString", "(", "bmd", ".", "timedMethodInfos", ")", ")", ";", "return", "false", ";", "}", "Method", "method", "=", "bmd", ".", "timedMethodInfos", "[", "methodId", "]", ".", "ivMethod", ";", "if", "(", "!", "method", ".", "getName", "(", ")", ".", "equals", "(", "automaticMethodName", ")", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"validateAutomaticTimer: ivAutomaticMethodName=\"", "+", "automaticMethodName", "+", "\" != \"", "+", "method", ".", "getName", "(", ")", ")", ";", "return", "false", ";", "}", "if", "(", "automaticClassName", "!=", "null", "&&", "!", "automaticClassName", ".", "equals", "(", "method", ".", "getDeclaringClass", "(", ")", ".", "getName", "(", ")", ")", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"validateAutomaticTimer: ivAutomaticClassName=\"", "+", "automaticClassName", "+", "\" != \"", "+", "method", ".", "getDeclaringClass", "(", ")", ".", "getName", "(", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Validate", "that", "the", "method", "corresponding", "to", "the", "method", "ID", "stored", "in", "the", "database", "matches", "the", "method", "that", "was", "used", "when", "the", "automatic", "timer", "was", "created", ".", "For", "example", "this", "validation", "will", "fail", "if", "the", "application", "is", "changed", "to", "remove", "an", "automatic", "timer", "without", "clearing", "the", "timers", "from", "the", "database", ".", "As", "a", "prerequisite", "to", "calling", "this", "method", "this", "object", "must", "be", "an", "automatic", "timer", "." ]

[ "private", "void", "writeObject", "(", "ObjectOutputStream", "out", ")", "throws", "IOException", "{", "final", "boolean", "isTraceOn", "=", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", ";", "if", "(", "isTraceOn", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "entry", "(", "tc", ",", "\"writeObject: \"", "+", "this", ")", ";", "// Use v1 unless features are present that require v2.", "int", "version", "=", "Constants", ".", "TIMER_TASK_V1", ";", "if", "(", "parsedSchedule", "!=", "null", ")", "{", "version", "=", "Constants", ".", "TIMER_TASK_V2", ";", "}", "out", ".", "defaultWriteObject", "(", ")", ";", "// Write out header information first.", "out", ".", "write", "(", "EYECATCHER", ")", ";", "out", ".", "writeShort", "(", "PLATFORM", ")", ";", "out", ".", "writeShort", "(", "version", ")", ";", "// Write out the instance data.", "out", ".", "writeObject", "(", "j2eeName", ".", "getBytes", "(", ")", ")", ";", "out", ".", "writeObject", "(", "userInfoBytes", ")", ";", "switch", "(", "version", ")", "{", "case", "Constants", ".", "TIMER_TASK_V1", ":", "out", ".", "writeLong", "(", "expiration", ")", ";", "out", ".", "writeLong", "(", "interval", ")", ";", "break", ";", "case", "Constants", ".", "TIMER_TASK_V2", ":", "out", ".", "writeObject", "(", "parsedSchedule", ")", ";", "out", ".", "writeInt", "(", "methodId", ")", ";", "out", ".", "writeObject", "(", "automaticMethodName", ")", ";", "out", ".", "writeObject", "(", "automaticClassName", ")", ";", "break", ";", "default", ":", "// cannot occur since initialize above", "break", ";", "}", "if", "(", "isTraceOn", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "exit", "(", "tc", ",", "\"writeObject\"", ")", ";", "}" ]

[ "Write", "this", "object", "to", "the", "ObjectOutputStream", "." ]

[ "private", "void", "readObject", "(", "ObjectInputStream", "in", ")", "throws", "IOException", ",", "ClassNotFoundException", "{", "final", "boolean", "isTraceOn", "=", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", ";", "if", "(", "isTraceOn", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "entry", "(", "tc", ",", "\"readObject\"", ")", ";", "in", ".", "defaultReadObject", "(", ")", ";", "// Read in eye catcher.", "byte", "[", "]", "eyeCatcher", "=", "new", "byte", "[", "EYECATCHER", ".", "length", "]", ";", "// Insure that all of the bytes have been read.", "int", "bytesRead", "=", "0", ";", "for", "(", "int", "offset", "=", "0", ";", "offset", "<", "EYECATCHER", ".", "length", ";", "offset", "+=", "bytesRead", ")", "{", "bytesRead", "=", "in", ".", "read", "(", "eyeCatcher", ",", "offset", ",", "EYECATCHER", ".", "length", "-", "offset", ")", ";", "if", "(", "bytesRead", "==", "-", "1", ")", "{", "throw", "new", "IOException", "(", "\"end of input stream while reading eye catcher\"", ")", ";", "}", "}", "// Validate that the eyecatcher matches", "for", "(", "int", "i", "=", "0", ";", "i", "<", "EYECATCHER", ".", "length", ";", "i", "++", ")", "{", "if", "(", "EYECATCHER", "[", "i", "]", "!=", "eyeCatcher", "[", "i", "]", ")", "{", "String", "eyeCatcherString", "=", "new", "String", "(", "eyeCatcher", ")", ";", "throw", "new", "IOException", "(", "\"Invalid eye catcher '\"", "+", "eyeCatcherString", "+", "\"' in TimerHandle input stream\"", ")", ";", "}", "}", "// Read in the rest of the header.", "@", "SuppressWarnings", "(", "\"unused\"", ")", "short", "incoming_platform", "=", "in", ".", "readShort", "(", ")", ";", "short", "incoming_vid", "=", "in", ".", "readShort", "(", ")", ";", "if", "(", "isTraceOn", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "Tr", ".", "debug", "(", "tc", ",", "\"version = \"", "+", "incoming_vid", ")", ";", "// Verify the version is supported by this version of code.", "if", "(", "incoming_vid", "!=", "Constants", ".", "TIMER_TASK_V1", "&&", "incoming_vid", "!=", "Constants", ".", "TIMER_TASK_V2", ")", "{", "throw", "new", "InvalidObjectException", "(", "\"EJB TimerTaskHandler data stream is not of the correct version, this client should be updated.\"", ")", ";", "}", "// Read in the instance data.", "byte", "[", "]", "j2eeNameBytes", "=", "(", "byte", "[", "]", ")", "in", ".", "readObject", "(", ")", ";", "j2eeName", "=", "EJSContainer", ".", "j2eeNameFactory", ".", "create", "(", "j2eeNameBytes", ")", ";", "userInfoBytes", "=", "(", "byte", "[", "]", ")", "in", ".", "readObject", "(", ")", ";", "switch", "(", "incoming_vid", ")", "{", "case", "Constants", ".", "TIMER_TASK_V1", ":", "expiration", "=", "in", ".", "readLong", "(", ")", ";", "interval", "=", "in", ".", "readLong", "(", ")", ";", "break", ";", "case", "Constants", ".", "TIMER_TASK_V2", ":", "parsedSchedule", "=", "(", "ParsedScheduleExpression", ")", "in", ".", "readObject", "(", ")", ";", "methodId", "=", "in", ".", "readInt", "(", ")", ";", "automaticMethodName", "=", "(", "String", ")", "in", ".", "readObject", "(", ")", ";", "automaticClassName", "=", "(", "String", ")", "in", ".", "readObject", "(", ")", ";", "break", ";", "default", ":", "// cannot occur since unsupported version detected above", "break", ";", "}", "if", "(", "isTraceOn", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "exit", "(", "tc", ",", "\"readObject: \"", "+", "this", ")", ";", "}" ]

[ "Read", "this", "object", "from", "the", "ObjectInputStream", "." ]

[ "protected", "BeanMetaData", "getBeanMetaData", "(", ")", "{", "final", "boolean", "isTraceOn", "=", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", ";", "if", "(", "isTraceOn", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "entry", "(", "tc", ",", "\"getBeanMetaData: \"", "+", "this", ")", ";", "EJSHome", "home", ";", "try", "{", "// Get the currently installed and active home for this timer. It", "// is possible the home is not currently running, so an", "// EJBNotFoundException may occur.", "home", "=", "EJSContainer", ".", "getDefaultContainer", "(", ")", ".", "getInstalledHome", "(", "j2eeName", ")", ";", "// Verify that the bean is still a Timer bean, in case the", "// application has been modified since the timer was created.", "if", "(", "(", "home", ".", "beanMetaData", ".", "timedMethodInfos", ")", "==", "null", ")", "{", "Tr", ".", "warning", "(", "tc", ",", "\"HOME_NOT_FOUND_CNTR0092W\"", ",", "j2eeName", ")", ";", "throw", "new", "EJBNotFoundException", "(", "\"Incompatible Application Change: \"", "+", "j2eeName", "+", "\" no longer supports timers.\"", ")", ";", "}", "}", "catch", "(", "EJBNotFoundException", "ejbnfex", ")", "{", "FFDCFilter", ".", "processException", "(", "ejbnfex", ",", "CLASS_NAME", "+", "\".getBeanMetaData\"", ",", "\"635\"", ",", "this", ")", ";", "if", "(", "isTraceOn", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "exit", "(", "tc", ",", "\"getBeanMetaData: Failed locating timer bean \"", "+", "j2eeName", "+", "\" : \"", "+", "ejbnfex", ")", ";", "throw", "new", "TimerServiceException", "(", "\"Failed locating timer bean \"", "+", "j2eeName", ",", "ejbnfex", ")", ";", "}", "BeanMetaData", "bmd", "=", "home", ".", "beanMetaData", ";", "if", "(", "isTraceOn", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "Tr", ".", "exit", "(", "tc", ",", "\"getBeanMetaData: \"", "+", "bmd", ")", ";", "return", "bmd", ";", "}" ]

[ "Gets", "BeanMetaData", "through", "EJSHome", "lookup" ]

[ "private", "static", "byte", "[", "]", "serializeObject", "(", "Object", "obj", ")", "{", "if", "(", "obj", "==", "null", ")", "{", "return", "null", ";", "}", "ByteArrayOutputStream", "baos", "=", "new", "ByteArrayOutputStream", "(", ")", ";", "try", "{", "ObjectOutputStream", "out", "=", "new", "ObjectOutputStream", "(", "baos", ")", ";", "out", ".", "writeObject", "(", "obj", ")", ";", "out", ".", "flush", "(", ")", ";", "}", "catch", "(", "IOException", "ioex", ")", "{", "throw", "new", "EJBException", "(", "\"Timer info object failed to serialize.\"", ",", "ioex", ")", ";", "}", "return", "baos", ".", "toByteArray", "(", ")", ";", "}" ]

[ "Internal", "convenience", "method", "for", "serializing", "the", "user", "info", "object", "to", "a", "byte", "array", "." ]

[ "protected", "boolean", "maxRequestsServed", "(", ")", "{", "// PK12235, check for a partial or full stop", "if", "(", "getChannel", "(", ")", ".", "isStopping", "(", ")", ")", "{", "// channel has stopped, no more keep-alives", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"Channel stopped, disabling keep-alive request\"", ")", ";", "}", "return", "true", ";", "}", "if", "(", "!", "getChannel", "(", ")", ".", "getHttpConfig", "(", ")", ".", "isKeepAliveEnabled", "(", ")", ")", "{", "// keep alives are disabled, no need to check the max request number", "return", "true", ";", "}", "int", "max", "=", "getChannel", "(", ")", ".", "getHttpConfig", "(", ")", ".", "getMaximumPersistentRequests", "(", ")", ";", "// -1 is unlimited, 0..1 is 1 request, any above that is that exact", "// number of requests", "if", "(", "0", "<=", "max", ")", "{", "return", "(", "this", ".", "numRequestsProcessed", ">=", "max", ")", ";", "}", "return", "false", ";", "}" ]

[ "Find", "out", "whether", "we", "ve", "served", "the", "maximum", "number", "of", "requests", "allowed", "on", "this", "connection", "already", "." ]

[ "@", "Override", "public", "void", "ready", "(", "VirtualConnection", "inVC", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "{", "Tr", ".", "entry", "(", "tc", ",", "\"ready: \"", "+", "this", "+", "\" \"", "+", "inVC", ")", ";", "}", "this", ".", "myTSC", "=", "(", "TCPConnectionContext", ")", "getDeviceLink", "(", ")", ".", "getChannelAccessor", "(", ")", ";", "HttpInboundServiceContextImpl", "sc", "=", "getHTTPContext", "(", ")", ";", "sc", ".", "init", "(", "this", ".", "myTSC", ",", "this", ",", "inVC", ",", "getChannel", "(", ")", ".", "getHttpConfig", "(", ")", ")", ";", "if", "(", "getChannel", "(", ")", ".", "getHttpConfig", "(", ")", ".", "getDebugLog", "(", ")", ".", "isEnabled", "(", "DebugLog", ".", "Level", ".", "INFO", ")", ")", "{", "getChannel", "(", ")", ".", "getHttpConfig", "(", ")", ".", "getDebugLog", "(", ")", ".", "log", "(", "DebugLog", ".", "Level", ".", "INFO", ",", "HttpMessages", ".", "MSG_CONN_STARTING", ",", "sc", ")", ";", "}", "processRequest", "(", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "{", "Tr", ".", "exit", "(", "tc", ",", "\"ready\"", ")", ";", "}", "}" ]

[ "Called", "by", "the", "device", "side", "channel", "when", "a", "new", "request", "is", "ready", "for", "work", "." ]

[ "protected", "void", "processRequest", "(", ")", "{", "final", "int", "timeout", "=", "getHTTPContext", "(", ")", ".", "getReadTimeout", "(", ")", ";", "final", "TCPReadCompletedCallback", "callback", "=", "HttpICLReadCallback", ".", "getRef", "(", ")", ";", "// keep looping on processing information until we fully parse the message", "// and hand it off, or until the reads for more data go async", "VirtualConnection", "rc", "=", "null", ";", "do", "{", "if", "(", "handleNewInformation", "(", ")", ")", "{", "// new information triggered an error message, so we're done", "return", ";", "}", "// Note: handleNewInformation will allocate the read buffers", "if", "(", "!", "isPartiallyParsed", "(", ")", ")", "{", "// we're done parsing at this point. Note: cannot take any action", "// with information after this call because it may go all the way", "// from the channel above us back to the persist read, must exit", "// this callstack immediately", "handleNewRequest", "(", ")", ";", "return", ";", "}", "rc", "=", "this", ".", "myTSC", ".", "getReadInterface", "(", ")", ".", "read", "(", "1", ",", "callback", ",", "false", ",", "timeout", ")", ";", "}", "while", "(", "null", "!=", "rc", ")", ";", "}" ]

[ "Process", "new", "information", "for", "an", "inbound", "request", "that", "needs", "to", "be", "parsed", "and", "handled", "by", "channels", "above", "." ]

[ "private", "boolean", "handleNewInformation", "(", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"Parsing new information: \"", "+", "getVirtualConnection", "(", ")", ")", ";", "}", "final", "HttpInboundServiceContextImpl", "sc", "=", "getHTTPContext", "(", ")", ";", "if", "(", "!", "isPartiallyParsed", "(", ")", ")", "{", "// this is the first pass through on parsing this new request", "// PK12235, check for a full stop only", "if", "(", "getChannel", "(", ")", ".", "isStopped", "(", ")", ")", "{", "// channel stopped during the initial read, send error back", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"Channel stopped during initial read\"", ")", ";", "}", "sc", ".", "setHeadersParsed", "(", ")", ";", "// since we haven't parsed the request version, force the", "// response to the minimal 1.0 version", "sc", ".", "getResponse", "(", ")", ".", "setVersion", "(", "VersionValues", ".", "V10", ")", ";", "sendErrorMessage", "(", "StatusCodes", ".", "UNAVAILABLE", ")", ";", "return", "true", ";", "}", "}", "boolean", "completed", "=", "false", ";", "// if this is an http/2 link, don't perform additional parsing", "if", "(", "this", ".", "isAlpnHttp2Link", "(", "switchedVC", ")", ")", "{", "return", "false", ";", "}", "try", "{", "completed", "=", "sc", ".", "parseMessage", "(", ")", ";", "}", "catch", "(", "UnsupportedMethodException", "meth", ")", "{", "// no FFDC required", "sc", ".", "setHeadersParsed", "(", ")", ";", "sendErrorMessage", "(", "StatusCodes", ".", "NOT_IMPLEMENTED", ")", ";", "setPartiallyParsed", "(", "false", ")", ";", "return", "true", ";", "}", "catch", "(", "UnsupportedProtocolVersionException", "ver", ")", "{", "// no FFDC required", "sc", ".", "setHeadersParsed", "(", ")", ";", "sendErrorMessage", "(", "StatusCodes", ".", "UNSUPPORTED_VERSION", ")", ";", "setPartiallyParsed", "(", "false", ")", ";", "return", "true", ";", "}", "catch", "(", "MessageTooLargeException", "mtle", ")", "{", "// no FFDC required", "sc", ".", "setHeadersParsed", "(", ")", ";", "sendErrorMessage", "(", "StatusCodes", ".", "ENTITY_TOO_LARGE", ")", ";", "setPartiallyParsed", "(", "false", ")", ";", "return", "true", ";", "}", "catch", "(", "MalformedMessageException", "mme", ")", "{", "//no FFDC required", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"parseMessage encountered a MalformedMessageException : \"", "+", "mme", ")", ";", "}", "handleGenericHNIError", "(", "mme", ",", "sc", ")", ";", "return", "true", ";", "}", "catch", "(", "IllegalArgumentException", "iae", ")", "{", "//no FFDC required", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"parseMessage encountered an IllegalArgumentException : \"", "+", "iae", ")", ";", "}", "handleGenericHNIError", "(", "iae", ",", "sc", ")", ";", "return", "true", ";", "}", "catch", "(", "CompressionException", "ce", ")", "{", "//no FFDC required", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"parseMessage encountered a CompressionException : \"", "+", "ce", ")", ";", "}", "handleGenericHNIError", "(", "ce", ",", "sc", ")", ";", "return", "true", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "FFDCFilter", ".", "processException", "(", "t", ",", "\"HttpInboundLink.handleNewInformation\"", ",", "\"2\"", ",", "this", ")", ";", "handleGenericHNIError", "(", "t", ",", "sc", ")", ";", "return", "true", ";", "}", "// partialParsed is the opposite of the complete flag", "setPartiallyParsed", "(", "!", "completed", ")", ";", "if", "(", "isPartiallyParsed", "(", ")", ")", "{", "sc", ".", "setupReadBuffers", "(", "sc", ".", "getHttpConfig", "(", ")", ".", "getIncomingHdrBufferSize", "(", ")", ",", "false", ")", ";", "}", "return", "false", ";", "}" ]

[ "Handle", "parsing", "the", "incoming", "request", "message", "." ]

[ "private", "void", "handleGenericHNIError", "(", "Throwable", "t", ",", "HttpInboundServiceContextImpl", "hisc", ")", "{", "hisc", ".", "setHeadersParsed", "(", ")", ";", "sendErrorMessage", "(", "t", ")", ";", "setPartiallyParsed", "(", "false", ")", ";", "}" ]

[ "the", "same", "thing", "so", "now", "they", "will", "just", "call", "this", "one", "method" ]

[ "private", "void", "handleNewRequest", "(", ")", "{", "// if this is an http/2 request, skip to discrimination", "if", "(", "!", "isAlpnHttp2Link", "(", "this", ".", "vc", ")", ")", "{", "final", "HttpInboundServiceContextImpl", "sc", "=", "getHTTPContext", "(", ")", ";", "// save the request info that was parsed in case somebody changes it", "sc", ".", "setRequestVersion", "(", "sc", ".", "getRequest", "(", ")", ".", "getVersionValue", "(", ")", ")", ";", "sc", ".", "setRequestMethod", "(", "sc", ".", "getRequest", "(", ")", ".", "getMethodValue", "(", ")", ")", ";", "// get the response message initialized. Note: in the proxy env, this", "// response message will be overwritten; however, this is the only", "// spot to init() it correctly for all other cases.", "sc", ".", "getResponseImpl", "(", ")", ".", "init", "(", "sc", ")", ";", "this", ".", "numRequestsProcessed", "++", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"Received request number \"", "+", "this", ".", "numRequestsProcessed", "+", "\" on link \"", "+", "this", ")", ";", "}", "// check for the 100-continue scenario", "if", "(", "!", "sc", ".", "check100Continue", "(", ")", ")", "{", "return", ";", "}", "}", "handleDiscrimination", "(", ")", ";", "}" ]

[ "Process", "a", "new", "request", "message", "updating", "internal", "stats", "and", "calling", "the", "discrimination", "to", "pass", "it", "along", "the", "channel", "chain", "." ]

[ "private", "void", "sendErrorMessage", "(", "Throwable", "t", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"Sending a 400 for throwable [\"", "+", "t", "+", "\"]\"", ")", ";", "}", "sendErrorMessage", "(", "StatusCodes", ".", "BAD_REQUEST", ")", ";", "}" ]

[ "Send", "an", "error", "message", "when", "a", "generic", "throwable", "occurs", "." ]

[ "private", "void", "sendErrorMessage", "(", "StatusCodes", "code", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"Sending an error page back [code: \"", "+", "code", "+", "\"]\"", ")", ";", "}", "try", "{", "getHTTPContext", "(", ")", ".", "sendError", "(", "code", ".", "getHttpError", "(", ")", ")", ";", "}", "catch", "(", "MessageSentException", "mse", ")", "{", "// no FFDC required", "close", "(", "getVirtualConnection", "(", ")", ",", "new", "Exception", "(", "\"HTTP Message failure\"", ")", ")", ";", "}", "}" ]

[ "Send", "an", "error", "message", "back", "to", "the", "client", "with", "a", "defined", "status", "code", "instead", "of", "an", "exception", "." ]

[ "private", "void", "handlePipeLining", "(", ")", "{", "HttpServiceContextImpl", "sc", "=", "getHTTPContext", "(", ")", ";", "WsByteBuffer", "buffer", "=", "sc", ".", "returnLastBuffer", "(", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEventEnabled", "(", ")", ")", "{", "Tr", ".", "event", "(", "tc", ",", "\"Pipelined request found: \"", "+", "buffer", ")", ";", "}", "sc", ".", "clear", "(", ")", ";", "// save it back so that we always release it", "sc", ".", "storeAllocatedBuffer", "(", "buffer", ")", ";", "sc", ".", "disableBufferModification", "(", ")", ";", "EventEngine", "events", "=", "HttpDispatcher", ".", "getEventService", "(", ")", ";", "if", "(", "null", "!=", "events", ")", "{", "Event", "event", "=", "events", ".", "createEvent", "(", "HttpPipelineEventHandler", ".", "TOPIC_PIPELINING", ")", ";", "event", ".", "setProperty", "(", "CallbackIDs", ".", "CALLBACK_HTTPICL", ".", "getName", "(", ")", ",", "this", ")", ";", "events", ".", "postEvent", "(", "event", ")", ";", "}", "else", "{", "// unable to dispatch work request, continue on this thread", "ready", "(", "getVirtualConnection", "(", ")", ")", ";", "}", "}" ]

[ "Handle", "a", "pipelined", "request", "discovered", "while", "closing", "the", "handling", "of", "the", "last", "request", "." ]

[ "@", "Override", "public", "void", "error", "(", "VirtualConnection", "inVC", ",", "Throwable", "t", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"error() called on \"", "+", "this", "+", "\" \"", "+", "inVC", ")", ";", "}", "try", "{", "close", "(", "inVC", ",", "(", "Exception", ")", "t", ")", ";", "}", "catch", "(", "ClassCastException", "cce", ")", "{", "// no FFDC required", "close", "(", "inVC", ",", "new", "Exception", "(", "\"Problem when finishing response\"", ")", ")", ";", "}", "}" ]

[ "Called", "when", "an", "error", "occurs", "on", "this", "connection", "." ]