Datasets:

CM

/

codexglue_code2text_java

like 4

[ "protected", "MethodDescriptor", "[", "]", "addMissingContextMethodDescriptors", "(", "Method", "[", "]", "methods", ",", "MethodDescriptor", "[", "]", "methodDescriptors", ")", "{", "List", "<", "Method", ">", "methodNames", "=", "new", "ArrayList", "<", "Method", ">", "(", "methodDescriptors", ".", "length", ")", ";", "Vector", "<", "MethodDescriptor", ">", "mds", "=", "new", "Vector", "<", "MethodDescriptor", ">", "(", "methods", ".", "length", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "methodDescriptors", ".", "length", ";", "i", "++", ")", "{", "methodNames", ".", "add", "(", "methodDescriptors", "[", "i", "]", ".", "getMethod", "(", ")", ")", ";", "mds", ".", "add", "(", "methodDescriptors", "[", "i", "]", ")", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "methods", ".", "length", ";", "i", "++", ")", "{", "if", "(", "!", "methodNames", ".", "contains", "(", "methods", "[", "i", "]", ")", ")", "{", "mds", ".", "add", "(", "new", "MethodDescriptor", "(", "methods", "[", "i", "]", ")", ")", ";", "}", "}", "methodDescriptors", "=", "new", "MethodDescriptor", "[", "mds", ".", "size", "(", ")", "]", ";", "mds", ".", "copyInto", "(", "methodDescriptors", ")", ";", "return", "methodDescriptors", ";", "}" ]

[ "Works", "around", "a", "bug", "in", "java", ".", "beans", ".", "Introspector", "where", "sub", "-", "interfaces", "do", "not", "return", "their", "parent", "s", "methods", "in", "the", "method", "descriptor", "array", "." ]

[ "public", "TypeDescription", "getType", "(", ")", "{", "if", "(", "mType", "==", "null", ")", "{", "mType", "=", "getTeaToolsUtils", "(", ")", ".", "createTypeDescription", "(", "getPropertyDescriptor", "(", ")", ".", "getPropertyType", "(", ")", ")", ";", "}", "return", "mType", ";", "}" ]

[ "Returns", "the", "property", "s", "type" ]

[ "public", "boolean", "isDeprecated", "(", ")", "{", "Method", "method", "=", "getPropertyDescriptor", "(", ")", ".", "getReadMethod", "(", ")", ";", "return", "(", "method", "==", "null", "?", "false", ":", "getTeaToolsUtils", "(", ")", ".", "isDeprecated", "(", "method", ")", ")", ";", "}" ]

[ "Returns", "whether", "the", "given", "property", "is", "deprecated", "based", "on", "whether", "any", "of", "its", "read", "methods", "are", "deprecated", "." ]

[ "public", "static", "ClassInjector", "getInstance", "(", "ClassLoader", "loader", ")", "{", "ClassInjector", "injector", "=", "null", ";", "synchronized", "(", "cShared", ")", "{", "Reference", "ref", "=", "(", "Reference", ")", "cShared", ".", "get", "(", "loader", ")", ";", "if", "(", "ref", "!=", "null", ")", "{", "injector", "=", "(", "ClassInjector", ")", "ref", ".", "get", "(", ")", ";", "}", "if", "(", "injector", "==", "null", ")", "{", "injector", "=", "new", "ClassInjector", "(", "loader", ")", ";", "cShared", ".", "put", "(", "loader", ",", "new", "WeakReference", "(", "injector", ")", ")", ";", "}", "return", "injector", ";", "}", "}" ]

[ "Returns", "a", "shared", "ClassInjector", "instance", "for", "the", "given", "ClassLoader", "." ]

[ "private", "static", "long", "getScaledValue", "(", "FileBuffer", "buffer", ",", "int", "scale", ",", "long", "position", ")", "throws", "IOException", "{", "return", "getScaledValue", "(", "new", "byte", "[", "8", "]", ",", "buffer", ",", "scale", ",", "position", ")", ";", "}" ]

[ "temporary", "byte", "array", "." ]

[ "private", "static", "void", "putScaledValue", "(", "FileBuffer", "buffer", ",", "int", "scale", ",", "long", "position", ",", "long", "value", ")", "throws", "IOException", "{", "putScaledValue", "(", "new", "byte", "[", "8", "]", ",", "buffer", ",", "scale", ",", "position", ",", "value", ")", ";", "}" ]

[ "temorary", "byte", "array", "." ]

[ "public", "void", "deleteFile", "(", "long", "id", ")", "throws", "IOException", "{", "if", "(", "id", ">=", "getFileCount", "(", ")", ")", "{", "return", ";", "}", "Long", "key", "=", "new", "Long", "(", "id", ")", ";", "InternalFile", "file", "=", "openInternal", "(", "key", ")", ";", "// Acquire write lock on file to delete before acquiring lock on", "// file table. This ensures a consistent lock order with all other", "// operations and prevents deadlock. Operations on internal files", "// will first lock the internal file, and then lock the shared file", "// table when necessary.", "try", "{", "file", ".", "lock", "(", ")", ".", "acquireWriteLock", "(", ")", ";", "// Use the file table lock to prevent multiple threads from using", "// mOpenFiles.", "try", "{", "mFileTableLock", ".", "acquireWriteLock", "(", ")", ";", "file", ".", "delete", "(", ")", ";", "mOpenFiles", ".", "remove", "(", "key", ")", ";", "}", "finally", "{", "mFileTableLock", ".", "releaseLock", "(", ")", ";", "}", "}", "catch", "(", "InterruptedException", "e", ")", "{", "throw", "new", "InterruptedIOException", "(", ")", ";", "}", "finally", "{", "file", ".", "lock", "(", ")", ".", "releaseLock", "(", ")", ";", "}", "}" ]

[ "Deletes", "the", "specified", "file", ".", "Opening", "it", "up", "again", "re", "-", "creates", "it", "." ]

[ "public", "void", "truncateFileCount", "(", "long", "count", ")", "throws", "IOException", "{", "if", "(", "count", "<", "0", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"count < 0: \"", "+", "count", ")", ";", "}", "try", "{", "mFileTableLock", ".", "acquireUpgradableLock", "(", ")", ";", "long", "oldCount", "=", "getFileCount", "(", ")", ";", "if", "(", "count", ">=", "oldCount", ")", "{", "return", ";", "}", "mFileTableLock", ".", "acquireWriteLock", "(", ")", ";", "try", "{", "for", "(", "long", "id", "=", "oldCount", ";", "--", "id", ">=", "count", ";", ")", "{", "deleteFile", "(", "id", ")", ";", "}", "mFileTable", ".", "truncate", "(", "count", "*", "mFileTableEntrySize", ")", ";", "}", "finally", "{", "mFileTableLock", ".", "releaseLock", "(", ")", ";", "}", "}", "catch", "(", "InterruptedException", "e", ")", "{", "throw", "new", "InterruptedIOException", "(", ")", ";", "}", "finally", "{", "mFileTableLock", ".", "releaseLock", "(", ")", ";", "}", "}" ]

[ "Truncating", "the", "file", "count", "deletes", "any", "files", "with", "ids", "at", "or", "above", "the", "new", "count", "." ]

[ "final", "int", "calcLevels", "(", "long", "length", ")", "{", "// The calculation is essentially a math log operation, but the table", "// lookup is faster.", "int", "index", "=", "Arrays", ".", "binarySearch", "(", "mLevelMaxSizes", ",", "length", ")", ";", "return", "(", "index", "<", "0", ")", "?", "~", "index", ":", "index", ";", "}" ]

[ "Calculates", "the", "level", "of", "indirection", "needed", "to", "access", "a", "block", "in", "a", "file", "of", "the", "given", "length", ".", "If", "the", "level", "is", "zero", "the", "file", "table", "points", "directly", "to", "a", "data", "block", ".", "If", "the", "level", "is", "one", "the", "file", "table", "points", "to", "file", "table", "block", ".", "A", "file", "table", "block", "contains", "block", "ids", "which", "map", "to", "data", "blocks", "or", "more", "file", "table", "blocks", "." ]

[ "final", "void", "freeBlock", "(", "long", "blockId", ")", "throws", "IOException", "{", "if", "(", "blockId", "==", "0", ")", "{", "// Can't free block 0.", "}", "else", "{", "try", "{", "mFreeBlocksBitlist", ".", "lock", "(", ")", ".", "acquireWriteLock", "(", ")", ";", "mFreeBlocksBitlist", ".", "set", "(", "blockId", ")", ";", "if", "(", "mFirstFreeBlock", "==", "0", "||", "blockId", "<", "mFirstFreeBlock", ")", "{", "setFirstFreeBlock", "(", "blockId", ")", ";", "}", "}", "catch", "(", "InterruptedException", "e", ")", "{", "throw", "new", "InterruptedIOException", "(", ")", ";", "}", "finally", "{", "mFreeBlocksBitlist", ".", "lock", "(", ")", ".", "releaseLock", "(", ")", ";", "}", "}", "}" ]

[ "Attempting", "to", "free", "block", "0", "or", "a", "block", "that", "is", "already", "free", "has", "no", "effect", "." ]

[ "final", "long", "getBlockId", "(", "long", "refBlockId", ",", "int", "index", ")", "throws", "IOException", "{", "if", "(", "refBlockId", "==", "0", ")", "{", "return", "0", ";", "}", "return", "getBlockId", "(", "mBackingFile", ",", "refBlockId", "*", "mBlockSize", "+", "index", ")", ";", "}" ]

[ "Returns", "0", "if", "referring", "block", "is", "0", "." ]

[ "public", "void", "doGet", "(", "HttpServletRequest", "req", ",", "HttpServletResponse", "res", ")", "{", "getTemplateData", "(", "req", ",", "res", ",", "req", ".", "getPathInfo", "(", ")", ")", ";", "}" ]

[ "Retrieves", "all", "the", "templates", "that", "are", "newer", "that", "the", "timestamp", "specified", "by", "the", "client", ".", "The", "pathInfo", "from", "the", "request", "specifies", "which", "templates", "are", "desired", ".", "QueryString", "parameters", "timeStamp", "and", "???", "provide" ]

[ "public", "final", "synchronized", "Template", "getTemplate", "(", "String", "name", ")", "throws", "ClassNotFoundException", ",", "NoSuchMethodException", ",", "LinkageError", "{", "Template", "template", "=", "mTemplates", ".", "get", "(", "name", ")", ";", "if", "(", "template", "==", "null", ")", "{", "template", "=", "loadTemplate", "(", "name", ")", ";", "mTemplates", ".", "put", "(", "name", ",", "template", ")", ";", "}", "return", "template", ";", "}" ]

[ "Get", "or", "load", "a", "template", "by", "its", "full", "name", ".", "The", "full", "name", "of", "a", "template", "has", ".", "characters", "to", "separate", "name", "parts", "and", "it", "does", "not", "include", "a", "Java", "package", "prefix", "." ]

[ "private", "Class", "<", "?", ">", "getTemplateClass", "(", ")", "{", "String", "fqName", "=", "getTargetPackage", "(", ")", "+", "\".\"", "+", "getName", "(", ")", ";", "try", "{", "mTemplateClass", "=", "getCompiler", "(", ")", ".", "loadClass", "(", "fqName", ")", ";", "}", "catch", "(", "ClassNotFoundException", "nx", ")", "{", "try", "{", "mTemplateClass", "=", "getCompiler", "(", ")", ".", "loadClass", "(", "getName", "(", ")", ")", ";", "// Try standard path as a last resort", "}", "catch", "(", "ClassNotFoundException", "nx2", ")", "{", "return", "null", ";", "}", "}", "return", "mTemplateClass", ";", "}" ]

[ "Load", "the", "template", "." ]

[ "public", "static", "boolean", "exists", "(", "Compiler", "c", ",", "String", "name", ",", "CompilationUnit", "from", ")", "{", "String", "fqName", "=", "getFullyQualifiedName", "(", "resolveName", "(", "name", ",", "from", ")", ")", ";", "try", "{", "c", ".", "loadClass", "(", "fqName", ")", ";", "return", "true", ";", "}", "catch", "(", "ClassNotFoundException", "nx", ")", "{", "try", "{", "c", ".", "loadClass", "(", "resolveName", "(", "name", ",", "from", ")", ")", ";", "// Try standard path as a last resort", "return", "true", ";", "}", "catch", "(", "ClassNotFoundException", "nx2", ")", "{", "return", "false", ";", "}", "}", "}" ]

[ "Test", "to", "see", "of", "the", "template", "can", "be", "loaded", "before", "CompiledTemplate", "can", "be", "constructed", "." ]

[ "public", "Template", "getParseTree", "(", ")", "{", "getTemplateClass", "(", ")", ";", "if", "(", "findExecuteMethod", "(", ")", "==", "null", ")", "throw", "new", "IllegalArgumentException", "(", "\"Cannot locate compiled template entry point.\"", ")", ";", "reflectParameters", "(", ")", ";", "mTree", "=", "new", "Template", "(", "mCallerInfo", ",", "new", "Name", "(", "mCallerInfo", ",", "getName", "(", ")", ")", ",", "mParameters", ",", "mSubParam", ",", "null", ",", "null", ")", ";", "mTree", ".", "setReturnType", "(", "new", "Type", "(", "mExecuteMethod", ".", "getReturnType", "(", ")", ",", "mExecuteMethod", ".", "getGenericReturnType", "(", ")", ")", ")", ";", "return", "mTree", ";", "}" ]

[ "This", "method", "is", "called", "by", "JavaClassGenerator", "during", "the", "compile", "phase", ".", "It", "overrides", "the", "method", "in", "CompilationUnit", "and", "returns", "just", "the", "reflected", "template", "signature", "." ]

[ "public", "String", "getTargetPackage", "(", ")", "{", "return", "mCaller", "!=", "null", "&&", "mCaller", ".", "getTargetPackage", "(", ")", "!=", "null", "?", "mCaller", ".", "getTargetPackage", "(", ")", ":", "TEMPLATE_PACKAGE", ";", "}" ]

[ "Return", "the", "package", "name", "that", "this", "CompilationUnit", "should", "be", "compiled", "into", "." ]

[ "public", "synchronized", "boolean", "enqueue", "(", "Transaction", "transaction", ")", "{", "mTotalEnqueueAttempts", "++", ";", "if", "(", "transaction", "==", "null", "||", "mThreadPool", ".", "isClosed", "(", ")", ")", "{", "return", "false", ";", "}", "int", "queueSize", ";", "if", "(", "(", "queueSize", "=", "mQueue", ".", "size", "(", ")", ")", ">=", "mMaxSize", ")", "{", "if", "(", "mListeners", ".", "size", "(", ")", ">", "0", ")", "{", "TransactionQueueEvent", "event", "=", "new", "TransactionQueueEvent", "(", "this", ",", "transaction", ")", ";", "Iterator", "it", "=", "mListeners", ".", "iterator", "(", ")", ";", "while", "(", "it", ".", "hasNext", "(", ")", ")", "{", "(", "(", "TransactionQueueListener", ")", "it", ".", "next", "(", ")", ")", ".", "transactionQueueFull", "(", "event", ")", ";", "}", "}", "return", "false", ";", "}", "if", "(", "!", "mSuspended", ")", "{", "if", "(", "!", "ensureWaitingThread", "(", ")", ")", "{", "return", "false", ";", "}", "}", "mTotalEnqueued", "++", ";", "TransactionQueueEvent", "event", "=", "new", "TransactionQueueEvent", "(", "this", ",", "transaction", ")", ";", "mQueue", ".", "addLast", "(", "event", ")", ";", "if", "(", "++", "queueSize", ">", "mPeakQueueSize", ")", "{", "mPeakQueueSize", "=", "queueSize", ";", "}", "notify", "(", ")", ";", "if", "(", "mListeners", ".", "size", "(", ")", ">", "0", ")", "{", "Iterator", "it", "=", "mListeners", ".", "iterator", "(", ")", ";", "while", "(", "it", ".", "hasNext", "(", ")", ")", "{", "(", "(", "TransactionQueueListener", ")", "it", ".", "next", "(", ")", ")", ".", "transactionEnqueued", "(", "event", ")", ";", "}", "}", "return", "true", ";", "}" ]

[ "Enqueues", "a", "transaction", "that", "will", "be", "serviced", "when", "a", "worker", "is", "available", ".", "If", "the", "queue", "is", "full", "or", "cannot", "accept", "new", "transactions", "the", "transaction", "is", "not", "enqueued", "and", "false", "is", "returned", "." ]

[ "public", "synchronized", "TransactionQueueData", "getStatistics", "(", ")", "{", "return", "new", "TransactionQueueData", "(", "this", ",", "mTimeLapseStart", ",", "System", ".", "currentTimeMillis", "(", ")", ",", "mQueue", ".", "size", "(", ")", ",", "mThreadCount", ",", "mServicingCount", ",", "mPeakQueueSize", ",", "mPeakThreadCount", ",", "mPeakServicingCount", ",", "mTotalEnqueueAttempts", ",", "mTotalEnqueued", ",", "mTotalServiced", ",", "mTotalExpired", ",", "mTotalServiceExceptions", ",", "mTotalUncaughtExceptions", ",", "mTotalQueueDuration", ",", "mTotalServiceDuration", ")", ";", "}" ]

[ "Returns", "a", "snapshot", "of", "the", "statistics", "on", "this", "TransactionQueue", "." ]

[ "public", "synchronized", "void", "resetStatistics", "(", ")", "{", "mPeakQueueSize", "=", "0", ";", "mPeakThreadCount", "=", "0", ";", "mPeakServicingCount", "=", "0", ";", "mTotalEnqueueAttempts", "=", "0", ";", "mTotalEnqueued", "=", "0", ";", "mTotalServiced", "=", "0", ";", "mTotalExpired", "=", "0", ";", "mTotalServiceExceptions", "=", "0", ";", "mTotalUncaughtExceptions", "=", "0", ";", "mTotalQueueDuration", "=", "0", ";", "mTotalServiceDuration", "=", "0", ";", "mTimeLapseStart", "=", "System", ".", "currentTimeMillis", "(", ")", ";", "}" ]

[ "Resets", "all", "time", "lapse", "statistics", "." ]

[ "public", "synchronized", "void", "applyProperties", "(", "PropertyMap", "properties", ")", "{", "if", "(", "properties", ".", "containsKey", "(", "\"max.size\"", ")", ")", "{", "setMaximumSize", "(", "properties", ".", "getInt", "(", "\"max.size\"", ")", ")", ";", "}", "if", "(", "properties", ".", "containsKey", "(", "\"max.threads\"", ")", ")", "{", "setMaximumThreads", "(", "properties", ".", "getInt", "(", "\"max.threads\"", ")", ")", ";", "}", "if", "(", "properties", ".", "containsKey", "(", "\"timeout.idle\"", ")", ")", "{", "setIdleTimeout", "(", "properties", ".", "getNumber", "(", "\"timeout.idle\"", ")", ".", "longValue", "(", ")", ")", ";", "}", "if", "(", "properties", ".", "containsKey", "(", "\"timeout.transaction\"", ")", ")", "{", "setTransactionTimeout", "(", "properties", ".", "getNumber", "(", "\"timeout.transaction\"", ")", ".", "longValue", "(", ")", ")", ";", "}", "if", "(", "\"true\"", ".", "equalsIgnoreCase", "(", "properties", ".", "getString", "(", "\"tune.size\"", ")", ")", ")", "{", "addTransactionQueueListener", "(", "new", "TransactionQueueSizeTuner", "(", ")", ")", ";", "}", "if", "(", "\"true\"", ".", "equalsIgnoreCase", "(", "properties", ".", "getString", "(", "\"tune.threads\"", ")", ")", ")", "{", "addTransactionQueueListener", "(", "new", "TransactionQueueThreadTuner", "(", ")", ")", ";", "}", "}" ]

[ "Understands", "and", "applies", "the", "following", "integer", "properties", "." ]

[ "synchronized", "TransactionQueueEvent", "nextTransactionEvent", "(", ")", "throws", "InterruptedException", "{", "if", "(", "mQueue", ".", "isEmpty", "(", ")", ")", "{", "if", "(", "mIdleTimeout", "!=", "0", ")", "{", "if", "(", "mIdleTimeout", "<", "0", ")", "{", "wait", "(", ")", ";", "}", "else", "{", "wait", "(", "mIdleTimeout", ")", ";", "}", "}", "}", "if", "(", "mQueue", ".", "isEmpty", "(", ")", ")", "{", "return", "null", ";", "}", "return", "(", "TransactionQueueEvent", ")", "mQueue", ".", "removeFirst", "(", ")", ";", "}" ]

[ "Returns", "null", "when", "the", "TransactionQueue", "should", "go", "idle", "." ]

[ "public", "int", "compareTo", "(", "NameValuePair", "<", "T", ">", "other", ")", "{", "String", "otherName", "=", "other", ".", "mName", ";", "if", "(", "mName", "==", "null", ")", "{", "return", "otherName", "==", "null", "?", "0", ":", "1", ";", "}", "if", "(", "otherName", "==", "null", ")", "{", "return", "-", "1", ";", "}", "return", "mName", ".", "compareToIgnoreCase", "(", "otherName", ")", ";", "}" ]

[ "Comparison", "is", "based", "on", "case", "-", "insensitive", "ordering", "of", "name", "." ]

[ "public", "String", "getDetailedMessage", "(", ")", "{", "String", "prepend", "=", "getSourceInfoMessage", "(", ")", ";", "if", "(", "prepend", "==", "null", "||", "prepend", ".", "length", "(", ")", "==", "0", ")", "{", "return", "mMessage", ";", "}", "else", "{", "return", "prepend", "+", "\": \"", "+", "mMessage", ";", "}", "}" ]

[ "Returns", "the", "detailed", "message", "by", "prepending", "the", "standard", "message", "with", "source", "file", "information", "." ]

[ "public", "String", "getSourceInfoMessage", "(", ")", "{", "String", "msg", ";", "if", "(", "mUnit", "==", "null", ")", "{", "if", "(", "mInfo", "==", "null", ")", "{", "msg", "=", "\"\"", ";", "}", "else", "{", "msg", "=", "String", ".", "valueOf", "(", "mInfo", ".", "getLine", "(", ")", ")", ";", "}", "}", "else", "{", "if", "(", "mInfo", "==", "null", ")", "{", "msg", "=", "mUnit", ".", "getName", "(", ")", ";", "}", "else", "{", "msg", "=", "mUnit", ".", "getName", "(", ")", "+", "'", "'", "+", "mInfo", ".", "getLine", "(", ")", ";", "}", "}", "return", "msg", ";", "}" ]

[ "Get", "the", "source", "file", "information", "associated", "with", "this", "event", ".", "The", "source", "file", "information", "includes", "the", "name", "of", "the", "associated", "template", "and", "potential", "line", "number", "." ]

[ "public", "static", "InetAddressResolver", "listenFor", "(", "String", "host", ",", "InetAddressListener", "listener", ")", "{", "synchronized", "(", "cResolvers", ")", "{", "InetAddressResolver", "resolver", "=", "(", "InetAddressResolver", ")", "cResolvers", ".", "get", "(", "host", ")", ";", "if", "(", "resolver", "==", "null", ")", "{", "resolver", "=", "new", "InetAddressResolver", "(", "host", ")", ";", "cResolvers", ".", "put", "(", "host", ",", "resolver", ")", ";", "}", "resolver", ".", "addListener", "(", "listener", ")", ";", "return", "resolver", ";", "}", "}" ]

[ "Resolve", "the", "host", "name", "into", "InetAddresses", "and", "listen", "for", "changes", ".", "The", "caller", "must", "save", "a", "reference", "to", "the", "resolver", "to", "prevent", "it", "from", "being", "reclaimed", "by", "the", "garbage", "collector", "." ]

[ "private", "synchronized", "boolean", "resolveAddresses", "(", ")", "{", "boolean", "changed", ";", "try", "{", "InetAddress", "[", "]", "addresses", "=", "InetAddress", ".", "getAllByName", "(", "mHost", ")", ";", "if", "(", "mResolutionResults", "instanceof", "UnknownHostException", ")", "{", "changed", "=", "true", ";", "}", "else", "{", "// Results may be ordered differently, so keep them sorted.", "Arrays", ".", "sort", "(", "addresses", ",", "new", "Comparator", "(", ")", "{", "public", "int", "compare", "(", "Object", "a", ",", "Object", "b", ")", "{", "return", "(", "(", "InetAddress", ")", "a", ")", ".", "getHostAddress", "(", ")", ".", "compareTo", "(", "(", "(", "InetAddress", ")", "b", ")", ".", "getHostAddress", "(", ")", ")", ";", "}", "}", ")", ";", "changed", "=", "!", "Arrays", ".", "equals", "(", "addresses", ",", "(", "InetAddress", "[", "]", ")", "mResolutionResults", ")", ";", "}", "mResolutionResults", "=", "addresses", ";", "}", "catch", "(", "UnknownHostException", "e", ")", "{", "changed", "=", "!", "(", "mResolutionResults", "instanceof", "UnknownHostException", ")", ";", "mResolutionResults", "=", "e", ";", "}", "if", "(", "changed", ")", "{", "int", "size", "=", "mListeners", ".", "size", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "size", ";", "i", "++", ")", "{", "notifyListener", "(", "(", "InetAddressListener", ")", "mListeners", ".", "get", "(", "i", ")", ")", ";", "}", "}", "return", "changed", ";", "}" ]

[ "Returns", "true", "if", "anything", "changed", "from", "the", "last", "time", "this", "was", "invoked", "." ]

[ "private", "static", "final", "String", "trimFirstWord", "(", "String", "s", ")", "{", "s", "=", "s", ".", "trim", "(", ")", ";", "char", "[", "]", "chars", "=", "s", ".", "toCharArray", "(", ")", ";", "int", "firstSpace", "=", "-", "1", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "chars", ".", "length", ";", "i", "++", ")", "{", "char", "c", "=", "chars", "[", "i", "]", ";", "if", "(", "Character", ".", "isWhitespace", "(", "c", ")", ")", "{", "firstSpace", "=", "i", ";", "break", ";", "}", "}", "if", "(", "firstSpace", "==", "-", "1", ")", "{", "return", "s", ";", "}", "s", "=", "s", ".", "substring", "(", "firstSpace", ")", ".", "trim", "(", ")", ";", "s", "=", "capitalize", "(", "s", ")", ";", "return", "s", ";", "}" ]

[ "Trims", "off", "the", "first", "word", "of", "the", "specified", "string", "and", "capitalizes", "the", "new", "first", "word" ]

[ "public", "String", "getTagValue", "(", "String", "tagName", ")", "{", "String", "value", "=", "null", ";", "if", "(", "mReadMethod", "!=", "null", ")", "{", "value", "=", "mReadMethod", ".", "getTagValue", "(", "tagName", ")", ";", "}", "if", "(", "value", "==", "null", "&&", "mWriteMethod", "!=", "null", ")", "{", "value", "=", "mWriteMethod", ".", "getTagValue", "(", "tagName", ")", ";", "}", "return", "value", ";", "}" ]

[ "Overridden", "to", "check", "both", "the", "read", "and", "write", "MethodDocs", "for", "the", "tag" ]

[ "private", "String", "getMethodCommentText", "(", ")", "{", "String", "text", "=", "null", ";", "// Check the read method first", "if", "(", "mReadMethod", "!=", "null", ")", "{", "text", "=", "mReadMethod", ".", "getCommentText", "(", ")", ";", "}", "if", "(", "text", "==", "null", "&&", "mWriteMethod", "!=", "null", ")", "{", "// Try the write method", "text", "=", "mWriteMethod", ".", "getCommentText", "(", ")", ";", "}", "if", "(", "text", "==", "null", "||", "text", ".", "trim", "(", ")", ".", "length", "(", ")", "==", "0", ")", "{", "// Try the \"@return\" tag", "text", "=", "getTagValue", "(", "\"return\"", ")", ";", "}", "return", "text", ";", "}" ]

[ "Checks", "both", "the", "read", "and", "write", "MethodDocs", "for", "a", "comment" ]

[ "String", "createTemplateServerRequest", "(", "String", "servletPath", ",", "String", "templateName", ")", "{", "String", "pathInfo", "=", "servletPath", ".", "substring", "(", "servletPath", ".", "indexOf", "(", "\"/\"", ",", "TEMPLATE_LOAD_PROTOCOL", ".", "length", "(", ")", ")", ")", ";", "if", "(", "templateName", "!=", "null", ")", "{", "pathInfo", "=", "pathInfo", "+", "templateName", ";", "}", "return", "pathInfo", ";", "}" ]

[ "turns", "a", "template", "name", "and", "a", "servlet", "path", "into", "a" ]

[ "private", "Map", "<", "String", ",", "TemplateSourceInfo", ">", "retrieveTemplateMap", "(", ")", "{", "Map", "<", "String", ",", "TemplateSourceInfo", ">", "templateMap", "=", "new", "TreeMap", "<", "String", ",", "TemplateSourceInfo", ">", "(", ")", ";", "String", "remoteSource", "=", "mRemoteSourceDir", ";", "if", "(", "!", "remoteSource", ".", "endsWith", "(", "\"/\"", ")", ")", "{", "remoteSource", "=", "remoteSource", "+", "\"/\"", ";", "}", "try", "{", "HttpClient", "tsClient", "=", "getTemplateServerClient", "(", "remoteSource", ")", ";", "HttpClient", ".", "Response", "response", "=", "tsClient", ".", "setURI", "(", "createTemplateServerRequest", "(", "remoteSource", ",", "null", ")", ")", ".", "setPersistent", "(", "true", ")", ".", "getResponse", "(", ")", ";", "if", "(", "response", "!=", "null", "&&", "response", ".", "getStatusCode", "(", ")", "==", "200", ")", "{", "Reader", "rin", "=", "new", "InputStreamReader", "(", "new", "BufferedInputStream", "(", "response", ".", "getInputStream", "(", ")", ")", ")", ";", "StreamTokenizer", "st", "=", "new", "StreamTokenizer", "(", "rin", ")", ";", "st", ".", "resetSyntax", "(", ")", ";", "st", ".", "wordChars", "(", "'", "'", ",", "'", "'", ")", ";", "st", ".", "wordChars", "(", "'", "'", ",", "'", "'", ")", ";", "st", ".", "whitespaceChars", "(", "0", ",", "'", "'", ")", ";", "st", ".", "parseNumbers", "(", ")", ";", "st", ".", "quoteChar", "(", "'", "'", ")", ";", "st", ".", "eolIsSignificant", "(", "true", ")", ";", "String", "templateName", "=", "null", ";", "int", "tokenID", "=", "0", ";", "// ditching the headers by looking for \"\\r\\n\\r\\n\"", "/* \n * no longer needed now that HttpClient is being used but leave\n * in for the moment.\n *\n * while (!((tokenID = st.nextToken()) == StreamTokenizer.TT_EOL \n * && st.nextToken() == StreamTokenizer.TT_EOL) \n * && tokenID != StreamTokenizer.TT_EOF) {\n * }\n */", "while", "(", "(", "tokenID", "=", "st", ".", "nextToken", "(", ")", ")", "!=", "StreamTokenizer", ".", "TT_EOF", ")", "{", "if", "(", "tokenID", "==", "'", "'", "||", "tokenID", "==", "StreamTokenizer", ".", "TT_WORD", ")", "{", "templateName", "=", "st", ".", "sval", ";", "}", "else", "if", "(", "tokenID", "==", "StreamTokenizer", ".", "TT_NUMBER", "&&", "templateName", "!=", "null", ")", "{", "templateName", "=", "templateName", ".", "substring", "(", "1", ")", ";", "//System.out.println(templateName);", "templateMap", ".", "put", "(", "templateName", ".", "replace", "(", "'", "'", ",", "'", "'", ")", ",", "new", "TemplateSourceInfo", "(", "templateName", ",", "remoteSource", ",", "(", "long", ")", "st", ".", "nval", ")", ")", ";", "templateName", "=", "null", ";", "}", "}", "}", "}", "catch", "(", "IOException", "ioe", ")", "{", "ioe", ".", "printStackTrace", "(", ")", ";", "}", "return", "templateMap", ";", "}" ]

[ "creates", "a", "map", "relating", "the", "templates", "found", "on", "the", "template", "server", "to", "the", "timestamp", "on", "the", "sourcecode" ]

[ "public", "synchronized", "static", "TypeDesc", "forClass", "(", "Class", "<", "?", ">", "clazz", ")", "{", "if", "(", "clazz", "==", "null", ")", "{", "return", "null", ";", "}", "TypeDesc", "type", "=", "cClassesToInstances", ".", "get", "(", "clazz", ")", ";", "if", "(", "type", "!=", "null", ")", "{", "return", "type", ";", "}", "if", "(", "clazz", ".", "isArray", "(", ")", ")", "{", "type", "=", "forClass", "(", "clazz", ".", "getComponentType", "(", ")", ")", ".", "toArrayType", "(", ")", ";", "}", "else", "if", "(", "clazz", ".", "isPrimitive", "(", ")", ")", "{", "if", "(", "clazz", "==", "int", ".", "class", ")", "{", "type", "=", "INT", ";", "}", "if", "(", "clazz", "==", "boolean", ".", "class", ")", "{", "type", "=", "BOOLEAN", ";", "}", "if", "(", "clazz", "==", "char", ".", "class", ")", "{", "type", "=", "CHAR", ";", "}", "if", "(", "clazz", "==", "byte", ".", "class", ")", "{", "type", "=", "BYTE", ";", "}", "if", "(", "clazz", "==", "long", ".", "class", ")", "{", "type", "=", "LONG", ";", "}", "if", "(", "clazz", "==", "float", ".", "class", ")", "{", "type", "=", "FLOAT", ";", "}", "if", "(", "clazz", "==", "double", ".", "class", ")", "{", "type", "=", "DOUBLE", ";", "}", "if", "(", "clazz", "==", "short", ".", "class", ")", "{", "type", "=", "SHORT", ";", "}", "if", "(", "clazz", "==", "void", ".", "class", ")", "{", "type", "=", "VOID", ";", "}", "}", "else", "{", "String", "name", "=", "clazz", ".", "getName", "(", ")", ";", "type", "=", "intern", "(", "new", "ObjectType", "(", "generateDescriptor", "(", "name", ")", ",", "name", ")", ")", ";", "}", "cClassesToInstances", ".", "put", "(", "clazz", ",", "type", ")", ";", "return", "type", ";", "}" ]

[ "Acquire", "a", "TypeDesc", "from", "any", "class", "including", "primitives", "and", "arrays", "." ]

[ "public", "static", "TypeDesc", "forDescriptor", "(", "String", "desc", ")", "throws", "IllegalArgumentException", "{", "// TODO: Figure out how to cache these. Using a plain IdentityMap poses", "// a problem. The back reference to the key causes a memory leak.", "TypeDesc", "td", ";", "int", "cursor", "=", "0", ";", "int", "dim", "=", "0", ";", "try", "{", "char", "c", ";", "while", "(", "(", "c", "=", "desc", ".", "charAt", "(", "cursor", "++", ")", ")", "==", "'", "'", ")", "{", "dim", "++", ";", "}", "switch", "(", "c", ")", "{", "case", "'", "'", ":", "td", "=", "VOID", ";", "break", ";", "case", "'", "'", ":", "td", "=", "BOOLEAN", ";", "break", ";", "case", "'", "'", ":", "td", "=", "CHAR", ";", "break", ";", "case", "'", "'", ":", "td", "=", "BYTE", ";", "break", ";", "case", "'", "'", ":", "td", "=", "SHORT", ";", "break", ";", "case", "'", "'", ":", "td", "=", "INT", ";", "break", ";", "case", "'", "'", ":", "td", "=", "LONG", ";", "break", ";", "case", "'", "'", ":", "td", "=", "FLOAT", ";", "break", ";", "case", "'", "'", ":", "td", "=", "DOUBLE", ";", "break", ";", "case", "'", "'", ":", "if", "(", "dim", ">", "0", ")", "{", "desc", "=", "desc", ".", "substring", "(", "dim", ")", ";", "cursor", "=", "1", ";", "}", "StringBuffer", "name", "=", "new", "StringBuffer", "(", "desc", ".", "length", "(", ")", "-", "2", ")", ";", "while", "(", "(", "c", "=", "desc", ".", "charAt", "(", "cursor", "++", ")", ")", "!=", "'", "'", ")", "{", "if", "(", "c", "==", "'", "'", ")", "{", "c", "=", "'", "'", ";", "}", "name", ".", "append", "(", "c", ")", ";", "}", "td", "=", "intern", "(", "new", "ObjectType", "(", "desc", ",", "name", ".", "toString", "(", ")", ")", ")", ";", "break", ";", "default", ":", "throw", "invalidDescriptor", "(", "desc", ")", ";", "}", "}", "catch", "(", "NullPointerException", "e", ")", "{", "throw", "invalidDescriptor", "(", "desc", ")", ";", "}", "catch", "(", "IndexOutOfBoundsException", "e", ")", "{", "throw", "invalidDescriptor", "(", "desc", ")", ";", "}", "if", "(", "cursor", "!=", "desc", ".", "length", "(", ")", ")", "{", "throw", "invalidDescriptor", "(", "desc", ")", ";", "}", "while", "(", "--", "dim", ">=", "0", ")", "{", "td", "=", "td", ".", "toArrayType", "(", ")", ";", "}", "return", "td", ";", "}" ]

[ "Acquire", "a", "TypeDesc", "from", "a", "type", "descriptor", ".", "This", "syntax", "is", "described", "in", "section", "4", ".", "3", ".", "2", "Field", "Descriptors", "." ]

[ "public", "String", "getMessage", "(", ")", "{", "Throwable", "rock", "=", "getUndeclaredThrowable", "(", ")", ";", "if", "(", "rock", "!=", "null", ")", "{", "return", "rock", ".", "getMessage", "(", ")", ";", "}", "else", "{", "return", "super", ".", "getMessage", "(", ")", ";", "}", "}" ]

[ "overridden", "Throwable", "methods" ]

[ "static", "ConstantClassInfo", "make", "(", "ConstantPool", "cp", ",", "String", "className", ",", "int", "dim", ")", "{", "ConstantInfo", "ci", "=", "new", "ConstantClassInfo", "(", "cp", ",", "className", ",", "dim", ")", ";", "return", "(", "ConstantClassInfo", ")", "cp", ".", "addConstant", "(", "ci", ")", ";", "}" ]

[ "Used", "to", "describe", "an", "array", "class", "." ]

[ "public", "void", "addReadUrl", "(", "String", "url", ")", "{", "//", "// Only cache the url data if logging is enabled.", "//", "if", "(", "readUrlLoggingEnabled", "==", "false", ")", "{", "return", ";", "}", "//", "// Strip off the query parameters.", "//", "int", "paramIndex", "=", "url", ".", "indexOf", "(", "'", "'", ")", ";", "String", "filteredUrl", "=", "url", ";", "if", "(", "paramIndex", "!=", "-", "1", ")", "{", "filteredUrl", "=", "url", ".", "substring", "(", "0", ",", "paramIndex", ")", ";", "}", "//", "// Because Cache doesn't take advantage of the underlying concurrentMap, this code either has to (1)introduce ", "// sync block to synchronize addReadUrl requests which would negatively impact all templates calling addReadUrl", "// or (2) accept potential race condition during the first add call on the same Url. This implementation takes", "// (2) approach as this feature is more for reporting and hence not worth the performance degradation . Also, ", "// once the first record is added to the map, the race condition no longer exists due to the use of atomic ", "// variable.", "// ", "AtomicLong", "count", "=", "(", "AtomicLong", ")", "__UrlMap", ".", "get", "(", "filteredUrl", ")", ";", "if", "(", "count", "==", "null", ")", "{", "count", "=", "new", "AtomicLong", "(", "1", ")", ";", "__UrlMap", ".", "put", "(", "filteredUrl", ",", "count", ")", ";", "}", "else", "{", "count", ".", "incrementAndGet", "(", ")", ";", "}", "}" ]

[ "Adds", "the", "URL", "to", "the", "list", "if", "it", "doesn", "t", "already", "exist", ".", "Or", "increment", "the", "hit", "count", "otherwise", "." ]

[ "public", "Scope", "[", "]", "getChildren", "(", ")", "{", "if", "(", "mChildren", "==", "null", ")", "{", "return", "new", "Scope", "[", "0", "]", ";", "}", "else", "{", "return", "mChildren", ".", "toArray", "(", "new", "Scope", "[", "mChildren", ".", "size", "(", ")", "]", ")", ";", "}", "}" ]

[ "Returns", "an", "empty", "array", "if", "this", "scope", "has", "no", "children", "." ]

[ "public", "Variable", "declareVariable", "(", "Variable", "var", ",", "boolean", "isPrivate", ")", "{", "if", "(", "mVariables", ".", "containsKey", "(", "var", ")", ")", "{", "var", "=", "mVariables", ".", "get", "(", "var", ")", ";", "}", "else", "{", "mVariables", ".", "put", "(", "var", ",", "var", ")", ";", "}", "mDeclared", ".", "put", "(", "var", ".", "getName", "(", ")", ",", "var", ")", ";", "if", "(", "isPrivate", ")", "{", "if", "(", "mPrivateVars", "==", "null", ")", "{", "mPrivateVars", "=", "new", "HashSet", "<", "Variable", ">", "(", "7", ")", ";", "}", "mPrivateVars", ".", "add", "(", "var", ")", ";", "}", "else", "{", "if", "(", "mPrivateVars", "!=", "null", ")", "{", "mPrivateVars", ".", "remove", "(", "var", ")", ";", "}", "}", "return", "var", ";", "}" ]

[ "Declare", "a", "variable", "for", "use", "in", "this", "scope", ".", "If", "no", "variable", "of", "this", "name", "and", "type", "has", "been", "defined", "it", "is", "added", "to", "the", "shared", "set", "of", "pooled", "variables", ".", "Returns", "the", "actual", "Variable", "object", "that", "should", "be", "used", "instead", "." ]

[ "public", "void", "declareVariables", "(", "Variable", "[", "]", "vars", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "vars", ".", "length", ";", "i", "++", ")", "{", "vars", "[", "i", "]", "=", "declareVariable", "(", "vars", "[", "i", "]", ")", ";", "}", "}" ]

[ "Declare", "new", "variables", "in", "this", "scope", ".", "Entries", "in", "the", "array", "are", "replaced", "with", "actual", "Variable", "objects", "that", "should", "be", "used", "instead", "." ]

[ "public", "Variable", "getDeclaredVariable", "(", "String", "name", ",", "boolean", "publicOnly", ")", "{", "//private Set mPrivateVars;", "Variable", "var", "=", "mDeclared", ".", "get", "(", "name", ")", ";", "if", "(", "var", "!=", "null", ")", "{", "// If its okay to be private or its public then...", "if", "(", "!", "publicOnly", "||", "mPrivateVars", "==", "null", "||", "!", "mPrivateVars", ".", "contains", "(", "var", ")", ")", "{", "return", "var", ";", "}", "}", "if", "(", "mParent", "!=", "null", ")", "{", "return", "mParent", ".", "getDeclaredVariable", "(", "name", ")", ";", "}", "return", "null", ";", "}" ]

[ "Returns", "a", "declared", "variable", "by", "name", ".", "Search", "begins", "in", "this", "scope", "and", "moves", "up", "into", "parent", "scopes", ".", "If", "not", "found", "null", "is", "returned", ".", "A", "public", "-", "only", "variable", "can", "be", "requested", "." ]

[ "private", "Variable", "[", "]", "getLocallyDeclaredVariables", "(", ")", "{", "Collection", "<", "Variable", ">", "vars", "=", "mDeclared", ".", "values", "(", ")", ";", "return", "vars", ".", "toArray", "(", "new", "Variable", "[", "vars", ".", "size", "(", ")", "]", ")", ";", "}" ]

[ "Returns", "all", "the", "variables", "declared", "in", "this", "scope", "." ]

[ "public", "boolean", "bindToVariable", "(", "VariableRef", "ref", ")", "{", "String", "name", "=", "ref", ".", "getName", "(", ")", ";", "Variable", "var", "=", "getDeclaredVariable", "(", "name", ")", ";", "if", "(", "var", "!=", "null", ")", "{", "ref", ".", "setType", "(", "null", ")", ";", "ref", ".", "setVariable", "(", "var", ")", ";", "mVariableRefs", ".", "add", "(", "ref", ")", ";", "return", "true", ";", "}", "else", "{", "return", "false", ";", "}", "}" ]

[ "Attempt", "to", "bind", "variable", "reference", "to", "a", "variable", "in", "this", "scope", "or", "a", "parent", "scope", ".", "If", "the", "variable", "to", "bind", "to", "isn", "t", "available", "or", "doesn", "t", "exist", "false", "is", "returned", "." ]

[ "public", "VariableRef", "[", "]", "getVariableRefs", "(", ")", "{", "Collection", "<", "VariableRef", ">", "allRefs", "=", "new", "ArrayList", "<", "VariableRef", ">", "(", ")", ";", "fillVariableRefs", "(", "allRefs", ",", "this", ")", ";", "return", "allRefs", ".", "toArray", "(", "new", "VariableRef", "[", "allRefs", ".", "size", "(", ")", "]", ")", ";", "}" ]

[ "Returns", "all", "the", "variable", "references", "made", "from", "this", "scope", "and", "all", "child", "scopes", "." ]

[ "public", "VariableRef", "[", "]", "getLocalVariableRefs", "(", ")", "{", "VariableRef", "[", "]", "refs", "=", "new", "VariableRef", "[", "mVariableRefs", ".", "size", "(", ")", "]", ";", "return", "mVariableRefs", ".", "toArray", "(", "refs", ")", ";", "}" ]

[ "Returns", "all", "the", "references", "made", "from", "this", "scope", "to", "variables", "declared", "in", "this", "scope", "or", "in", "a", "parent", "." ]

[ "public", "VariableRef", "[", "]", "getOutOfScopeVariableRefs", "(", ")", "{", "Scope", "parent", ";", "if", "(", "(", "parent", "=", "getParent", "(", ")", ")", "==", "null", ")", "{", "return", "new", "VariableRef", "[", "0", "]", ";", "}", "Collection", "<", "VariableRef", ">", "allRefs", "=", "new", "ArrayList", "<", "VariableRef", ">", "(", ")", ";", "fillVariableRefs", "(", "allRefs", ",", "this", ")", ";", "Collection", "<", "VariableRef", ">", "refs", "=", "new", "ArrayList", "<", "VariableRef", ">", "(", "allRefs", ".", "size", "(", ")", ")", ";", "Iterator", "<", "VariableRef", ">", "it", "=", "allRefs", ".", "iterator", "(", ")", ";", "while", "(", "it", ".", "hasNext", "(", ")", ")", "{", "VariableRef", "ref", "=", "it", ".", "next", "(", ")", ";", "Variable", "var", "=", "ref", ".", "getVariable", "(", ")", ";", "if", "(", "var", "!=", "null", "&&", "parent", ".", "getDeclaredVariable", "(", "var", ".", "getName", "(", ")", ")", "==", "var", ")", "{", "refs", ".", "add", "(", "ref", ")", ";", "}", "}", "VariableRef", "[", "]", "refsArray", "=", "new", "VariableRef", "[", "refs", ".", "size", "(", ")", "]", ";", "return", "refs", ".", "toArray", "(", "refsArray", ")", ";", "}" ]

[ "Returns", "all", "the", "references", "made", "from", "this", "scope", "and", "all", "child", "scopes", "to", "variables", "declared", "outside", "of", "this", "scope", "." ]

[ "public", "boolean", "isEnclosing", "(", "Scope", "scope", ")", "{", "for", "(", ";", "scope", "!=", "null", ";", "scope", "=", "scope", ".", "getParent", "(", ")", ")", "{", "if", "(", "this", "==", "scope", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Returns", "true", "if", "this", "scope", "is", "the", "same", "as", "or", "a", "parent", "of", "the", "one", "given", "." ]

[ "public", "Scope", "getEnclosingScope", "(", "Scope", "scope", ")", "{", "for", "(", "Scope", "s", "=", "this", ";", "s", "!=", "null", ";", "s", "=", "s", ".", "getParent", "(", ")", ")", "{", "if", "(", "s", ".", "isEnclosing", "(", "scope", ")", ")", "{", "return", "s", ";", "}", "}", "return", "null", ";", "}" ]

[ "Returns", "the", "innermost", "enclosing", "scope", "of", "this", "and", "the", "one", "given", ".", "If", "no", "enclosing", "scope", "exists", "null", "is", "returned", "." ]

[ "public", "boolean", "hasPrimitivePeer", "(", ")", "{", "if", "(", "mObjectClass", "==", "Integer", ".", "class", "||", "mObjectClass", "==", "Boolean", ".", "class", "||", "mObjectClass", "==", "Byte", ".", "class", "||", "mObjectClass", "==", "Character", ".", "class", "||", "mObjectClass", "==", "Short", ".", "class", "||", "mObjectClass", "==", "Long", ".", "class", "||", "mObjectClass", "==", "Float", ".", "class", "||", "mObjectClass", "==", "Double", ".", "class", "||", "mObjectClass", "==", "Void", ".", "class", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Returns", "true", "if", "this", "type", "is", "not", "primitive", "but", "it", "has", "a", "primitive", "type", "peer", "." ]

[ "public", "Type", "toPrimitive", "(", ")", "{", "if", "(", "mPrimitive", ")", "{", "return", "this", ";", "}", "else", "{", "Class", "<", "?", ">", "primitive", "=", "convertToPrimitive", "(", "mObjectClass", ")", ";", "if", "(", "primitive", ".", "isPrimitive", "(", ")", ")", "{", "return", "new", "Type", "(", "primitive", ")", ";", "}", "else", "{", "return", "new", "Type", "(", "mGenericType", ",", "primitive", ")", ";", "}", "}", "}" ]

[ "Returns", "a", "new", "type", "from", "this", "one", "that", "represents", "a", "primitive", "type", ".", "If", "this", "type", "cannot", "be", "represented", "by", "a", "primitive", "then", "this", "is", "returned", "." ]

[ "public", "Type", "toNonNull", "(", ")", "{", "if", "(", "isNonNull", "(", ")", ")", "{", "return", "this", ";", "}", "else", "{", "return", "new", "Type", "(", "this", ")", "{", "private", "static", "final", "long", "serialVersionUID", "=", "1L", ";", "public", "boolean", "isNonNull", "(", ")", "{", "return", "true", ";", "}", "public", "boolean", "isNullable", "(", ")", "{", "return", "false", ";", "}", "public", "Type", "toNullable", "(", ")", "{", "return", "Type", ".", "this", ";", "}", "}", ";", "}", "}" ]

[ "Returns", "this", "type", "converted", "such", "that", "it", "cannot", "reference", "null", "." ]

[ "public", "Type", "[", "]", "getArrayIndexTypes", "(", ")", "throws", "IntrospectionException", "{", "if", "(", "!", "mCheckedForArrayLookup", ")", "{", "checkForArrayLookup", "(", ")", ";", "}", "return", "mArrayIndexTypes", "==", "null", "?", "null", ":", "(", "Type", "[", "]", ")", "mArrayIndexTypes", ".", "clone", "(", ")", ";", "}" ]

[ "If", "this", "Type", "supports", "array", "lookup", "then", "return", "the", "index", "type", ".", "Because", "the", "index", "type", "may", "be", "overloaded", "an", "array", "is", "returned", ".", "Null", "is", "returned", "if", "this", "Type", "doesn", "t", "support", "array", "lookup", "." ]

[ "public", "Method", "[", "]", "getArrayAccessMethods", "(", ")", "throws", "IntrospectionException", "{", "if", "(", "!", "mCheckedForArrayLookup", ")", "{", "checkForArrayLookup", "(", ")", ";", "}", "return", "mArrayAccessMethods", "==", "null", "?", "null", ":", "(", "Method", "[", "]", ")", "mArrayAccessMethods", ".", "clone", "(", ")", ";", "}" ]

[ "If", "this", "Type", "supports", "array", "lookup", "then", "return", "all", "of", "the", "methods", "that", "can", "be", "called", "to", "access", "the", "array", ".", "If", "there", "are", "no", "methods", "then", "an", "empty", "array", "is", "returned", ".", "Null", "is", "returned", "only", "if", "this", "Type", "doesn", "t", "support", "array", "lookup", "." ]

[ "public", "Type", "getIterationElementType", "(", ")", "throws", "IntrospectionException", "{", "if", "(", "!", "mCheckedForIteration", ")", "{", "mCheckedForIteration", "=", "true", ";", "if", "(", "mIterationElementType", "!=", "null", ")", "return", "mIterationElementType", ";", "if", "(", "mNaturalClass", ".", "isArray", "(", ")", ")", "{", "mIterationElementType", "=", "getArrayElementType", "(", ")", ";", "}", "else", "if", "(", "Collection", ".", "class", ".", "isAssignableFrom", "(", "mNaturalClass", ")", "||", "Map", ".", "class", ".", "isAssignableFrom", "(", "mNaturalClass", ")", ")", "{", "mIterationElementType", "=", "getIterationType", "(", "mGenericType", ")", ";", "if", "(", "mIterationElementType", "==", "null", "||", "mIterationElementType", "==", "OBJECT_TYPE", ")", "{", "try", "{", "Field", "field", "=", "mNaturalClass", ".", "getField", "(", "BeanAnalyzer", ".", "ELEMENT_TYPE_FIELD_NAME", ")", ";", "if", "(", "field", ".", "getType", "(", ")", "==", "Class", ".", "class", "&&", "Modifier", ".", "isStatic", "(", "field", ".", "getModifiers", "(", ")", ")", ")", "{", "mIterationElementType", "=", "new", "Type", "(", "(", "Class", "<", "?", ">", ")", "field", ".", "get", "(", "null", ")", ")", ";", "}", "}", "catch", "(", "NoSuchFieldException", "e", ")", "{", "// nothing to do", "}", "catch", "(", "IllegalAccessException", "e", ")", "{", "// nothing to do", "}", "}", "}", "if", "(", "mIterationElementType", "==", "null", ")", "{", "mIterationElementType", "=", "Type", ".", "OBJECT_TYPE", ";", "}", "}", "return", "mIterationElementType", ";", "}" ]

[ "If", "this", "type", "supports", "iteration", "then", "the", "element", "type", "is", "returned", ".", "Otherwise", "null", "is", "returned", "." ]

[ "public", "boolean", "isReverseIterationSupported", "(", ")", "{", "return", "mNaturalClass", ".", "isArray", "(", ")", "||", "List", ".", "class", ".", "isAssignableFrom", "(", "mNaturalClass", ")", "||", "Set", ".", "class", ".", "isAssignableFrom", "(", "mNaturalClass", ")", "||", "Map", ".", "class", ".", "isAssignableFrom", "(", "mNaturalClass", ")", ";", "}" ]

[ "Returns", "true", "if", "this", "type", "supports", "iteration", "in", "the", "reverse", "direction", "." ]

[ "public", "Type", "setArrayElementType", "(", "Type", "elementType", ")", "throws", "IntrospectionException", "{", "Type", "type", "=", "new", "Type", "(", "mGenericType", ",", "mNaturalClass", ")", ";", "type", ".", "checkForArrayLookup", "(", ")", ";", "type", ".", "mArrayElementType", "=", "elementType", ";", "return", "type", ";", "}" ]

[ "Accessed", "by", "the", "TypeChecker", "to", "override", "the", "default", "." ]

[ "public", "Type", "getCompatibleType", "(", "Type", "other", ")", "{", "if", "(", "other", "==", "null", ")", "{", "return", "null", ";", "}", "if", "(", "equals", "(", "other", ")", ")", "{", "if", "(", "this", "==", "NULL_TYPE", ")", "{", "return", "other", ";", "}", "else", "{", "return", "this", ";", "}", "}", "Class", "<", "?", ">", "classA", "=", "mObjectClass", ";", "Class", "<", "?", ">", "classB", "=", "other", ".", "mObjectClass", ";", "Type", "compat", ";", "if", "(", "classA", "==", "Void", ".", "class", ")", "{", "if", "(", "classB", "==", "Void", ".", "class", ")", "{", "compat", "=", "this", ";", "}", "else", "{", "return", "null", ";", "}", "}", "else", "if", "(", "classB", "==", "Void", ".", "class", ")", "{", "return", "null", ";", "}", "else", "if", "(", "other", "==", "NULL_TYPE", ")", "{", "compat", "=", "this", ".", "toNullable", "(", ")", ";", "}", "else", "if", "(", "this", "==", "NULL_TYPE", ")", "{", "compat", "=", "other", ".", "toNullable", "(", ")", ";", "}", "else", "if", "(", "Number", ".", "class", ".", "isAssignableFrom", "(", "classA", ")", "&&", "Number", ".", "class", ".", "isAssignableFrom", "(", "classB", ")", ")", "{", "Class", "<", "?", ">", "clazz", "=", "compatibleNumber", "(", "classA", ",", "classB", ")", ";", "if", "(", "isPrimitive", "(", ")", "&&", "other", ".", "isPrimitive", "(", ")", ")", "{", "compat", "=", "new", "Type", "(", "clazz", ",", "convertToPrimitive", "(", "clazz", ")", ")", ";", "}", "else", "{", "compat", "=", "new", "Type", "(", "clazz", ")", ";", "}", "}", "else", "{", "// TODO: ensure generics are matched", "// ie: List<Number> and List<Integer> = List<Number>", "compat", "=", "new", "Type", "(", "findCommonBaseClass", "(", "classA", ",", "classB", ")", ")", ";", "}", "if", "(", "isNonNull", "(", ")", "&&", "other", ".", "isNonNull", "(", ")", ")", "{", "compat", "=", "compat", ".", "toNonNull", "(", ")", ";", "}", "return", "compat", ";", "}" ]

[ "Returns", "a", "type", "that", "is", "compatible", "with", "this", "type", "and", "the", "one", "passed", "in", ".", "The", "type", "returned", "is", "selected", "using", "a", "best", "-", "fit", "algorithm", "." ]

[ "public", "static", "Type", "preserveType", "(", "Type", "currentType", ",", "Type", "newType", ")", "{", "Type", "result", "=", "newType", ";", "if", "(", "newType", "!=", "null", "&&", "currentType", "!=", "null", "&&", "currentType", ".", "getObjectClass", "(", ")", "==", "newType", ".", "getObjectClass", "(", ")", ")", "{", "if", "(", "newType", ".", "getGenericType", "(", ")", ".", "getGenericType", "(", ")", "instanceof", "Class", "&&", "!", "(", "currentType", ".", "getGenericType", "(", ")", ".", "getGenericType", "(", ")", "instanceof", "Class", ")", ")", "{", "if", "(", "newType", ".", "isNonNull", "(", ")", "&&", "!", "currentType", ".", "isNonNull", "(", ")", ")", "{", "result", "=", "currentType", ".", "toNonNull", "(", ")", ";", "}", "else", "if", "(", "!", "newType", ".", "isNonNull", "(", ")", "&&", "currentType", ".", "isNonNull", "(", ")", ")", "{", "result", "=", "currentType", ".", "toNullable", "(", ")", ";", "}", "}", "}", "return", "result", ";", "}" ]

[ "Preserve", "the", "current", "type", "s", "generic", "information", "with", "the", "specified", "new", "type", "if", "they", "have", "the", "same", "class", "." ]

[ "public", "static", "Class", "<", "?", ">", "findCommonBaseClass", "(", "Class", "<", "?", ">", "a", ",", "Class", "<", "?", ">", "b", ")", "{", "Class", "<", "?", ">", "clazz", "=", "findCommonBaseClass0", "(", "a", ",", "b", ")", ";", "if", "(", "clazz", "!=", "null", "&&", "clazz", ".", "isInterface", "(", ")", ")", "{", "// Only return interface if it actually defines something.", "if", "(", "clazz", ".", "getMethods", "(", ")", ".", "length", "<=", "0", ")", "{", "//clazz = Object.class;", "}", "}", "return", "clazz", ";", "}" ]

[ "Returns", "the", "most", "specific", "common", "superclass", "or", "interface", "that", "can", "be", "used", "to", "represent", "both", "of", "the", "specified", "classes", ".", "Null", "is", "only", "returned", "if", "either", "class", "refers", "to", "a", "primitive", "type", "and", "isn", "t", "the", "same", "as", "the", "other", "class", "." ]

[ "private", "static", "Class", "<", "?", ">", "convertToObject", "(", "Class", "<", "?", ">", "type", ")", "{", "if", "(", "type", "==", "int", ".", "class", ")", "{", "return", "Integer", ".", "class", ";", "}", "else", "if", "(", "type", "==", "boolean", ".", "class", ")", "{", "return", "Boolean", ".", "class", ";", "}", "else", "if", "(", "type", "==", "byte", ".", "class", ")", "{", "return", "Byte", ".", "class", ";", "}", "else", "if", "(", "type", "==", "char", ".", "class", ")", "{", "return", "Character", ".", "class", ";", "}", "else", "if", "(", "type", "==", "short", ".", "class", ")", "{", "return", "Short", ".", "class", ";", "}", "else", "if", "(", "type", "==", "long", ".", "class", ")", "{", "return", "Long", ".", "class", ";", "}", "else", "if", "(", "type", "==", "float", ".", "class", ")", "{", "return", "Float", ".", "class", ";", "}", "else", "if", "(", "type", "==", "double", ".", "class", ")", "{", "return", "Double", ".", "class", ";", "}", "else", "if", "(", "type", "==", "void", ".", "class", ")", "{", "return", "Void", ".", "class", ";", "}", "else", "{", "return", "type", ";", "}", "}" ]

[ "If", "class", "passed", "in", "represents", "a", "primitive", "type", "its", "object", "peer", "is", "returned", ".", "Otherwise", "it", "is", "returned", "unchanged", "." ]

[ "public", "int", "convertableFrom", "(", "Type", "other", ",", "boolean", "vararg", ")", "{", "int", "cost", "=", "convertableFrom", "(", "other", ")", ";", "if", "(", "cost", "<", "0", ")", "{", "return", "cost", ";", "}", "return", "(", "vararg", "?", "cost", "+", "40", ":", "cost", ")", ";", "}" ]

[ "Check", "if", "a", "type", "is", "convertable", "including", "support", "for", "varargs", ".", "If", "varargs", "is", "true", "then", "this", "will", "add", "40", "to", "the", "total", "cost", "such", "that", "non", "-", "varargs", "will", "always", "take", "precedence", "." ]

[ "static", "ConstantIntegerInfo", "make", "(", "ConstantPool", "cp", ",", "int", "value", ")", "{", "ConstantInfo", "ci", "=", "new", "ConstantIntegerInfo", "(", "value", ")", ";", "return", "(", "ConstantIntegerInfo", ")", "cp", ".", "addConstant", "(", "ci", ")", ";", "}" ]

[ "Will", "return", "either", "a", "new", "ConstantIntegerInfo", "object", "or", "one", "already", "in", "the", "constant", "pool", ".", "If", "it", "is", "a", "new", "ConstantIntegerInfo", "it", "will", "be", "inserted", "into", "the", "pool", "." ]

[ "public", "List", "<", "CompileEvent", ">", "getErrors", "(", ")", "{", "List", "<", "CompileEvent", ">", "errors", "=", "new", "ArrayList", "<", "CompileEvent", ">", "(", ")", ";", "for", "(", "CompileEvent", "event", ":", "mIssues", ")", "{", "if", "(", "event", ".", "isError", "(", ")", ")", "{", "errors", ".", "add", "(", "event", ")", ";", "}", "}", "return", "errors", ";", "}" ]

[ "Retrieves", "the", "set", "of", "errors", "that", "were", "reported", "via", "the", "compileError", "method", "." ]

[ "public", "List", "<", "CompileEvent", ">", "getWarnings", "(", ")", "{", "List", "<", "CompileEvent", ">", "warnings", "=", "new", "ArrayList", "<", "CompileEvent", ">", "(", ")", ";", "for", "(", "CompileEvent", "event", ":", "mIssues", ")", "{", "if", "(", "event", ".", "isWarning", "(", ")", ")", "{", "warnings", ".", "add", "(", "event", ")", ";", "}", "}", "return", "warnings", ";", "}" ]

[ "Retrieves", "the", "set", "of", "warnings", "that", "were", "reported", "via", "the", "compileWarning", "method", "." ]

[ "public", "String", "[", "]", "getPagination", "(", "String", "text", ",", "int", "maxChars", ",", "String", "splitValue", ",", "String", "[", "]", "HTMLBalanceTags", ")", "{", "int", "count", ";", "int", "lastSplitCount", ";", "String", "tempHolder", "=", "\" \"", ";", "List", "<", "String", ">", "list", "=", "new", "ArrayList", "<", "String", ">", "(", ")", ";", "boolean", "secondRunThrough", "=", "false", ";", "// if the story will not be broken up because it's too small, ", "// just return it without doing all the logic.", "if", "(", "(", "getCharCount", "(", "text", ")", "<=", "maxChars", ")", ")", "{", "list", ".", "add", "(", "text", ")", ";", "return", "list", ".", "toArray", "(", "new", "String", "[", "list", ".", "size", "(", ")", "]", ")", ";", "}", "//JVM 1.4 version", "//String[] splits = text.split(splitValue);", "//Will need an HTMLBalance function if implemented.", "//JVM 1.3 version", "String", "[", "]", "splits", "=", "split", "(", "text", ",", "splitValue", ",", "HTMLBalanceTags", ")", ";", "int", "len", "=", "splits", ".", "length", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "len", ";", "i", "++", ")", "{", "//Check to see if last page would not be at least half filled. ", "// If so, add to previous page.", "if", "(", "i", "==", "len", "-", "2", ")", "{", "lastSplitCount", "=", "getCharCount", "(", "splits", "[", "i", "+", "1", "]", ")", ";", "if", "(", "lastSplitCount", "<=", "maxChars", "/", "2", ")", "{", "splits", "[", "i", "]", "=", "splits", "[", "i", "]", "+", "\" \"", "+", "splits", "[", "i", "+", "1", "]", ";", "list", ".", "add", "(", "tempHolder", "+", "splits", "[", "i", "]", ")", ";", "return", "list", ".", "toArray", "(", "new", "String", "[", "list", ".", "size", "(", ")", "]", ")", ";", "}", "}", "if", "(", "secondRunThrough", ")", "{", "count", "=", "getCharCount", "(", "tempHolder", "+", "splits", "[", "i", "]", ")", ";", "}", "else", "{", "count", "=", "getCharCount", "(", "splits", "[", "i", "]", ")", ";", "}", "if", "(", "count", ">=", "maxChars", "||", "i", "+", "1", "==", "len", ")", "{", "list", ".", "add", "(", "tempHolder", "+", "splits", "[", "i", "]", ")", ";", "secondRunThrough", "=", "false", ";", "tempHolder", "=", "\" \"", ";", "}", "else", "{", "tempHolder", "=", "tempHolder", "+", "splits", "[", "i", "]", ";", "secondRunThrough", "=", "true", ";", "}", "}", "return", "list", ".", "toArray", "(", "new", "String", "[", "list", ".", "size", "(", ")", "]", ")", ";", "}" ]

[ "Paginate", "the", "given", "text", "input", "so", "that", "each", "page", "contains", "no", "more", "than", "the", "given", "maximum", "number", "of", "characters", ".", "The", "length", "of", "each", "page", "is", "based", "on", "the", "text", "only", "ignoring", "any", "HTML", "tags", "." ]

[ "public", "String", "[", "]", "split", "(", "String", "text", ",", "String", "splitValue", ",", "String", "[", "]", "HTMLBalanceTags", ")", "{", "String", "restOfText", "=", "text", ";", "int", "nextBreakIndex", "=", "0", ";", "List", "<", "String", ">", "list", "=", "new", "ArrayList", "<", "String", ">", "(", ")", ";", "int", "splitValueLength", "=", "splitValue", ".", "length", "(", ")", ";", "while", "(", "restOfText", ".", "length", "(", ")", ">", "0", ")", "{", "nextBreakIndex", "=", "restOfText", ".", "indexOf", "(", "splitValue", ")", ";", "if", "(", "nextBreakIndex", "<", "0", ")", "{", "list", ".", "add", "(", "restOfText", ")", ";", "break", ";", "}", "list", ".", "add", "(", "restOfText", ".", "substring", "(", "0", ",", "nextBreakIndex", "+", "splitValueLength", ")", ")", ";", "restOfText", "=", "restOfText", ".", "substring", "(", "nextBreakIndex", "+", "splitValueLength", ")", ";", "}", "// This code makes sure that no ending HTML </> tags are left out ", "// causing malfomed pages.", "if", "(", "HTMLBalanceTags", ".", "length", ">", "0", ")", "{", "List", "<", "String", ">", "balancedList", "=", "new", "ArrayList", "<", "String", ">", "(", ")", ";", "for", "(", "int", "t", "=", "0", ";", "t", "<", "HTMLBalanceTags", ".", "length", ";", "t", "++", ")", "{", "// first tag pass through", "if", "(", "t", "<", "1", ")", "{", "balancedList", "=", "getBalancedList", "(", "HTMLBalanceTags", "[", "t", "]", ",", "list", ")", ";", "}", "else", "if", "(", "balancedList", ".", "size", "(", ")", ">", "1", ")", "{", "// after the first pass through keep trying on each", "// subsequent tag.", "balancedList", "=", "getBalancedList", "(", "HTMLBalanceTags", "[", "t", "]", ",", "balancedList", ")", ";", "}", "}", "return", "balancedList", ".", "toArray", "(", "new", "String", "[", "balancedList", ".", "size", "(", ")", "]", ")", ";", "}", "else", "{", "return", "list", ".", "toArray", "(", "new", "String", "[", "list", ".", "size", "(", ")", "]", ")", ";", "}", "}" ]

[ "Split", "the", "given", "string", "around", "the", "given", "split", "value", ".", "This", "will", "also", "ensure", "any", "of", "the", "given", "HTML", "tags", "are", "properly", "closed", "." ]

[ "public", "Annotation", "[", "]", "[", "]", "getAnnotations", "(", ")", "{", "Annotation", "[", "]", "[", "]", "copy", "=", "new", "Annotation", "[", "mParameterAnnotations", ".", "size", "(", ")", "]", "[", "", "]", ";", "for", "(", "int", "i", "=", "copy", ".", "length", ";", "--", "i", ">=", "0", ";", ")", "{", "Vector", "<", "Annotation", ">", "annotations", "=", "mParameterAnnotations", ".", "get", "(", "i", ")", ";", "if", "(", "annotations", "==", "null", ")", "{", "copy", "[", "i", "]", "=", "new", "Annotation", "[", "0", "]", ";", "}", "else", "{", "copy", "[", "i", "]", "=", "annotations", ".", "toArray", "(", "new", "Annotation", "[", "annotations", ".", "size", "(", ")", "]", ")", ";", "}", "}", "return", "copy", ";", "}" ]

[ "First", "array", "index", "is", "zero", "-", "based", "parameter", "number", "." ]

[ "public", "void", "launchAuto", "(", "boolean", "active", ")", "{", "killAuto", "(", ")", ";", "if", "(", "mSock", "!=", "null", ")", "{", "try", "{", "mAuto", "=", "new", "AutomaticClusterManagementThread", "(", "this", ",", "mCluster", ".", "getClusterName", "(", ")", ",", "active", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "mAuto", "=", "new", "AutomaticClusterManagementThread", "(", "this", ",", "active", ")", ";", "}", "if", "(", "mAuto", "!=", "null", ")", "{", "mAuto", ".", "start", "(", ")", ";", "}", "}", "}" ]

[ "Allows", "the", "management", "thread", "to", "passively", "take", "part", "in", "the", "cluster", "operations", ".", "Other", "cluster", "members", "will", "not", "be", "made", "aware", "of", "this", "instance", "." ]

[ "public", "void", "launchAuto", "(", "AutomaticClusterManagementThread", "auto", ")", "{", "killAuto", "(", ")", ";", "if", "(", "mSock", "!=", "null", ")", "{", "mAuto", "=", "auto", ";", "if", "(", "mAuto", "!=", "null", ")", "{", "mAuto", ".", "start", "(", ")", ";", "}", "}", "}" ]

[ "permits", "the", "AutomaticClusterManagementThread", "to", "be", "subclassed", "and", "used", "into", "the", "ClusterManager", "." ]

[ "public", "long", "convertIPBytes", "(", "byte", "[", "]", "ipBytes", ")", "{", "if", "(", "ipBytes", ".", "length", "==", "4", ")", "{", "long", "ipLong", "=", "(", "(", "(", "long", ")", "ipBytes", "[", "0", "]", ")", "<<", "24", ")", ";", "ipLong", "|=", "(", "(", "(", "long", ")", "ipBytes", "[", "1", "]", ")", "<<", "16", ")", ";", "ipLong", "|=", "(", "(", "(", "long", ")", "ipBytes", "[", "2", "]", ")", "<<", "8", ")", ";", "ipLong", "|=", "(", "long", ")", "ipBytes", "[", "3", "]", ";", "return", "ipLong", ";", "}", "return", "-", "1", ";", "}" ]

[ "converts", "an", "array", "of", "four", "bytes", "to", "a", "long", "." ]

[ "public", "long", "convertIPString", "(", "String", "ip", ")", "throws", "NumberFormatException", ",", "IllegalArgumentException", "{", "StringTokenizer", "st", "=", "new", "StringTokenizer", "(", "ip", ",", "\".\"", ")", ";", "if", "(", "st", ".", "countTokens", "(", ")", "==", "4", ")", "{", "long", "ipLong", "=", "(", "Long", ".", "parseLong", "(", "st", ".", "nextToken", "(", ")", ")", "<<", "24", ")", ";", "ipLong", "+=", "(", "Long", ".", "parseLong", "(", "st", ".", "nextToken", "(", ")", ")", "<<", "16", ")", ";", "ipLong", "+=", "(", "Long", ".", "parseLong", "(", "st", ".", "nextToken", "(", ")", ")", "<<", "8", ")", ";", "ipLong", "+=", "Long", ".", "parseLong", "(", "st", ".", "nextToken", "(", ")", ")", ";", "return", "ipLong", ";", "}", "else", "{", "throw", "new", "IllegalArgumentException", "(", "\"Invalid IP string\"", ")", ";", "}", "}" ]

[ "turns", "a", "dot", "delimited", "IP", "address", "string", "into", "a", "long", "." ]

[ "public", "String", "convertIPBackToString", "(", "long", "ip", ")", "{", "StringBuffer", "sb", "=", "new", "StringBuffer", "(", "16", ")", ";", "sb", ".", "append", "(", "Long", ".", "toString", "(", "(", "ip", ">>", "24", ")", "&", "0xFF", ")", ")", ";", "sb", ".", "append", "(", "'", "'", ")", ";", "sb", ".", "append", "(", "Long", ".", "toString", "(", "(", "ip", ">>", "16", ")", "&", "0xFF", ")", ")", ";", "sb", ".", "append", "(", "'", "'", ")", ";", "sb", ".", "append", "(", "Long", ".", "toString", "(", "(", "ip", ">>", "8", ")", "&", "0xFF", ")", ")", ";", "sb", ".", "append", "(", "'", "'", ")", ";", "sb", ".", "append", "(", "Long", ".", "toString", "(", "ip", "&", "0xFF", ")", ")", ";", "return", "sb", ".", "toString", "(", ")", ";", "}" ]

[ "converts", "a", "long", "to", "a", "dot", "delimited", "IP", "address", "string", "." ]

[ "public", "Class", "<", "?", ">", "loadClass", "(", "String", "name", ")", "throws", "ClassNotFoundException", "{", "while", "(", "true", ")", "{", "try", "{", "if", "(", "mClassLoader", "==", "null", ")", "{", "return", "Class", ".", "forName", "(", "name", ")", ";", "}", "else", "{", "return", "mClassLoader", ".", "loadClass", "(", "name", ")", ";", "}", "}", "catch", "(", "ClassNotFoundException", "e", ")", "{", "int", "index", "=", "name", ".", "lastIndexOf", "(", "'", "'", ")", ";", "if", "(", "index", "<", "0", ")", "{", "throw", "e", ";", "}", "// Search for inner class.", "name", "=", "name", ".", "substring", "(", "0", ",", "index", ")", "+", "'", "'", "+", "name", ".", "substring", "(", "index", "+", "1", ")", ";", "}", "}", "}" ]

[ "Loads", "and", "returns", "a", "class", "by", "the", "fully", "qualified", "name", "given", ".", "If", "a", "ClassLoader", "is", "specified", "it", "is", "used", "to", "load", "the", "class", ".", "Otherwise", "the", "class", "is", "loaded", "via", "Class", ".", "forName", "." ]

[ "public", "void", "preserveParseTree", "(", "String", "name", ")", "{", "if", "(", "mPreserveTree", "==", "null", ")", "{", "mPreserveTree", "=", "new", "HashSet", "<", "String", ">", "(", ")", ";", "}", "mPreserveTree", ".", "add", "(", "name", ")", ";", "}" ]

[ "After", "a", "template", "is", "compiled", "all", "but", "the", "root", "node", "of", "its", "parse", "tree", "is", "clipped", "in", "order", "to", "save", "memory", ".", "Applications", "that", "wish", "to", "traverse", "CompilationUnit", "parse", "trees", "should", "call", "this", "method", "to", "preserve", "them", ".", "This", "method", "must", "be", "called", "prior", "to", "compilation", "and", "prior", "to", "requesting", "a", "parse", "tree", "from", "a", "CompilationUnit", "." ]

[ "public", "String", "[", "]", "compile", "(", "String", "[", "]", "names", ")", "throws", "IOException", "{", "if", "(", "!", "TemplateRepository", ".", "isInitialized", "(", ")", ")", "{", "return", "compile0", "(", "names", ")", ";", "}", "String", "[", "]", "compNames", "=", "compile0", "(", "names", ")", ";", "ArrayList", "<", "String", ">", "compList", "=", "new", "ArrayList", "<", "String", ">", "(", "Arrays", ".", "asList", "(", "compNames", ")", ")", ";", "TemplateRepository", "rep", "=", "TemplateRepository", ".", "getInstance", "(", ")", ";", "String", "[", "]", "callers", "=", "rep", ".", "getCallersNeedingRecompile", "(", "compNames", ",", "this", ")", ";", "if", "(", "callers", ".", "length", ">", "0", ")", "compList", ".", "addAll", "(", "Arrays", ".", "asList", "(", "compile0", "(", "callers", ")", ")", ")", ";", "String", "[", "]", "compiled", "=", "compList", ".", "toArray", "(", "new", "String", "[", "compList", ".", "size", "(", ")", "]", ")", ";", "// JoshY - There's a VM bug in JVM 1.4.2 that can cause the repository ", "// update to throw a NullPointerException when it shouldn't. There's a ", "// workaround in place and we also put a catch here, to allow the ", "// TeaServlet init to finish just in case", "try", "{", "rep", ".", "update", "(", "compiled", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "System", ".", "err", ".", "println", "(", "\"Unable to update repository\"", ")", ";", "e", ".", "printStackTrace", "(", "System", ".", "err", ")", ";", "}", "return", "compiled", ";", "}" ]

[ "Compile", "a", "list", "of", "compilation", "units", ".", "This", "method", "can", "be", "called", "multiple", "times", "but", "it", "will", "not", "compile", "compilation", "units", "that", "have", "already", "been", "compiled", "." ]

[ "public", "CompilationUnit", "getCompilationUnit", "(", "String", "name", ",", "CompilationUnit", "from", ")", "{", "String", "fqName", "=", "determineQualifiedName", "(", "name", ",", "from", ")", ";", "// Templates with source will always override compiled templates", "boolean", "compiled", "=", "false", ";", "if", "(", "fqName", "==", "null", "&&", "(", "compiled", "=", "CompiledTemplate", ".", "exists", "(", "this", ",", "name", ",", "from", ")", ")", ")", "{", "fqName", "=", "CompiledTemplate", ".", "getFullyQualifiedName", "(", "name", ")", ";", "}", "if", "(", "fqName", "==", "null", ")", "return", "null", ";", "CompilationUnit", "unit", "=", "mCompilationUnitMap", ".", "get", "(", "fqName", ")", ";", "if", "(", "unit", "==", "null", ")", "{", "if", "(", "!", "compiled", ")", "{", "unit", "=", "createCompilationUnit", "(", "fqName", ")", ";", "if", "(", "unit", "!=", "null", ")", "mCompilationUnitMap", ".", "put", "(", "fqName", ",", "unit", ")", ";", "}", "else", "{", "unit", "=", "new", "CompiledTemplate", "(", "name", ",", "this", ",", "from", ")", ";", "// if the CompiledTemplate class was precompiled (is valid) return the unit, otherwise return null to signify 'not found'", "if", "(", "(", "(", "CompiledTemplate", ")", "unit", ")", ".", "isValid", "(", ")", ")", "{", "mCompilationUnitMap", ".", "put", "(", "fqName", ",", "unit", ")", ";", "}", "else", "{", "// TODO: flag the template class for removal", "unit", "=", "null", ";", "}", "}", "}", "return", "unit", ";", "}" ]

[ "Returns", "a", "compilation", "unit", "associated", "with", "the", "given", "name", "or", "null", "if", "not", "found", "." ]

[ "public", "void", "addImportedPackages", "(", "String", "[", "]", "imports", ")", "{", "if", "(", "imports", "==", "null", ")", "{", "return", ";", "}", "for", "(", "String", "imported", ":", "imports", ")", "{", "this", ".", "mImports", ".", "add", "(", "imported", ")", ";", "}", "}" ]

[ "Add", "all", "imported", "packages", "that", "all", "templates", "will", "have", "." ]

[ "public", "final", "Method", "[", "]", "getStringConverterMethods", "(", ")", "{", "if", "(", "mStringConverters", "==", "null", ")", "{", "String", "name", "=", "getRuntimeStringConverter", "(", ")", ";", "Vector", "<", "Method", ">", "methods", "=", "new", "Vector", "<", "Method", ">", "(", ")", ";", "if", "(", "name", "!=", "null", ")", "{", "Method", "[", "]", "contextMethods", "=", "getRuntimeContextMethods", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "contextMethods", ".", "length", ";", "i", "++", ")", "{", "Method", "m", "=", "contextMethods", "[", "i", "]", ";", "if", "(", "m", ".", "getName", "(", ")", ".", "equals", "(", "name", ")", "&&", "m", ".", "getReturnType", "(", ")", "==", "String", ".", "class", "&&", "m", ".", "getParameterTypes", "(", ")", ".", "length", "==", "1", ")", "{", "methods", ".", "addElement", "(", "m", ")", ";", "}", "}", "}", "int", "customSize", "=", "methods", ".", "size", "(", ")", ";", "Method", "[", "]", "stringMethods", "=", "String", ".", "class", ".", "getMethods", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "stringMethods", ".", "length", ";", "i", "++", ")", "{", "Method", "m", "=", "stringMethods", "[", "i", "]", ";", "if", "(", "m", ".", "getName", "(", ")", ".", "equals", "(", "\"valueOf\"", ")", "&&", "m", ".", "getReturnType", "(", ")", "==", "String", ".", "class", "&&", "m", ".", "getParameterTypes", "(", ")", ".", "length", "==", "1", "&&", "Modifier", ".", "isStatic", "(", "m", ".", "getModifiers", "(", ")", ")", ")", "{", "// Don't add to list if a custom converter already handles", "// this method's parameter type.", "Class", "<", "?", ">", "type", "=", "m", ".", "getParameterTypes", "(", ")", "[", "0", "]", ";", "int", "j", ";", "for", "(", "j", "=", "0", ";", "j", "<", "customSize", ";", "j", "++", ")", "{", "Method", "cm", "=", "methods", ".", "elementAt", "(", "j", ")", ";", "if", "(", "cm", ".", "getParameterTypes", "(", ")", "[", "0", "]", "==", "type", ")", "{", "break", ";", "}", "}", "if", "(", "j", "==", "customSize", ")", "{", "methods", ".", "addElement", "(", "m", ")", ";", "}", "}", "}", "mStringConverters", "=", "new", "Method", "[", "methods", ".", "size", "(", ")", "]", ";", "methods", ".", "copyInto", "(", "mStringConverters", ")", ";", "}", "return", "mStringConverters", ".", "clone", "(", ")", ";", "}" ]

[ "Returns", "the", "set", "of", "methods", "that", "are", "used", "to", "perform", "conversion", "to", "strings", ".", "The", "compiler", "will", "bind", "to", "the", "closest", "matching", "method", "based", "on", "its", "parameter", "type", "." ]

[ "private", "String", "determineQualifiedName", "(", "String", "name", ",", "CompilationUnit", "from", ")", "{", "if", "(", "from", "!=", "null", ")", "{", "// Determine qualified name as being relative to \"from\"", "String", "fromName", "=", "from", ".", "getName", "(", ")", ";", "int", "index", "=", "fromName", ".", "lastIndexOf", "(", "'", "'", ")", ";", "if", "(", "index", ">=", "0", ")", "{", "String", "qual", "=", "fromName", ".", "substring", "(", "0", ",", "index", "+", "1", ")", "+", "name", ";", "if", "(", "sourceExists", "(", "qual", ")", ")", "{", "return", "qual", ";", "}", "}", "}", "if", "(", "sourceExists", "(", "name", ")", ")", "{", "return", "name", ";", "}", "return", "null", ";", "}" ]

[ "Given", "a", "name", "as", "requested", "by", "the", "given", "CompilationUnit", "return", "a", "fully", "qualified", "name", "or", "null", "if", "the", "name", "could", "not", "be", "found", "." ]

[ "public", "Result", "getMatch", "(", "String", "lookup", ")", "{", "int", "strLen", "=", "lookup", ".", "length", "(", ")", ";", "char", "[", "]", "chars", "=", "new", "char", "[", "strLen", "+", "1", "]", ";", "lookup", ".", "getChars", "(", "0", ",", "strLen", ",", "chars", ",", "0", ")", ";", "chars", "[", "strLen", "]", "=", "'", "'", ";", "TinyList", "resultList", "=", "new", "TinyList", "(", ")", ";", "fillMatchResults", "(", "chars", ",", "1", ",", "resultList", ")", ";", "return", "(", "Result", ")", "resultList", ".", "mElement", ";", "}" ]

[ "Returns", "null", "if", "no", "match", "." ]

[ "protected", "static", "boolean", "addMatchResult", "(", "int", "limit", ",", "List", "results", ",", "String", "pattern", ",", "Object", "value", ",", "int", "[", "]", "positions", ",", "int", "len", ")", "{", "int", "size", "=", "results", ".", "size", "(", ")", ";", "if", "(", "size", "<", "limit", ")", "{", "if", "(", "positions", "==", "null", "||", "len", "==", "0", ")", "{", "positions", "=", "NO_POSITIONS", ";", "}", "else", "{", "int", "[", "]", "original", "=", "positions", ";", "positions", "=", "new", "int", "[", "len", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "len", ";", "i", "++", ")", "{", "positions", "[", "i", "]", "=", "original", "[", "i", "]", ";", "}", "}", "results", ".", "add", "(", "new", "Result", "(", "pattern", ",", "value", ",", "positions", ")", ")", ";", "return", "size", "+", "1", "<", "limit", ";", "}", "else", "{", "return", "false", ";", "}", "}" ]

[ "Returns", "false", "if", "no", "more", "results", "should", "be", "added", "." ]

[ "public", "boolean", "endsWith", "(", "String", "str", ",", "String", "suffix", ")", "{", "return", "(", "str", "==", "null", "||", "suffix", "==", "null", ")", "?", "(", "str", "==", "suffix", ")", ":", "str", ".", "endsWith", "(", "suffix", ")", ";", "}" ]

[ "Tests", "if", "the", "given", "string", "ends", "with", "the", "given", "suffix", ".", "Returns", "true", "if", "the", "given", "string", "ends", "with", "the", "given", "suffix", "." ]

[ "public", "int", "[", "]", "find", "(", "String", "str", ",", "String", "search", ",", "int", "fromIndex", ")", "{", "if", "(", "str", "==", "null", "||", "search", "==", "null", ")", "{", "return", "new", "int", "[", "0", "]", ";", "}", "int", "[", "]", "indices", "=", "new", "int", "[", "10", "]", ";", "int", "size", "=", "0", ";", "int", "index", "=", "fromIndex", ";", "while", "(", "(", "index", "=", "str", ".", "indexOf", "(", "search", ",", "index", ")", ")", ">=", "0", ")", "{", "if", "(", "size", ">=", "indices", ".", "length", ")", "{", "// Expand capacity.", "int", "[", "]", "newArray", "=", "new", "int", "[", "indices", ".", "length", "*", "2", "]", ";", "System", ".", "arraycopy", "(", "indices", ",", "0", ",", "newArray", ",", "0", ",", "indices", ".", "length", ")", ";", "indices", "=", "newArray", ";", "}", "indices", "[", "size", "++", "]", "=", "index", ";", "index", "+=", "search", ".", "length", "(", ")", ";", "}", "if", "(", "size", "<", "indices", ".", "length", ")", "{", "// Trim capacity.", "int", "[", "]", "newArray", "=", "new", "int", "[", "size", "]", ";", "System", ".", "arraycopy", "(", "indices", ",", "0", ",", "newArray", ",", "0", ",", "size", ")", ";", "indices", "=", "newArray", ";", "}", "return", "indices", ";", "}" ]

[ "Finds", "the", "indices", "for", "each", "occurrence", "of", "the", "given", "search", "string", "in", "the", "source", "string", "starting", "from", "the", "given", "index", "." ]

[ "public", "int", "findFirst", "(", "String", "str", ",", "String", "search", ")", "{", "return", "(", "str", "==", "null", "||", "search", "==", "null", ")", "?", "-", "1", ":", "str", ".", "indexOf", "(", "search", ")", ";", "}" ]

[ "Finds", "the", "index", "of", "the", "first", "occurrence", "of", "the", "given", "search", "string", "in", "the", "source", "string", "or", "-", "1", "if", "not", "found", "." ]

[ "public", "String", "substring", "(", "String", "str", ",", "int", "startIndex", ",", "int", "endIndex", ")", "{", "return", "(", "str", "==", "null", ")", "?", "null", ":", "str", ".", "substring", "(", "startIndex", ",", "endIndex", ")", ";", "}" ]

[ "Returns", "a", "sub", "-", "portion", "of", "the", "given", "string", "for", "the", "characters", "that", "are", "at", "or", "after", "the", "starting", "index", "and", "are", "before", "the", "end", "index", "." ]

[ "public", "String", "trimLeading", "(", "String", "str", ")", "{", "if", "(", "str", "==", "null", ")", "{", "return", "null", ";", "}", "int", "length", "=", "str", ".", "length", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "length", ";", "i", "++", ")", "{", "if", "(", "str", ".", "charAt", "(", "i", ")", ">", "'", "'", ")", "{", "return", "str", ".", "substring", "(", "i", ")", ";", "}", "}", "return", "\"\"", ";", "}" ]

[ "Trims", "all", "leading", "whitespace", "characters", "from", "the", "given", "string", "." ]

[ "public", "String", "trimTrailing", "(", "String", "str", ")", "{", "if", "(", "str", "==", "null", ")", "{", "return", "null", ";", "}", "int", "length", "=", "str", ".", "length", "(", ")", ";", "for", "(", "int", "i", "=", "length", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "str", ".", "charAt", "(", "i", ")", ">", "'", "'", ")", "{", "return", "str", ".", "substring", "(", "0", ",", "i", "+", "1", ")", ";", "}", "}", "return", "\"\"", ";", "}" ]

[ "Trims", "all", "trailing", "whitespace", "characters", "from", "the", "given", "string", "." ]

[ "public", "String", "[", "]", "split", "(", "String", "str", ",", "String", "regex", ",", "int", "limit", ")", "{", "return", "str", ".", "split", "(", "regex", ",", "limit", ")", ";", "}" ]

[ "Split", "the", "given", "string", "with", "the", "given", "regular", "expression", "returning", "the", "array", "of", "strings", "after", "splitting", "." ]

[ "public", "String", "[", "]", "splitString", "(", "String", "text", ",", "int", "maxChars", ")", "{", "String", "[", "]", "splitVals", "=", "{", "\" \"", "}", ";", "return", "splitString", "(", "text", ",", "maxChars", ",", "splitVals", ")", ";", "}" ]

[ "Split", "the", "given", "string", "on", "spaces", "ensuring", "the", "maximum", "number", "of", "characters", "in", "each", "token", "." ]

[ "public", "String", "[", "]", "splitString", "(", "String", "text", ",", "int", "maxChars", ",", "String", "[", "]", "splitValues", ")", "{", "String", "restOfText", "=", "text", ";", "List", "<", "String", ">", "list", "=", "new", "ArrayList", "<", "String", ">", "(", ")", ";", "while", "(", "restOfText", ".", "length", "(", ")", ">", "maxChars", ")", "{", "String", "thisLine", "=", "restOfText", ".", "substring", "(", "0", ",", "maxChars", ")", ";", "int", "lineEnd", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "splitValues", ".", "length", ";", "i", "++", ")", "{", "int", "lastIndex", "=", "thisLine", ".", "lastIndexOf", "(", "splitValues", "[", "i", "]", ")", ";", "if", "(", "lastIndex", ">", "lineEnd", ")", "{", "lineEnd", "=", "lastIndex", ";", "}", "}", "if", "(", "lineEnd", "==", "0", ")", "{", "list", ".", "add", "(", "thisLine", ")", ";", "restOfText", "=", "restOfText", ".", "substring", "(", "maxChars", ")", ";", "}", "else", "{", "list", ".", "add", "(", "thisLine", ".", "substring", "(", "0", ",", "lineEnd", ")", ")", ";", "restOfText", "=", "restOfText", ".", "substring", "(", "lineEnd", ")", ";", "}", "}", "list", ".", "add", "(", "restOfText", ")", ";", "return", "list", ".", "toArray", "(", "new", "String", "[", "list", ".", "size", "(", ")", "]", ")", ";", "}" ]

[ "Split", "the", "given", "string", "on", "the", "given", "split", "values", "ensuring", "the", "maximum", "number", "of", "characters", "in", "each", "token", "." ]

[ "public", "String", "[", "]", "tokenize", "(", "String", "string", ",", "String", "token", ")", "{", "String", "[", "]", "result", ";", "try", "{", "StringTokenizer", "st", "=", "new", "StringTokenizer", "(", "string", ",", "token", ")", ";", "List", "<", "String", ">", "list", "=", "new", "ArrayList", "<", "String", ">", "(", ")", ";", "while", "(", "st", ".", "hasMoreTokens", "(", ")", ")", "{", "list", ".", "add", "(", "st", ".", "nextToken", "(", ")", ")", ";", "}", "result", "=", "list", ".", "toArray", "(", "new", "String", "[", "list", ".", "size", "(", ")", "]", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "result", "=", "null", ";", "}", "return", "result", ";", "}" ]

[ "Tokenize", "the", "given", "string", "with", "the", "given", "token", ".", "This", "will", "return", "an", "array", "of", "strings", "containing", "each", "token", "delimited", "by", "the", "given", "value", "." ]

[ "public", "String", "[", "]", "addToStringArray", "(", "String", "[", "]", "strArray", ",", "String", "str", ")", "{", "String", "[", "]", "result", "=", "null", ";", "if", "(", "strArray", "!=", "null", ")", "{", "result", "=", "new", "String", "[", "strArray", ".", "length", "+", "1", "]", ";", "System", ".", "arraycopy", "(", "strArray", ",", "0", ",", "result", ",", "0", ",", "strArray", ".", "length", ")", ";", "result", "[", "strArray", ".", "length", "]", "=", "str", ";", "}", "return", "result", ";", "}" ]

[ "Add", "the", "given", "string", "to", "the", "string", "array", ".", "This", "will", "create", "a", "new", "array", "expanded", "by", "one", "element", "copy", "the", "existing", "array", "add", "the", "given", "value", "and", "return", "the", "resulting", "array", "." ]

[ "public", "String", "[", "]", "removeFromStringArray", "(", "String", "[", "]", "strArray", ",", "String", "str", ")", "{", "String", "[", "]", "result", "=", "null", ";", "if", "(", "strArray", "!=", "null", "&&", "strArray", ".", "length", ">", "0", ")", "{", "List", "<", "String", ">", "list", "=", "new", "ArrayList", "<", "String", ">", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "strArray", ".", "length", ";", "i", "++", ")", "{", "if", "(", "!", "strArray", "[", "i", "]", ".", "equals", "(", "str", ")", ")", "{", "list", ".", "add", "(", "strArray", "[", "i", "]", ")", ";", "}", "}", "int", "size", "=", "list", ".", "size", "(", ")", ";", "if", "(", "size", ">", "0", ")", "{", "result", "=", "list", ".", "toArray", "(", "new", "String", "[", "size", "]", ")", ";", "}", "}", "return", "result", ";", "}" ]

[ "Remove", "all", "occurrences", "of", "the", "given", "string", "from", "the", "given", "array", ".", "This", "will", "create", "a", "new", "array", "containing", "all", "elements", "of", "the", "given", "array", "except", "for", "those", "matching", "the", "given", "value", "." ]

[ "public", "String", "[", "]", "removeFromStringArray", "(", "String", "[", "]", "strArray", ",", "int", "index", ")", "{", "String", "[", "]", "result", "=", "null", ";", "if", "(", "strArray", "!=", "null", "&&", "index", ">", "0", "&&", "index", "<", "strArray", ".", "length", ")", "{", "result", "=", "new", "String", "[", "strArray", ".", "length", "-", "1", "]", ";", "for", "(", "int", "i", "=", "0", ",", "j", "=", "0", ";", "i", "<", "strArray", ".", "length", ";", "i", "++", ")", "{", "if", "(", "i", "!=", "index", ")", "{", "result", "[", "j", "++", "]", "=", "strArray", "[", "i", "]", ";", "}", "}", "}", "return", "result", ";", "}" ]

[ "Remove", "the", "string", "at", "the", "given", "index", "from", "the", "given", "array", ".", "This", "will", "return", "a", "new", "array", "containing", "the", "given", "array", "excluding", "the", "element", "at", "the", "given", "index", "." ]

[ "public", "boolean", "setInStringArray", "(", "String", "[", "]", "strArray", ",", "int", "index", ",", "String", "str", ")", "{", "boolean", "result", "=", "false", ";", "if", "(", "strArray", "!=", "null", "&&", "index", ">=", "0", "&&", "index", "<", "strArray", ".", "length", ")", "{", "strArray", "[", "index", "]", "=", "str", ";", "result", "=", "true", ";", "}", "return", "result", ";", "}" ]

[ "Set", "the", "given", "string", "in", "the", "given", "array", "at", "the", "given", "index", ".", "This", "will", "overwrite", "the", "existing", "value", "at", "the", "given", "index", "." ]

[ "public", "String", "convertToEncoding", "(", "String", "subject", ",", "String", "encoding", ")", "throws", "UnsupportedEncodingException", "{", "return", "new", "String", "(", "subject", ".", "getBytes", "(", "encoding", ")", ",", "encoding", ")", ";", "}" ]

[ "Convert", "the", "given", "string", "to", "the", "given", "encoding", "." ]

[ "public", "String", "replaceFirstRegex", "(", "String", "subject", ",", "String", "regex", ",", "String", "replacement", ")", "{", "return", "subject", ".", "replaceFirst", "(", "regex", ",", "replacement", ")", ";", "}" ]

[ "Replace", "the", "given", "regular", "expression", "pattern", "with", "the", "given", "replacement", ".", "Only", "the", "first", "match", "will", "be", "replaced", "." ]

[ "public", "String", "replaceAllRegex", "(", "String", "subject", ",", "String", "regex", ",", "String", "replacement", ")", "{", "return", "subject", ".", "replaceAll", "(", "regex", ",", "replacement", ")", ";", "}" ]

[ "Replace", "the", "given", "regular", "expression", "pattern", "with", "the", "given", "replacement", ".", "This", "will", "replace", "all", "matches", "in", "the", "given", "string", "." ]

[ "public", "void", "append", "(", "StringBuilder", "buffer", ",", "Object", "value", ")", "{", "if", "(", "buffer", "==", "null", ")", "{", "throw", "new", "NullPointerException", "(", "\"buffer\"", ")", ";", "}", "buffer", ".", "append", "(", "value", ")", ";", "}" ]

[ "A", "function", "to", "append", "a", "value", "to", "an", "existing", "buffer", "." ]

[ "public", "void", "prepend", "(", "StringBuilder", "buffer", ",", "Object", "value", ")", "{", "if", "(", "buffer", "==", "null", ")", "{", "throw", "new", "NullPointerException", "(", "\"buffer\"", ")", ";", "}", "buffer", ".", "insert", "(", "0", ",", "value", ")", ";", "}" ]

[ "A", "function", "to", "prepend", "a", "value", "to", "an", "existing", "buffer", "." ]