Datasets:

CM

/

codexglue_code2text_java

like 4

[ "public", "Object", "createContext", "(", "ApplicationRequest", "request", ",", "ApplicationResponse", "response", ")", "{", "return", "new", "CookieContext", "(", "request", ",", "response", ",", "mDomain", ",", "mPath", ",", "mIsSecure", ")", ";", "}" ]

[ "Creates", "a", "context", "for", "the", "templates", "." ]

[ "public", "File", "[", "]", "getFiles", "(", ")", "{", "String", "path", "=", "mRequest", ".", "getParameter", "(", "\"path\"", ")", ";", "if", "(", "path", "==", "null", ")", "{", "path", "=", "mApp", ".", "getInitParameter", "(", "\"defaultPath\"", ")", ";", "}", "if", "(", "path", "==", "null", ")", "{", "path", "=", "\"/\"", ";", "}", "File", "activefile", "=", "new", "File", "(", "path", ")", ";", "if", "(", "activefile", ".", "isDirectory", "(", ")", ")", "{", "return", "activefile", ".", "listFiles", "(", ")", ";", "}", "else", "{", "return", "null", ";", "}", "}" ]

[ "Gets", "an", "array", "of", "files", "in", "the", "directory", "specified", "by", "the", "path", "query", "parameter", "." ]

[ "public", "void", "clear", "(", ")", "{", "mPutLock", ".", "lock", "(", ")", ";", "mPollLock", ".", "lock", "(", ")", ";", "try", "{", "mSize", ".", "set", "(", "0", ")", ";", "mHead", "=", "new", "Node", "(", "null", ")", ";", "mTail", "=", "new", "Node", "(", "null", ")", ";", "mHead", ".", "mNext", "=", "mTail", ";", "}", "finally", "{", "mPollLock", ".", "unlock", "(", ")", ";", "mPutLock", ".", "unlock", "(", ")", ";", "}", "}" ]

[ "Clears", "the", "contents", "of", "the", "queue", ".", "This", "is", "a", "blocking", "operation", "." ]

[ "public", "boolean", "remove", "(", "Node", "<", "E", ">", "e", ")", "{", "mPutLock", ".", "lock", "(", ")", ";", "mPollLock", ".", "lock", "(", ")", ";", "try", "{", "if", "(", "e", "==", "null", ")", "return", "false", ";", "if", "(", "e", ".", "mRemoved", ")", "return", "false", ";", "if", "(", "mSize", ".", "get", "(", ")", "==", "0", ")", "return", "false", ";", "if", "(", "e", "==", "mTail", ")", "{", "removeTail", "(", ")", ";", "return", "true", ";", "}", "if", "(", "e", "==", "mHead", ".", "mNext", ")", "{", "removeHead", "(", ")", ";", "return", "true", ";", "}", "if", "(", "mSize", ".", "get", "(", ")", "<", "3", ")", "return", "false", ";", "if", "(", "e", ".", "mPrev", "==", "null", "||", "e", ".", "mNext", "==", "null", ")", "return", "false", ";", "e", ".", "mPrev", ".", "mNext", "=", "e", ".", "mNext", ";", "e", ".", "mNext", ".", "mPrev", "=", "e", ".", "mPrev", ";", "e", ".", "mRemoved", "=", "true", ";", "mSize", ".", "decrementAndGet", "(", ")", ";", "mNodePool", ".", "returnNode", "(", "e", ")", ";", "return", "true", ";", "}", "finally", "{", "mPollLock", ".", "unlock", "(", ")", ";", "mPutLock", ".", "unlock", "(", ")", ";", "}", "}" ]

[ "Removes", "a", "given", "Node", "handle", ".", "This", "is", "a", "blocking", "operation", "that", "runs", "in", "constant", "time", "." ]

[ "public", "Object", "getComponent", "(", "String", "role", ",", "String", "roleHint", ")", "throws", "ComponentLookupException", "{", "return", "container", ".", "lookup", "(", "role", ",", "roleHint", ")", ";", "}" ]

[ "Gets", "the", "component", "." ]

[ "public", "void", "setTcpNoDelay", "(", "boolean", "on", ")", "throws", "SocketException", "{", "if", "(", "mSocket", "!=", "null", ")", "{", "mSocket", ".", "setTcpNoDelay", "(", "on", ")", ";", "}", "else", "{", "setOption", "(", "0", ",", "on", "?", "Boolean", ".", "TRUE", ":", "Boolean", ".", "FALSE", ")", ";", "}", "}" ]

[ "Option", "0", "." ]

[ "public", "void", "setSoLinger", "(", "boolean", "on", ",", "int", "linger", ")", "throws", "SocketException", "{", "if", "(", "mSocket", "!=", "null", ")", "{", "mSocket", ".", "setSoLinger", "(", "on", ",", "linger", ")", ";", "}", "else", "{", "Object", "value", ";", "if", "(", "on", ")", "{", "value", "=", "new", "Integer", "(", "linger", ")", ";", "}", "else", "{", "value", "=", "Boolean", ".", "FALSE", ";", "}", "setOption", "(", "1", ",", "value", ")", ";", "}", "}" ]

[ "Option", "1", "." ]

[ "public", "void", "setSoTimeout", "(", "int", "timeout", ")", "throws", "SocketException", "{", "if", "(", "mSocket", "!=", "null", ")", "{", "mSocket", ".", "setSoTimeout", "(", "timeout", ")", ";", "}", "else", "{", "setOption", "(", "2", ",", "new", "Integer", "(", "timeout", ")", ")", ";", "}", "}" ]

[ "Option", "2", "." ]

[ "public", "void", "setSendBufferSize", "(", "int", "size", ")", "throws", "SocketException", "{", "if", "(", "mSocket", "!=", "null", ")", "{", "mSocket", ".", "setSendBufferSize", "(", "size", ")", ";", "}", "else", "{", "setOption", "(", "3", ",", "new", "Integer", "(", "size", ")", ")", ";", "}", "}" ]

[ "Option", "3", "." ]

[ "public", "void", "setReceiveBufferSize", "(", "int", "size", ")", "throws", "SocketException", "{", "if", "(", "mSocket", "!=", "null", ")", "{", "mSocket", ".", "setReceiveBufferSize", "(", "size", ")", ";", "}", "else", "{", "setOption", "(", "4", ",", "new", "Integer", "(", "size", ")", ")", ";", "}", "}" ]

[ "Option", "4", "." ]

[ "CheckedSocket", "recycle", "(", ")", "{", "CheckedSocket", "s", ";", "if", "(", "mClosed", ")", "{", "s", "=", "null", ";", "}", "else", "{", "s", "=", "mSocket", ";", "mSocket", "=", "null", ";", "mClosed", "=", "true", ";", "}", "return", "s", ";", "}" ]

[ "Returns", "the", "internal", "wrapped", "socket", "or", "null", "if", "not", "connected", ".", "After", "calling", "recycle", "this", "LazySocket", "instance", "is", "closed", "." ]

[ "public", "AppAdminLinks", "getAdminLinks", "(", ")", "{", "AppAdminLinks", "links", "=", "new", "AppAdminLinks", "(", "mConfig", ".", "getName", "(", ")", ")", ";", "//links.addAdminLink(\"Instrumentation\",\"/system/console?page=instrumentation\");", "//links.addAdminLink(\"Dashboard\",\"/system/console?page=dashboard\");", "//links.addAdminLink(\"Janitor\",\"/system/console?page=janitor\");", "//links.addAdminLink(\"Compile\",\"/system/console?page=compile\");", "//links.addAdminLink(\"Templates\",\"/system/console?page=templates\");", "//links.addAdminLink(\"Functions\",\"/system/console?page=functions\");", "//links.addAdminLink(\"Applications\", \"/system/console?page=applications\");", "//links.addAdminLink(\"Logs\",\"/system/console?page=logs\");", "//links.addAdminLink(\"Servlet Engine\", \"/system/console?page=servlet_engine\");", "//links.addAdminLink(\"Echo Request\", \"/system/console?page=echo_request\");", "links", ".", "addAdminLink", "(", "\"Templates\"", ",", "\"/system/teaservlet/AdminTemplates\"", ")", ";", "links", ".", "addAdminLink", "(", "\"Functions\"", ",", "\"/system/teaservlet/AdminFunctions\"", ")", ";", "links", ".", "addAdminLink", "(", "\"Applications\"", ",", "\"/system/teaservlet/AdminApplications\"", ")", ";", "links", ".", "addAdminLink", "(", "\"Logs\"", ",", "\"/system/teaservlet/LogViewer\"", ")", ";", "links", ".", "addAdminLink", "(", "\"Servlet Engine\"", ",", "\"/system/teaservlet/AdminServletEngine\"", ")", ";", "return", "links", ";", "}" ]

[ "This", "implementation", "uses", "hard", "coded", "link", "information", "but", "other", "applications", "can", "dynamically", "determine", "their", "admin", "links", "." ]

[ "public", "void", "init", "(", "ServletConfig", "config", ")", "throws", "ServletException", "{", "super", ".", "init", "(", "config", ")", ";", "mServletConfig", "=", "config", ";", "config", ".", "getServletContext", "(", ")", ".", "log", "(", "\"Initializing TeaServlet...\"", ")", ";", "String", "ver", "=", "System", ".", "getProperty", "(", "\"java.version\"", ")", ";", "if", "(", "ver", ".", "startsWith", "(", "\"0.\"", ")", "||", "ver", ".", "startsWith", "(", "\"1.2\"", ")", "||", "ver", ".", "startsWith", "(", "\"1.3\"", ")", ")", "{", "config", ".", "getServletContext", "(", ")", ".", "log", "(", "\"The TeaServlet requires Java 1.4 or higher to run properly\"", ")", ";", "}", "mServletContext", "=", "setServletContext", "(", "config", ")", ";", "mServletName", "=", "setServletName", "(", "config", ")", ";", "mProperties", "=", "new", "PropertyMap", "(", ")", ";", "mSubstitutions", "=", "SubstitutionFactory", ".", "getDefaults", "(", ")", ";", "mResourceFactory", "=", "new", "TeaServletResourceFactory", "(", "config", ".", "getServletContext", "(", ")", ",", "mSubstitutions", ")", ";", "Enumeration", "<", "?", ">", "e", "=", "config", ".", "getInitParameterNames", "(", ")", ";", "while", "(", "e", ".", "hasMoreElements", "(", ")", ")", "{", "String", "key", "=", "(", "String", ")", "e", ".", "nextElement", "(", ")", ";", "String", "value", "=", "SubstitutionFactory", ".", "substitute", "(", "config", ".", "getInitParameter", "(", "key", ")", ")", ";", "if", "(", "key", ".", "equals", "(", "\"debug\"", ")", ")", "{", "mDebugEnabled", "=", "Boolean", ".", "parseBoolean", "(", "value", ")", ";", "continue", ";", "}", "mProperties", ".", "put", "(", "key", ",", "value", ")", ";", "}", "loadDefaults", "(", ")", ";", "discoverProperties", "(", ")", ";", "createListeners", "(", ")", ";", "createLog", "(", "mServletContext", ")", ";", "mLog", ".", "applyProperties", "(", "mProperties", ".", "subMap", "(", "\"log\"", ")", ")", ";", "createMemoryLog", "(", "mLog", ")", ";", "mInstrumentationEnabled", "=", "mProperties", ".", "getBoolean", "(", "\"instrumentation.enabled\"", ",", "true", ")", ";", "Initializer", "initializer", "=", "new", "Initializer", "(", ")", ";", "if", "(", "mProperties", ".", "getBoolean", "(", "\"startup.background\"", ",", "false", ")", ")", "{", "mInitializer", "=", "Executors", ".", "newSingleThreadExecutor", "(", ")", ".", "submit", "(", "initializer", ")", ";", "}", "else", "{", "initializer", ".", "call", "(", ")", ";", "}", "}" ]

[ "Initializes", "the", "TeaServlet", ".", "Creates", "the", "logger", "and", "loads", "the", "user", "s", "application", "." ]

[ "protected", "void", "doGet", "(", "HttpServletRequest", "request", ",", "HttpServletResponse", "response", ")", "throws", "ServletException", ",", "IOException", "{", "if", "(", "processStatus", "(", "request", ",", "response", ")", ")", "{", "return", ";", "}", "if", "(", "!", "isRunning", "(", ")", ")", "{", "int", "errorCode", "=", "mProperties", ".", "getInt", "(", "\"startup.codes.error\"", ",", "503", ")", ";", "response", ".", "sendError", "(", "errorCode", ")", ";", "return", ";", "}", "if", "(", "mUseSpiderableRequest", ")", "{", "request", "=", "new", "SpiderableRequest", "(", "request", ",", "mQuerySeparator", ",", "mParameterSeparator", ",", "mValueSeparator", ")", ";", "}", "// start transaction", "TeaServletTransaction", "tsTrans", "=", "getEngine", "(", ")", ".", "createTransaction", "(", "request", ",", "response", ",", "true", ")", ";", "// load associated request/response", "ApplicationRequest", "appRequest", "=", "tsTrans", ".", "getRequest", "(", ")", ";", "ApplicationResponse", "appResponse", "=", "tsTrans", ".", "getResponse", "(", ")", ";", "// process template", "processTemplate", "(", "appRequest", ",", "appResponse", ")", ";", "appResponse", ".", "finish", "(", ")", ";", "// flush the output", "response", ".", "flushBuffer", "(", ")", ";", "}" ]

[ "Process", "the", "user", "s", "http", "get", "request", ".", "Process", "the", "template", "that", "maps", "to", "the", "URI", "that", "was", "hit", "." ]

[ "private", "boolean", "processResource", "(", "ApplicationRequest", "appRequest", ",", "ApplicationResponse", "appResponse", ")", "throws", "IOException", "{", "// get the associated system path", "String", "requestURI", "=", "null", ";", "if", "(", "(", "requestURI", "=", "appRequest", ".", "getPathInfo", "(", ")", ")", "==", "null", ")", "{", "String", "context", "=", "appRequest", ".", "getContextPath", "(", ")", ";", "requestURI", "=", "appRequest", ".", "getRequestURI", "(", ")", ";", "if", "(", "requestURI", ".", "startsWith", "(", "context", ")", ")", "{", "requestURI", "=", "requestURI", ".", "substring", "(", "context", ".", "length", "(", ")", ")", ";", "}", "}", "// check for valid asset", "Asset", "asset", "=", "getEngine", "(", ")", ".", "getAssetEngine", "(", ")", ".", "getAsset", "(", "requestURI", ")", ";", "if", "(", "asset", "==", "null", ")", "{", "return", "false", ";", "}", "// set mime type", "appResponse", ".", "setContentType", "(", "asset", ".", "getMimeType", "(", ")", ")", ";", "// write contents", "int", "read", "=", "-", "1", ";", "byte", "[", "]", "contents", "=", "new", "byte", "[", "1024", "]", ";", "InputStream", "input", "=", "asset", ".", "getInputStream", "(", ")", ";", "ServletOutputStream", "output", "=", "appResponse", ".", "getOutputStream", "(", ")", ";", "while", "(", "(", "read", "=", "input", ".", "read", "(", "contents", ")", ")", ">=", "0", ")", "{", "output", ".", "write", "(", "contents", ",", "0", ",", "read", ")", ";", "}", "// complete response", "appResponse", ".", "finish", "(", ")", ";", "// success", "return", "true", ";", "}" ]

[ "Inserts", "a", "plugin", "to", "expose", "parts", "of", "the", "teaservlet", "via", "the", "EngineAccess", "interface", "." ]

[ "protected", "Object", "convertParameter", "(", "String", "value", ",", "Class", "<", "?", ">", "toType", ")", "{", "if", "(", "toType", "==", "Boolean", ".", "class", ")", "{", "return", "!", "\"\"", ".", "equals", "(", "value", ")", "?", "new", "Boolean", "(", "\"true\"", ".", "equals", "(", "value", ")", ")", ":", "null", ";", "}", "if", "(", "toType", "==", "Integer", ".", "class", ")", "{", "try", "{", "return", "new", "Integer", "(", "value", ")", ";", "}", "catch", "(", "NumberFormatException", "e", ")", "{", "return", "null", ";", "}", "}", "else", "if", "(", "toType", "==", "Long", ".", "class", ")", "{", "try", "{", "return", "new", "Long", "(", "value", ")", ";", "}", "catch", "(", "NumberFormatException", "e", ")", "{", "return", "null", ";", "}", "}", "else", "if", "(", "toType", "==", "Float", ".", "class", ")", "{", "try", "{", "return", "new", "Float", "(", "value", ")", ";", "}", "catch", "(", "NumberFormatException", "e", ")", "{", "return", "null", ";", "}", "}", "else", "if", "(", "toType", "==", "Double", ".", "class", ")", "{", "try", "{", "return", "new", "Double", "(", "value", ")", ";", "}", "catch", "(", "NumberFormatException", "e", ")", "{", "return", "null", ";", "}", "}", "else", "if", "(", "toType", "==", "Number", ".", "class", "||", "toType", "==", "Object", ".", "class", ")", "{", "try", "{", "return", "new", "Integer", "(", "value", ")", ";", "}", "catch", "(", "NumberFormatException", "e", ")", "{", "}", "try", "{", "return", "new", "Long", "(", "value", ")", ";", "}", "catch", "(", "NumberFormatException", "e", ")", "{", "}", "try", "{", "return", "new", "Double", "(", "value", ")", ";", "}", "catch", "(", "NumberFormatException", "e", ")", "{", "return", "(", "toType", "==", "Object", ".", "class", ")", "?", "value", ":", "null", ";", "}", "}", "else", "{", "return", "null", ";", "}", "}" ]

[ "Converts", "the", "given", "HTTP", "parameter", "value", "to", "the", "requested", "type", "so", "that", "it", "can", "be", "passed", "directly", "as", "a", "template", "parameter", ".", "This", "method", "is", "called", "if", "the", "template", "that", "is", "directly", "requested", "accepts", "non", "-", "String", "parameters", "and", "the", "request", "provides", "non", "-", "null", "values", "for", "those", "parameters", ".", "The", "template", "may", "request", "an", "array", "of", "values", "for", "a", "parameter", "in", "which", "case", "this", "method", "is", "called", "not", "to", "create", "the", "array", "but", "rather", "to", "convert", "any", "elements", "put", "into", "the", "array", "." ]

[ "public", "static", "String", "replace", "(", "String", "source", ",", "String", "pattern", ",", "String", "replacement", ")", "{", "return", "replace", "(", "source", ",", "pattern", ",", "replacement", ",", "0", ")", ";", "}" ]

[ "Replaces", "all", "exact", "matches", "of", "the", "given", "pattern", "in", "the", "source", "string", "with", "the", "provided", "replacement", "." ]

[ "public", "void", "print", "(", "Object", "obj", ")", "throws", "IOException", "{", "if", "(", "mOut", "!=", "null", ")", "{", "// static Tea!", "mOut", ".", "write", "(", "toString", "(", "obj", ")", ")", ";", "}", "}" ]

[ "The", "standard", "context", "method", "implemented", "to", "write", "to", "the", "file", "." ]

[ "public", "void", "setType", "(", "Type", "type", ")", "{", "Type", "actual", "=", "Type", ".", "preserveType", "(", "this", ".", "getType", "(", ")", ",", "type", ")", ";", "mConversions", ".", "clear", "(", ")", ";", "mExceptionPossible", "=", "false", ";", "if", "(", "actual", "!=", "null", ")", "{", "// Prefer cast for initial type for correct operation of", "// setInitialType if a conversion needs to be inserted at the", "// beginning.", "mConversions", ".", "add", "(", "new", "Conversion", "(", "null", ",", "actual", ",", "true", ")", ")", ";", "}", "}" ]

[ "Sets", "the", "type", "of", "this", "expression", "clearing", "the", "conversion", "chain", "." ]

[ "public", "void", "setInitialType", "(", "Type", "type", ")", "{", "Type", "initial", "=", "getInitialType", "(", ")", ";", "Type", "actual", "=", "Type", ".", "preserveType", "(", "initial", ",", "type", ")", ";", "if", "(", "actual", "!=", "null", "&&", "!", "actual", ".", "equals", "(", "initial", ")", ")", "{", "if", "(", "initial", "==", "null", ")", "{", "setType", "(", "actual", ")", ";", "}", "else", "{", "Iterator", "<", "Conversion", ">", "it", "=", "mConversions", ".", "iterator", "(", ")", ";", "mConversions", "=", "new", "LinkedList", "<", "Conversion", ">", "(", ")", ";", "// Prefer cast for initial type for correct operation of", "// setInitialType if a conversion needs to be inserted at the", "// beginning.", "mConversions", ".", "add", "(", "new", "Conversion", "(", "null", ",", "actual", ",", "true", ")", ")", ";", "while", "(", "it", ".", "hasNext", "(", ")", ")", "{", "Conversion", "conv", "=", "(", "Conversion", ")", "it", ".", "next", "(", ")", ";", "convertTo", "(", "conv", ".", "getToType", "(", ")", ",", "conv", ".", "isCastPreferred", "(", ")", ")", ";", "}", "}", "}", "}" ]

[ "Sets", "the", "intial", "type", "in", "the", "conversion", "chain", "but", "does", "not", "clear", "the", "conversions", "." ]

[ "public", "synchronized", "Token", "peekToken", "(", ")", "throws", "IOException", "{", "if", "(", "mLookahead", ".", "empty", "(", ")", ")", "{", "return", "mLookahead", ".", "push", "(", "scanToken", "(", ")", ")", ";", "}", "else", "{", "return", "mLookahead", ".", "peek", "(", ")", ";", "}", "}" ]

[ "Returns", "EOF", "as", "the", "last", "token", "." ]

[ "private", "Token", "scanText", "(", "int", "c", ")", "throws", "IOException", "{", "// Read first character in text so that source info does not include", "// tags.", "c", "=", "mSource", ".", "read", "(", ")", ";", "int", "startLine", "=", "mSource", ".", "getLineNumber", "(", ")", ";", "int", "startPos", "=", "mSource", ".", "getStartPosition", "(", ")", ";", "int", "endPos", "=", "mSource", ".", "getEndPosition", "(", ")", ";", "StringBuilder", "buf", "=", "new", "StringBuilder", "(", "256", ")", ";", "while", "(", "c", "!=", "-", "1", ")", "{", "if", "(", "c", "==", "SourceReader", ".", "ENTER_CODE", ")", "{", "if", "(", "mEmitSpecial", ")", "{", "mLookahead", ".", "push", "(", "makeStringToken", "(", "Token", ".", "ENTER_CODE", ",", "mSource", ".", "getBeginTag", "(", ")", ")", ")", ";", "}", "break", ";", "}", "else", "if", "(", "c", "==", "SourceReader", ".", "ENTER_TEXT", ")", "{", "buf", ".", "append", "(", "mSource", ".", "getEndTag", "(", ")", ")", ";", "}", "else", "{", "buf", ".", "append", "(", "(", "char", ")", "c", ")", ";", "}", "if", "(", "mSource", ".", "peek", "(", ")", "<", "0", ")", "{", "endPos", "=", "mSource", ".", "getEndPosition", "(", ")", ";", "}", "c", "=", "mSource", ".", "read", "(", ")", ";", "}", "if", "(", "c", "==", "-", "1", ")", "{", "// If the last token in the source file is text, trim all trailing", "// whitespace from it.", "int", "length", "=", "buf", ".", "length", "(", ")", ";", "int", "i", ";", "for", "(", "i", "=", "length", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "buf", ".", "charAt", "(", "i", ")", ">", "'", "'", ")", "{", "break", ";", "}", "}", "buf", ".", "setLength", "(", "i", "+", "1", ")", ";", "}", "String", "str", "=", "buf", ".", "toString", "(", ")", ";", "return", "new", "StringToken", "(", "startLine", ",", "startPos", ",", "endPos", ",", "Token", ".", "STRING", ",", "str", ")", ";", "}" ]

[ "The", "ENTER_TEXT", "code", "has", "already", "been", "scanned", "when", "this", "is", "called", "." ]

[ "public", "static", "void", "main", "(", "String", "[", "]", "args", ")", "throws", "Exception", "{", "Map", "map", "=", "getAllProperties", "(", "Class", ".", "forName", "(", "args", "[", "0", "]", ")", ")", ";", "Iterator", "keys", "=", "map", ".", "keySet", "(", ")", ".", "iterator", "(", ")", ";", "while", "(", "keys", ".", "hasNext", "(", ")", ")", "{", "String", "key", "=", "(", "String", ")", "keys", ".", "next", "(", ")", ";", "PropertyDescriptor", "desc", "=", "(", "PropertyDescriptor", ")", "map", ".", "get", "(", "key", ")", ";", "System", ".", "out", ".", "println", "(", "key", "+", "\" = \"", "+", "desc", ")", ";", "}", "}" ]

[ "Test", "program", "." ]

[ "public", "static", "Map", "getAllProperties", "(", "Class", "clazz", ")", "throws", "IntrospectionException", "{", "synchronized", "(", "cPropertiesCache", ")", "{", "Map", "properties", ";", "Reference", "ref", "=", "(", "Reference", ")", "cPropertiesCache", ".", "get", "(", "clazz", ")", ";", "if", "(", "ref", "!=", "null", ")", "{", "properties", "=", "(", "Map", ")", "ref", ".", "get", "(", ")", ";", "if", "(", "properties", "!=", "null", ")", "{", "return", "properties", ";", "}", "else", "{", "// Clean up cleared reference.", "cPropertiesCache", ".", "remove", "(", "clazz", ")", ";", "}", "}", "properties", "=", "Collections", ".", "unmodifiableMap", "(", "createProperties", "(", "clazz", ")", ")", ";", "cPropertiesCache", ".", "put", "(", "clazz", ",", "new", "SoftReference", "(", "properties", ")", ")", ";", "return", "properties", ";", "}", "}" ]

[ "A", "function", "that", "returns", "a", "Map", "of", "all", "the", "available", "properties", "on", "a", "given", "class", "including", "write", "-", "only", "properties", ".", "The", "properties", "returned", "is", "mostly", "a", "superset", "of", "those", "returned", "from", "the", "standard", "JavaBeans", "Introspector", "except", "more", "properties", "are", "made", "available", "to", "interfaces", "." ]

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

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

[ "public", "Template", "parse", "(", ")", "throws", "IOException", "{", "Template", "t", "=", "parseTemplate", "(", ")", ";", "if", "(", "t", "!=", "null", ")", "{", "return", "t", ";", "}", "return", "new", "Template", "(", "new", "SourceInfo", "(", "0", ",", "0", ",", "0", ")", ",", "null", ",", "null", ",", "false", ",", "null", ",", "null", ")", ";", "}" ]

[ "Returns", "a", "parse", "tree", "by", "its", "root", "node", ".", "The", "parse", "tree", "is", "generated", "from", "tokens", "read", "from", "the", "scanner", ".", "Any", "errors", "encountered", "while", "parsing", "are", "delivered", "by", "dispatching", "an", "event", ".", "Add", "a", "compile", "listener", "in", "order", "to", "capture", "parse", "errors", "." ]

[ "private", "IfStatement", "parseIfStatement", "(", "Token", "token", ")", "throws", "IOException", "{", "SourceInfo", "info", "=", "token", ".", "getSourceInfo", "(", ")", ";", "Expression", "condition", "=", "parseExpression", "(", ")", ";", "if", "(", "!", "(", "condition", "instanceof", "ParenExpression", ")", ")", "{", "error", "(", "\"if.condition\"", ",", "condition", ".", "getSourceInfo", "(", ")", ")", ";", "}", "Block", "thenPart", "=", "parseBlock", "(", ")", ";", "Block", "elsePart", "=", "null", ";", "token", "=", "peek", "(", ")", ";", "if", "(", "token", ".", "getID", "(", ")", "!=", "Token", ".", "ELSE", ")", "{", "info", "=", "info", ".", "setEndPosition", "(", "thenPart", ".", "getSourceInfo", "(", ")", ")", ";", "}", "else", "{", "read", "(", ")", ";", "// read the else keyword", "token", "=", "peek", "(", ")", ";", "if", "(", "token", ".", "getID", "(", ")", "==", "Token", ".", "IF", ")", "{", "elsePart", "=", "new", "Block", "(", "parseIfStatement", "(", "read", "(", ")", ")", ")", ";", "}", "else", "{", "elsePart", "=", "parseBlock", "(", ")", ";", "}", "info", "=", "info", ".", "setEndPosition", "(", "elsePart", ".", "getSourceInfo", "(", ")", ")", ";", "}", "return", "new", "IfStatement", "(", "info", ",", "condition", ",", "thenPart", ",", "elsePart", ")", ";", "}" ]

[ "When", "this", "is", "called", "the", "keyword", "if", "has", "already", "been", "read", "." ]

[ "private", "ForeachStatement", "parseForeachStatement", "(", "Token", "token", ")", "throws", "IOException", "{", "SourceInfo", "info", "=", "token", ".", "getSourceInfo", "(", ")", ";", "token", "=", "peek", "(", ")", ";", "if", "(", "token", ".", "getID", "(", ")", "==", "Token", ".", "LPAREN", ")", "{", "read", "(", ")", ";", "}", "else", "{", "error", "(", "\"foreach.lparen.expected\"", ",", "token", ")", ";", "}", "VariableRef", "loopVar", "=", "parseLValue", "(", ")", ";", "// mod for declarative typing", "boolean", "foundASToken", "=", "false", ";", "Token", "asToken", "=", "peek", "(", ")", ";", "if", "(", "asToken", ".", "getID", "(", ")", "==", "Token", ".", "AS", ")", "{", "foundASToken", "=", "true", ";", "read", "(", ")", ";", "TypeName", "typeName", "=", "parseTypeName", "(", ")", ";", "SourceInfo", "info2", "=", "peek", "(", ")", ".", "getSourceInfo", "(", ")", ";", "loopVar", ".", "setVariable", "(", "new", "Variable", "(", "info2", ",", "loopVar", ".", "getName", "(", ")", ",", "typeName", ",", "true", ")", ")", ";", "}", "// end mod", "token", "=", "peek", "(", ")", ";", "if", "(", "token", ".", "getID", "(", ")", "==", "Token", ".", "IN", ")", "{", "read", "(", ")", ";", "}", "else", "{", "error", "(", "\"foreach.in.expected\"", ",", "token", ")", ";", "}", "Expression", "range", "=", "parseExpression", "(", ")", ";", "Expression", "endRange", "=", "null", ";", "token", "=", "peek", "(", ")", ";", "if", "(", "token", ".", "getID", "(", ")", "==", "Token", ".", "DOTDOT", ")", "{", "read", "(", ")", ";", "endRange", "=", "parseExpression", "(", ")", ";", "token", "=", "peek", "(", ")", ";", "}", "if", "(", "endRange", "!=", "null", "&&", "foundASToken", ")", "error", "(", "\"foreach.as.not.allowed\"", ",", "asToken", ")", ";", "boolean", "reverse", "=", "false", ";", "if", "(", "token", ".", "getID", "(", ")", "==", "Token", ".", "REVERSE", ")", "{", "read", "(", ")", ";", "reverse", "=", "true", ";", "token", "=", "peek", "(", ")", ";", "}", "if", "(", "token", ".", "getID", "(", ")", "==", "Token", ".", "RPAREN", ")", "{", "read", "(", ")", ";", "}", "else", "{", "error", "(", "\"foreach.rparen.expected\"", ",", "token", ")", ";", "}", "Block", "body", "=", "parseBlock", "(", ")", ";", "info", "=", "info", ".", "setEndPosition", "(", "body", ".", "getSourceInfo", "(", ")", ")", ";", "return", "new", "ForeachStatement", "(", "info", ",", "loopVar", ",", "range", ",", "endRange", ",", "reverse", ",", "body", ")", ";", "}" ]

[ "When", "this", "is", "called", "the", "keyword", "foreach", "has", "already", "been", "read", "." ]

[ "private", "AssignmentStatement", "parseAssignmentStatement", "(", "Token", "token", ")", "throws", "IOException", "{", "// TODO: allow lvalue to support dot notations", "// ie: field = x (store local variable)", "// obj.field = x (obj.setField)", "// obj.field.field = x (obj.getField().setField)", "// array[idx] = x (array[idx])", "// list[idx] = x (list.set(idx, x))", "// map[key] = x (map.put(key, x))", "// map[obj.name] = x (map.put(obj.getName(), x)", "SourceInfo", "info", "=", "token", ".", "getSourceInfo", "(", ")", ";", "VariableRef", "lvalue", "=", "parseLValue", "(", "token", ")", ";", "if", "(", "peek", "(", ")", ".", "getID", "(", ")", "==", "Token", ".", "ASSIGN", ")", "{", "read", "(", ")", ";", "}", "else", "{", "error", "(", "\"assignment.equals.expected\"", ",", "peek", "(", ")", ")", ";", "}", "Expression", "rvalue", "=", "parseExpression", "(", ")", ";", "info", "=", "info", ".", "setEndPosition", "(", "rvalue", ".", "getSourceInfo", "(", ")", ")", ";", "// Start mod for 'as' keyword for declarative typing", "if", "(", "peek", "(", ")", ".", "getID", "(", ")", "==", "Token", ".", "AS", ")", "{", "read", "(", ")", ";", "TypeName", "typeName", "=", "parseTypeName", "(", ")", ";", "SourceInfo", "info2", "=", "peek", "(", ")", ".", "getSourceInfo", "(", ")", ";", "lvalue", ".", "setVariable", "(", "new", "Variable", "(", "info2", ",", "lvalue", ".", "getName", "(", ")", ",", "typeName", ",", "true", ")", ")", ";", "}", "// End mod", "return", "new", "AssignmentStatement", "(", "info", ",", "lvalue", ",", "rvalue", ")", ";", "}" ]

[ "When", "this", "is", "called", "the", "identifier", "token", "has", "already", "been", "read", "." ]

[ "private", "FunctionCallExpression", "parseFunctionCallExpression", "(", "Token", "token", ")", "throws", "IOException", "{", "Token", "next", "=", "peek", "(", ")", ";", "if", "(", "next", ".", "getID", "(", ")", "!=", "Token", ".", "LPAREN", ")", "{", "return", "null", ";", "}", "SourceInfo", "info", "=", "token", ".", "getSourceInfo", "(", ")", ";", "Name", "target", "=", "new", "Name", "(", "info", ",", "token", ".", "getStringValue", "(", ")", ")", ";", "// parse remainder of call expression", "return", "parseCallExpression", "(", "FunctionCallExpression", ".", "class", ",", "null", ",", "target", ",", "info", ")", ";", "}" ]

[ "a", "FunctionCallExpression", ".", "Token", "passed", "in", "must", "be", "an", "identifier", "." ]

[ "public", "ConstantInfo", "getConstant", "(", "int", "index", ")", "{", "if", "(", "mIndexedConstants", "==", "null", ")", "{", "throw", "new", "ArrayIndexOutOfBoundsException", "(", "\"Constant pool indexes have not been assigned\"", ")", ";", "}", "return", "(", "ConstantInfo", ")", "mIndexedConstants", ".", "get", "(", "index", ")", ";", "}" ]

[ "Returns", "a", "constant", "from", "the", "pool", "by", "index", "or", "throws", "an", "exception", "if", "not", "found", ".", "If", "this", "constant", "pool", "has", "not", "yet", "been", "written", "or", "was", "not", "created", "by", "the", "read", "method", "indexes", "are", "not", "assigned", "." ]

[ "public", "ConstantMethodInfo", "addConstantConstructor", "(", "String", "className", ",", "TypeDesc", "[", "]", "params", ")", "{", "return", "addConstantMethod", "(", "className", ",", "\"<init>\"", ",", "null", ",", "params", ")", ";", "}" ]

[ "Get", "or", "create", "a", "constant", "from", "the", "constant", "pool", "representing", "a", "constructor", "in", "any", "class", "." ]

[ "public", "ConstantInfo", "addConstant", "(", "ConstantInfo", "constant", ")", "{", "ConstantInfo", "info", "=", "(", "ConstantInfo", ")", "mConstants", ".", "get", "(", "constant", ")", ";", "if", "(", "info", "!=", "null", ")", "{", "return", "info", ";", "}", "int", "entryCount", "=", "constant", ".", "getEntryCount", "(", ")", ";", "if", "(", "mIndexedConstants", "!=", "null", "&&", "mPreserveOrder", ")", "{", "int", "size", "=", "mIndexedConstants", ".", "size", "(", ")", ";", "mIndexedConstants", ".", "setSize", "(", "size", "+", "entryCount", ")", ";", "mIndexedConstants", ".", "set", "(", "size", ",", "constant", ")", ";", "}", "mConstants", ".", "put", "(", "constant", ",", "constant", ")", ";", "mEntries", "+=", "entryCount", ";", "return", "constant", ";", "}" ]

[ "Will", "only", "insert", "into", "the", "pool", "if", "the", "constant", "is", "not", "already", "in", "the", "pool", "." ]

[ "public", "String", "doGet", "(", "String", "host", ",", "String", "path", ",", "int", "port", ",", "Map", "<", "String", ",", "String", ">", "headers", ",", "int", "timeout", ")", "throws", "UnknownHostException", ",", "ConnectException", ",", "IOException", "{", "return", "doHttpCall", "(", "host", ",", "path", ",", "null", ",", "port", ",", "headers", ",", "timeout", ",", "false", ")", ";", "}" ]

[ "Perform", "an", "HTTP", "GET", "at", "the", "given", "path", "returning", "the", "results", "of", "the", "response", "." ]

[ "public", "String", "doSecureGet", "(", "String", "host", ",", "String", "path", ",", "int", "port", ",", "Map", "<", "String", ",", "String", ">", "headers", ",", "int", "timeout", ")", "throws", "UnknownHostException", ",", "ConnectException", ",", "IOException", "{", "return", "doHttpCall", "(", "host", ",", "path", ",", "null", ",", "port", ",", "headers", ",", "timeout", ",", "true", ")", ";", "}" ]

[ "Perform", "a", "secure", "HTTPS", "GET", "at", "the", "given", "path", "returning", "the", "results", "of", "the", "response", "." ]

[ "public", "String", "doPost", "(", "String", "host", ",", "String", "path", ",", "String", "postData", ",", "int", "port", ",", "Map", "<", "String", ",", "String", ">", "headers", ",", "int", "timeout", ")", "throws", "UnknownHostException", ",", "ConnectException", ",", "IOException", "{", "return", "doHttpCall", "(", "host", ",", "path", ",", "postData", ",", "port", ",", "headers", ",", "timeout", ",", "false", ")", ";", "}" ]

[ "Perform", "an", "HTTP", "POST", "at", "the", "given", "path", "sending", "in", "the", "given", "post", "data", "returning", "the", "results", "of", "the", "response", "." ]

[ "public", "String", "doSecurePost", "(", "String", "host", ",", "String", "path", ",", "String", "postData", ",", "int", "port", ",", "Map", "<", "String", ",", "String", ">", "headers", ",", "int", "timeout", ")", "throws", "UnknownHostException", ",", "ConnectException", ",", "IOException", "{", "return", "doHttpCall", "(", "host", ",", "path", ",", "postData", ",", "port", ",", "headers", ",", "timeout", ",", "true", ")", ";", "}" ]

[ "Perform", "a", "secure", "HTTPS", "POST", "at", "the", "given", "path", "sending", "in", "the", "given", "post", "data", "returning", "the", "results", "of", "the", "response", "." ]

[ "public", "TypeDescription", "getArrayType", "(", ")", "{", "Class", "<", "?", ">", "c", "=", "getTeaToolsUtils", "(", ")", ".", "getArrayType", "(", "mType", ")", ";", "if", "(", "mType", "==", "c", ")", "{", "return", "this", ";", "}", "return", "getTeaToolsUtils", "(", ")", ".", "createTypeDescription", "(", "c", ")", ";", "}" ]

[ "Returns", "the", "array", "type", ".", "Returns", "this", "if", "it", "is", "not", "an", "array", "type", "." ]

[ "public", "BeanInfo", "getBeanInfo", "(", ")", "{", "if", "(", "mBeanInfo", "==", "null", ")", "{", "try", "{", "mBeanInfo", "=", "getTeaToolsUtils", "(", ")", ".", "getBeanInfo", "(", "mType", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "return", "null", ";", "}", "}", "return", "mBeanInfo", ";", "}" ]

[ "Introspects", "a", "Java", "bean", "to", "learn", "about", "all", "its", "properties", "exposed", "methods", "and", "events", ".", "Returns", "null", "if", "the", "BeanInfo", "could", "not", "be", "created", "." ]

[ "public", "PropertyDescriptor", "[", "]", "getPropertyDescriptors", "(", ")", "{", "BeanInfo", "info", "=", "getBeanInfo", "(", ")", ";", "if", "(", "info", "==", "null", ")", "{", "return", "null", ";", "}", "PropertyDescriptor", "[", "]", "pds", "=", "info", ".", "getPropertyDescriptors", "(", ")", ";", "getTeaToolsUtils", "(", ")", ".", "sortPropertyDescriptors", "(", "pds", ")", ";", "return", "pds", ";", "}" ]

[ "Returns", "the", "type", "s", "PropertyDescriptors", "." ]

[ "public", "MethodDescriptor", "[", "]", "getMethodDescriptors", "(", ")", "{", "BeanInfo", "info", "=", "getBeanInfo", "(", ")", ";", "if", "(", "info", "==", "null", ")", "{", "return", "null", ";", "}", "MethodDescriptor", "[", "]", "mds", "=", "info", ".", "getMethodDescriptors", "(", ")", ";", "getTeaToolsUtils", "(", ")", ".", "sortMethodDescriptors", "(", "mds", ")", ";", "return", "mds", ";", "}" ]

[ "Returns", "the", "type", "s", "MethodDescriptors", "." ]

[ "public", "final", "static", "byte", "reverseIfOpcode", "(", "byte", "opcode", ")", "{", "// Actually, because the numbers assigned to the \"if\" opcodes", "// were so cleverly chosen, all I really need to do is toggle", "// bit 0. I'm not going to do that because I still need to check if ", "// an invalid opcode was passed in.", "switch", "(", "opcode", ")", "{", "case", "IF_ACMPEQ", ":", "return", "IF_ACMPNE", ";", "case", "IF_ACMPNE", ":", "return", "IF_ACMPEQ", ";", "case", "IF_ICMPEQ", ":", "return", "IF_ICMPNE", ";", "case", "IF_ICMPNE", ":", "return", "IF_ICMPEQ", ";", "case", "IF_ICMPLT", ":", "return", "IF_ICMPGE", ";", "case", "IF_ICMPGE", ":", "return", "IF_ICMPLT", ";", "case", "IF_ICMPGT", ":", "return", "IF_ICMPLE", ";", "case", "IF_ICMPLE", ":", "return", "IF_ICMPGT", ";", "case", "IFEQ", ":", "return", "IFNE", ";", "case", "IFNE", ":", "return", "IFEQ", ";", "case", "IFLT", ":", "return", "IFGE", ";", "case", "IFGE", ":", "return", "IFLT", ";", "case", "IFGT", ":", "return", "IFLE", ";", "case", "IFLE", ":", "return", "IFGT", ";", "case", "IFNONNULL", ":", "return", "IFNULL", ";", "case", "IFNULL", ":", "return", "IFNONNULL", ";", "default", ":", "throw", "new", "IllegalArgumentException", "(", "\"Opcode not an if instruction: \"", "+", "getMnemonic", "(", "opcode", ")", ")", ";", "}", "}" ]

[ "Reverses", "the", "condition", "for", "an", "if", "opcode", ".", "i", ".", "e", ".", "IFEQ", "is", "changed", "to", "IFNE", "." ]

[ "public", "FunctionInfo", "[", "]", "getFunctions", "(", ")", "{", "// TODO: make this a little more useful by showing more function", "// details.", "ApplicationInfo", "[", "]", "AppInf", "=", "getApplications", "(", ")", ";", "FunctionInfo", "[", "]", "funcArray", "=", "null", ";", "try", "{", "MethodDescriptor", "[", "]", "methods", "=", "Introspector", ".", "getBeanInfo", "(", "HttpContext", ".", "class", ")", ".", "getMethodDescriptors", "(", ")", ";", "List", "<", "FunctionInfo", ">", "funcList", "=", "new", "Vector", "<", "FunctionInfo", ">", "(", "50", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "methods", ".", "length", ";", "i", "++", ")", "{", "MethodDescriptor", "m", "=", "methods", "[", "i", "]", ";", "if", "(", "m", ".", "getMethod", "(", ")", ".", "getDeclaringClass", "(", ")", "!=", "Object", ".", "class", "&&", "!", "m", ".", "getMethod", "(", ")", ".", "getName", "(", ")", ".", "equals", "(", "\"print\"", ")", "&&", "!", "m", ".", "getMethod", "(", ")", ".", "getName", "(", ")", ".", "equals", "(", "\"toString\"", ")", ")", "{", "funcList", ".", "add", "(", "new", "FunctionInfo", "(", "m", ",", "null", ")", ")", ";", "}", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "AppInf", ".", "length", ";", "i", "++", ")", "{", "FunctionInfo", "[", "]", "ctxFunctions", "=", "AppInf", "[", "i", "]", ".", "getContextFunctions", "(", ")", ";", "for", "(", "int", "j", "=", "0", ";", "j", "<", "ctxFunctions", ".", "length", ";", "j", "++", ")", "{", "funcList", ".", "add", "(", "ctxFunctions", "[", "j", "]", ")", ";", "}", "}", "funcArray", "=", "funcList", ".", "toArray", "(", "new", "FunctionInfo", "[", "funcList", ".", "size", "(", ")", "]", ")", ";", "Arrays", ".", "sort", "(", "funcArray", ")", ";", "}", "catch", "(", "Exception", "ie", ")", "{", "ie", ".", "printStackTrace", "(", ")", ";", "}", "return", "funcArray", ";", "}" ]

[ "Returns", "information", "about", "all", "functions", "available", "to", "the", "templates", "." ]

[ "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "public", "TemplateWrapper", "[", "]", "getKnownTemplates", "(", ")", "{", "if", "(", "mTemplateOrdering", "==", "null", ")", "{", "setTemplateOrdering", "(", "\"name\"", ")", ";", "}", "Comparator", "<", "TemplateWrapper", ">", "comparator", "=", "BeanComparator", ".", "forClass", "(", "TemplateWrapper", ".", "class", ")", ".", "orderBy", "(", "\"name\"", ")", ";", "Set", "<", "TemplateWrapper", ">", "known", "=", "new", "TreeSet", "<", "TemplateWrapper", ">", "(", "comparator", ")", ";", "TemplateLoader", ".", "Template", "[", "]", "loaded", "=", "mTeaServletEngine", ".", "getTemplateSource", "(", ")", ".", "getLoadedTemplates", "(", ")", ";", "if", "(", "loaded", "!=", "null", ")", "{", "for", "(", "int", "j", "=", "0", ";", "j", "<", "loaded", ".", "length", ";", "j", "++", ")", "{", "TeaServletAdmin", ".", "TemplateWrapper", "wrapper", "=", "new", "TemplateWrapper", "(", "loaded", "[", "j", "]", ",", "TeaServletInvocationStats", ".", "getInstance", "(", ")", ".", "getStatistics", "(", "loaded", "[", "j", "]", ".", "getName", "(", ")", ",", "null", ")", ",", "TeaServletInvocationStats", ".", "getInstance", "(", ")", ".", "getStatistics", "(", "loaded", "[", "j", "]", ".", "getName", "(", ")", ",", "\"__substitution\"", ")", ",", "TeaServletRequestStats", ".", "getInstance", "(", ")", ".", "getStats", "(", "loaded", "[", "j", "]", ".", "getName", "(", ")", ")", ")", ";", "try", "{", "known", ".", "add", "(", "wrapper", ")", ";", "}", "catch", "(", "ClassCastException", "cce", ")", "{", "mTeaServletEngine", ".", "getLog", "(", ")", ".", "warn", "(", "cce", ")", ";", "}", "}", "}", "String", "[", "]", "allNames", "=", "mTeaServletEngine", ".", "getTemplateSource", "(", ")", ".", "getKnownTemplateNames", "(", ")", ";", "if", "(", "allNames", "!=", "null", ")", "{", "for", "(", "int", "j", "=", "0", ";", "j", "<", "allNames", ".", "length", ";", "j", "++", ")", "{", "TeaServletAdmin", ".", "TemplateWrapper", "wrapper", "=", "new", "TemplateWrapper", "(", "allNames", "[", "j", "]", ",", "TeaServletInvocationStats", ".", "getInstance", "(", ")", ".", "getStatistics", "(", "allNames", "[", "j", "]", ",", "null", ")", ",", "TeaServletInvocationStats", ".", "getInstance", "(", ")", ".", "getStatistics", "(", "allNames", "[", "j", "]", ",", "\"__substitution\"", ")", ",", "TeaServletRequestStats", ".", "getInstance", "(", ")", ".", "getStats", "(", "allNames", "[", "j", "]", ")", ")", ";", "try", "{", "known", ".", "add", "(", "wrapper", ")", ";", "}", "catch", "(", "ClassCastException", "cce", ")", "{", "mTeaServletEngine", ".", "getLog", "(", ")", ".", "warn", "(", "cce", ")", ";", "}", "}", "}", "List", "<", "TemplateWrapper", ">", "v", "=", "new", "ArrayList", "<", "TemplateWrapper", ">", "(", "known", ")", ";", "Collections", ".", "sort", "(", "v", ",", "mTemplateOrdering", ")", ";", "// return (TeaServletAdmin.TemplateWrapper[])known.toArray(new TemplateWrapper[known.size()]);", "return", "v", ".", "toArray", "(", "new", "TemplateWrapper", "[", "v", ".", "size", "(", ")", "]", ")", ";", "}" ]

[ "Provides", "an", "ordered", "array", "of", "available", "templates", "using", "a", "handy", "wrapper", "class", "." ]

[ "private", "HttpClient", "getTemplateServerClient", "(", "String", "remoteSource", ")", "throws", "IOException", "{", "// TODO: this was copied from the RemoteCompiler class. This needs", "// to be moved into a location where both can access it!", "int", "port", "=", "80", ";", "String", "host", "=", "remoteSource", ".", "substring", "(", "RemoteCompilationProvider", ".", "TEMPLATE_LOAD_PROTOCOL", ".", "length", "(", ")", ")", ";", "int", "portIndex", "=", "host", ".", "indexOf", "(", "\"/\"", ")", ";", "if", "(", "portIndex", ">=", "0", ")", "{", "host", "=", "host", ".", "substring", "(", "0", ",", "portIndex", ")", ";", "}", "portIndex", "=", "host", ".", "indexOf", "(", "\":\"", ")", ";", "if", "(", "portIndex", ">=", "0", ")", "{", "try", "{", "port", "=", "Integer", ".", "parseInt", "(", "host", ".", "substring", "(", "portIndex", "+", "1", ")", ")", ";", "}", "catch", "(", "NumberFormatException", "nfe", ")", "{", "System", ".", "out", ".", "println", "(", "\"Invalid port number specified\"", ")", ";", "}", "host", "=", "host", ".", "substring", "(", "0", ",", "portIndex", ")", ";", "}", "// TODO: remove the hardcoded 15 second timeout!", "SocketFactory", "factory", "=", "new", "PooledSocketFactory", "(", "new", "PlainSocketFactory", "(", "InetAddress", ".", "getByName", "(", "host", ")", ",", "port", ",", "15000", ")", ")", ";", "return", "new", "HttpClient", "(", "factory", ")", ";", "}" ]

[ "returns", "a", "socket", "connected", "to", "a", "host", "running", "the", "TemplateServerServlet" ]

[ "private", "static", "InetAddress", "[", "]", "getAllLocalInetAddresses", "(", "final", "Log", "log", ")", "throws", "SocketException", "{", "final", "List", "addresses", "=", "new", "ArrayList", "(", ")", ";", "// get the network adapters", "final", "Enumeration", "netInterfaces", "=", "NetworkInterface", ".", "getNetworkInterfaces", "(", ")", ";", "while", "(", "netInterfaces", ".", "hasMoreElements", "(", ")", ")", "{", "final", "NetworkInterface", "ni", "=", "(", "NetworkInterface", ")", "netInterfaces", ".", "nextElement", "(", ")", ";", "if", "(", "log", "!=", "null", ")", "{", "log", ".", "debug", "(", "\"Found interface: \"", "+", "ni", ".", "getName", "(", ")", ")", ";", "}", "// get the IPs for this network interface", "final", "Enumeration", "ips", "=", "ni", ".", "getInetAddresses", "(", ")", ";", "while", "(", "ips", ".", "hasMoreElements", "(", ")", ")", "{", "final", "InetAddress", "ip", "=", "(", "InetAddress", ")", "ips", ".", "nextElement", "(", ")", ";", "if", "(", "log", "!=", "null", ")", "{", "log", ".", "debug", "(", "\"Found ip: \"", "+", "ip", ".", "getHostName", "(", ")", "+", "\"/\"", "+", "ip", ".", "getHostAddress", "(", ")", "+", "\" on interface: \"", "+", "ni", ".", "getName", "(", ")", ")", ";", "}", "// ignore the local loopback address: 127.0.0.1", "if", "(", "!", "ip", ".", "isLoopbackAddress", "(", ")", ")", "{", "if", "(", "log", "!=", "null", ")", "{", "log", ".", "debug", "(", "\"Let's add this IP: \"", "+", "ip", ".", "getCanonicalHostName", "(", ")", ")", ";", "}", "addresses", ".", "add", "(", "ip", ")", ";", "}", "}", "}", "return", "(", "InetAddress", "[", "]", ")", "addresses", ".", "toArray", "(", "new", "InetAddress", "[", "addresses", ".", "size", "(", ")", "]", ")", ";", "}" ]

[ "calling", "getHostName", "returns", "the", "IP", ".", "how", "do", "we", "get", "the", "host?" ]

[ "public", "LogEvent", "[", "]", "getLogEvents", "(", ")", "{", "if", "(", "mLogEvents", "==", "null", ")", "{", "return", "new", "LogEvent", "[", "0", "]", ";", "}", "else", "{", "LogEvent", "[", "]", "events", "=", "new", "LogEvent", "[", "mLogEvents", ".", "size", "(", ")", "]", ";", "return", "(", "LogEvent", "[", "]", ")", "mLogEvents", ".", "toArray", "(", "events", ")", ";", "}", "}" ]

[ "Returns", "the", "lines", "that", "have", "been", "written", "to", "the", "log", "file", ".", "This", "is", "used", "by", "the", "admin", "functions", "." ]

[ "public", "Template", "findTemplate", "(", "String", "uri", ",", "HttpServletRequest", "request", ",", "HttpServletResponse", "response", ")", "throws", "ServletException", ",", "IOException", "{", "return", "findTemplate", "(", "uri", ",", "request", ",", "response", ",", "getTemplateSource", "(", ")", ")", ";", "}" ]

[ "Finds", "a", "template", "based", "on", "the", "given", "URI", ".", "If", "path", "ends", "in", "a", "slash", "revert", "to", "loading", "default", "template", ".", "If", "default", "not", "found", "or", "not", "specified", "return", "null", "." ]

[ "public", "HttpContext", "createHttpContext", "(", "ApplicationRequest", "req", ",", "ApplicationResponse", "resp", ")", "throws", "Exception", "{", "Template", "template", "=", "(", "Template", ")", "req", ".", "getTemplate", "(", ")", ";", "return", "createHttpContext", "(", "req", ",", "resp", ",", "template", ".", "getTemplateSource", "(", ")", ".", "getContextSource", "(", ")", ")", ";", "}" ]

[ "Lets", "external", "classes", "use", "the", "HttpContext", "for", "their", "own", "possibly", "malicious", "purposes", "." ]

[ "private", "TeaServletTemplateSource", "createTemplateSource", "(", "ContextSource", "contextSource", ")", "{", "return", "TeaServletTemplateSource", ".", "createTemplateSource", "(", "getServletContext", "(", ")", ",", "(", "TeaServletContextSource", ")", "contextSource", ",", "getProperties", "(", ")", ".", "subMap", "(", "\"template\"", ")", ",", "getLog", "(", ")", ")", ";", "}" ]

[ "Create", "a", "template", "source", "using", "the", "composite", "context", "passed", "to", "the", "method", "." ]

[ "public", "synchronized", "Object", "put", "(", "Object", "obj", ")", "{", "// This implementation is based on the IdentityMap.put method.", "if", "(", "obj", "==", "null", ")", "{", "return", "null", ";", "}", "Entry", "tab", "[", "]", "=", "mTable", ";", "int", "hash", "=", "hashCode", "(", "obj", ")", ";", "int", "index", "=", "(", "hash", "&", "0x7FFFFFFF", ")", "%", "tab", ".", "length", ";", "for", "(", "Entry", "e", "=", "tab", "[", "index", "]", ",", "prev", "=", "null", ";", "e", "!=", "null", ";", "e", "=", "e", ".", "mNext", ")", "{", "Object", "iobj", "=", "e", ".", "get", "(", ")", ";", "if", "(", "iobj", "==", "null", ")", "{", "// Clean up after a cleared Reference.", "if", "(", "prev", "!=", "null", ")", "{", "prev", ".", "mNext", "=", "e", ".", "mNext", ";", "}", "else", "{", "tab", "[", "index", "]", "=", "e", ".", "mNext", ";", "}", "mCount", "--", ";", "}", "else", "if", "(", "e", ".", "mHash", "==", "hash", "&&", "obj", ".", "getClass", "(", ")", "==", "iobj", ".", "getClass", "(", ")", "&&", "equals", "(", "obj", ",", "iobj", ")", ")", "{", "// Found flyweight instance.", "return", "iobj", ";", "}", "else", "{", "prev", "=", "e", ";", "}", "}", "if", "(", "mCount", ">=", "mThreshold", ")", "{", "// Cleanup the table if the threshold is exceeded.", "cleanup", "(", ")", ";", "}", "if", "(", "mCount", ">=", "mThreshold", ")", "{", "// Rehash the table if the threshold is still exceeded.", "rehash", "(", ")", ";", "tab", "=", "mTable", ";", "index", "=", "(", "hash", "&", "0x7FFFFFFF", ")", "%", "tab", ".", "length", ";", "}", "// Create a new entry.", "tab", "[", "index", "]", "=", "new", "Entry", "(", "obj", ",", "hash", ",", "tab", "[", "index", "]", ")", ";", "mCount", "++", ";", "return", "obj", ";", "}" ]

[ "Pass", "in", "a", "candidate", "flyweight", "object", "and", "get", "a", "unique", "instance", "from", "this", "set", ".", "The", "returned", "object", "will", "always", "be", "of", "the", "same", "type", "as", "that", "passed", "in", ".", "If", "the", "object", "passed", "in", "does", "not", "equal", "any", "object", "currently", "in", "the", "set", "it", "will", "be", "added", "to", "the", "set", "becoming", "a", "flyweight", "." ]

[ "private", "String", "printTeaStackTraceLines", "(", "TeaStackTraceLine", "[", "]", "lines", ")", "{", "String", "result", "=", "\"\"", ";", "for", "(", "int", "line", "=", "0", ";", "line", "<", "lines", ".", "length", ";", "line", "++", ")", "{", "if", "(", "line", ">", "0", ")", "{", "result", "+=", "'", "'", ";", "}", "result", "+=", "lines", "[", "line", "]", ".", "toString", "(", ")", ";", "}", "return", "result", ";", "}" ]

[ "Prints", "the", "stack", "trace", "lines", "to", "a", "String", "." ]

[ "private", "TeaStackTraceLine", "[", "]", "getTeaStackTraceLines", "(", "Throwable", "t", ")", "{", "// grab the existing stack trace", "StringWriter", "stackTraceGrabber", "=", "new", "StringWriter", "(", ")", ";", "t", ".", "printStackTrace", "(", "new", "PrintWriter", "(", "stackTraceGrabber", ")", ")", ";", "String", "stackTrace", "=", "stackTraceGrabber", ".", "toString", "(", ")", ";", "int", "extensionIndex", "=", "stackTrace", ".", "lastIndexOf", "(", "TEA_EXCEPTION", ")", ";", "boolean", "isTeaException", "=", "extensionIndex", "!=", "-", "1", ";", "if", "(", "isTeaException", ")", "{", "// trim off all lines after the last template exception", "int", "endIndex", "=", "stackTrace", ".", "indexOf", "(", "'", "'", ",", "extensionIndex", ")", ";", "int", "endRIndex", "=", "stackTrace", ".", "indexOf", "(", "'", "'", ",", "extensionIndex", ")", ";", "if", "(", "endRIndex", ">", "-", "1", "&&", "endRIndex", "<", "endIndex", ")", "endIndex", "=", "endRIndex", ";", "if", "(", "endIndex", "<=", "0", ")", "{", "endIndex", "=", "stackTrace", ".", "length", "(", ")", ";", "}", "stackTrace", "=", "stackTrace", ".", "substring", "(", "0", ",", "endIndex", ")", ";", "// parse each line", "List", "<", "TeaStackTraceLine", ">", "teaStackTraceLines", "=", "new", "ArrayList", "<", "TeaStackTraceLine", ">", "(", ")", ";", "StringTokenizer", "tokenizer", "=", "new", "StringTokenizer", "(", "stackTrace", ",", "\"\\n\"", ")", ";", "while", "(", "tokenizer", ".", "hasMoreElements", "(", ")", ")", "{", "String", "line", "=", "(", "String", ")", "tokenizer", ".", "nextElement", "(", ")", ";", "if", "(", "line", ".", "indexOf", "(", "TEA_EXCEPTION", ")", "!=", "-", "1", ")", "{", "/*\n TODO: make sure this works for lines that don't have\n line numbers. Look in ESPN logs for examples.\n at org.teatrove.teaservlet.template.schedule.substitute(schedule.tea:78)\n at org.teatrove.teaservlet.template.shell.story.frame.substitute(shell/story/frame.tea)\n */", "String", "tempLine", "=", "line", ";", "int", "bracket", "=", "tempLine", ".", "indexOf", "(", "'", "'", ")", ";", "tempLine", "=", "tempLine", ".", "substring", "(", "bracket", "+", "1", ")", ";", "bracket", "=", "tempLine", ".", "indexOf", "(", "'", "'", ")", ";", "tempLine", "=", "tempLine", ".", "substring", "(", "0", ",", "bracket", ")", ";", "int", "colonIndex", "=", "tempLine", ".", "indexOf", "(", "'", "'", ")", ";", "String", "templateName", "=", "null", ";", "Integer", "lineNumber", "=", "null", ";", "if", "(", "colonIndex", ">=", "0", ")", "{", "templateName", "=", "tempLine", ".", "substring", "(", "0", ",", "colonIndex", ")", ";", "try", "{", "lineNumber", "=", "new", "Integer", "(", "tempLine", ".", "substring", "(", "colonIndex", "+", "1", ")", ")", ";", "}", "catch", "(", "NumberFormatException", "nfe", ")", "{", "lineNumber", "=", "null", ";", "}", "}", "else", "{", "templateName", "=", "tempLine", ";", "lineNumber", "=", "null", ";", "}", "teaStackTraceLines", ".", "add", "(", "new", "TeaStackTraceLine", "(", "templateName", ",", "lineNumber", ",", "line", ")", ")", ";", "}", "else", "{", "teaStackTraceLines", ".", "add", "(", "new", "TeaStackTraceLine", "(", "null", ",", "null", ",", "line", ")", ")", ";", "}", "}", "return", "(", "TeaStackTraceLine", "[", "]", ")", "teaStackTraceLines", ".", "toArray", "(", "new", "TeaStackTraceLine", "[", "teaStackTraceLines", ".", "size", "(", ")", "]", ")", ";", "}", "else", "{", "return", "null", ";", "}", "}" ]

[ "Splits", "the", "stack", "trace", "into", "separate", "lines", "and", "extracts", "the", "template", "name", "and", "line", "number", "." ]

[ "public", "String", "getName", "(", ")", "{", "String", "name", "=", "super", ".", "getName", "(", ")", ";", "if", "(", "name", "!=", "null", ")", "{", "if", "(", "name", ".", "equals", "(", "getParameterDescriptor", "(", ")", ".", "getDisplayName", "(", ")", ")", "||", "name", ".", "length", "(", ")", "==", "0", ")", "{", "name", "=", "null", ";", "}", "}", "return", "name", ";", "}" ]

[ "Returns", "the", "formal", "param", "name", "or", "null", "if", "the", "formal", "name", "is", "not", "available", "." ]

[ "static", "ConstantNameAndTypeInfo", "make", "(", "ConstantPool", "cp", ",", "String", "name", ",", "Descriptor", "type", ")", "{", "ConstantInfo", "ci", "=", "new", "ConstantNameAndTypeInfo", "(", "cp", ",", "name", ",", "type", ")", ";", "return", "(", "ConstantNameAndTypeInfo", ")", "cp", ".", "addConstant", "(", "ci", ")", ";", "}" ]

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

[ "public", "TypeDescription", "getReturnType", "(", ")", "{", "if", "(", "mReturnType", "==", "null", ")", "{", "mReturnType", "=", "getTeaToolsUtils", "(", ")", ".", "createTypeDescription", "(", "getMethod", "(", ")", ".", "getReturnType", "(", ")", ")", ";", "}", "return", "mReturnType", ";", "}" ]

[ "Returns", "the", "method", "s", "return", "type" ]

[ "public", "<", "T", ">", "void", "add", "(", "List", "<", "T", ">", "list", ",", "int", "index", ",", "T", "value", ")", "{", "list", ".", "add", "(", "index", ",", "value", ")", ";", "}" ]

[ "Insert", "the", "given", "value", "to", "the", "given", "list", "at", "the", "given", "index", ".", "This", "will", "insert", "the", "value", "at", "the", "index", "shifting", "the", "elements", "accordingly", "." ]

[ "public", "<", "T", ">", "boolean", "addAll", "(", "List", "<", "T", ">", "listToAddTo", ",", "Collection", "<", "?", "extends", "T", ">", "collectionToAdd", ")", "{", "return", "listToAddTo", ".", "addAll", "(", "collectionToAdd", ")", ";", "}" ]

[ "Add", "all", "items", "of", "the", "given", "collection", "to", "the", "given", "list", "." ]

[ "public", "<", "T", ">", "T", "set", "(", "List", "<", "T", ">", "list", ",", "int", "index", ",", "T", "obj", ")", "{", "return", "list", ".", "set", "(", "index", ",", "obj", ")", ";", "}" ]

[ "Set", "the", "value", "at", "the", "given", "index", "in", "the", "given", "list", ".", "If", "the", "value", "is", "properly", "set", "the", "previous", "value", "will", "be", "returned", "." ]

[ "public", "<", "T", ">", "List", "<", "T", ">", "subList", "(", "List", "<", "T", ">", "list", ",", "int", "fromIndex", ",", "int", "toIndex", ")", "{", "return", "list", ".", "subList", "(", "fromIndex", ",", "toIndex", ")", ";", "}" ]

[ "Get", "a", "portion", "of", "the", "given", "list", "as", "a", "new", "list", "." ]

[ "public", "Object", "[", "]", "toArray", "(", "List", "<", "?", ">", "list", ",", "Class", "<", "?", ">", "arrayType", ")", "{", "int", "[", "]", "dims", "=", "findArrayDimensions", "(", "list", ",", "arrayType", ")", ";", "Object", "[", "]", "typedArray", "=", "(", "Object", "[", "]", ")", "Array", ".", "newInstance", "(", "arrayType", ",", "dims", ")", ";", "return", "list", ".", "toArray", "(", "typedArray", ")", ";", "}" ]

[ "Convert", "the", "given", "list", "to", "an", "array", "of", "the", "given", "array", "type", "." ]

[ "public", "void", "addPlugin", "(", "Plugin", "plugin", ")", "{", "if", "(", "!", "mPluginMap", ".", "containsKey", "(", "plugin", ".", "getName", "(", ")", ")", ")", "{", "mPluginMap", ".", "put", "(", "plugin", ".", "getName", "(", ")", ",", "plugin", ")", ";", "PluginEvent", "event", "=", "new", "PluginEvent", "(", "this", ",", "plugin", ")", ";", "firePluginAddedEvent", "(", "event", ")", ";", "}", "}" ]

[ "Adds", "a", "Plugin", "to", "the", "PluginContext", ".", "Plugins", "that", "want", "to", "make", "themselves", "available", "to", "other", "Plugins", "should", "add", "themselves", "to", "the", "PluginContext", "through", "this", "method", ".", "All", "PluginListeners", "will", "be", "notified", "of", "the", "new", "addition", "." ]

[ "public", "static", "int", "findReservedWordID", "(", "StringBuilder", "word", ")", "{", "char", "c", "=", "word", ".", "charAt", "(", "0", ")", ";", "switch", "(", "c", ")", "{", "case", "'", "'", ":", "if", "(", "matches", "(", "word", ",", "\"and\"", ")", ")", "return", "AND", ";", "if", "(", "matches", "(", "word", ",", "\"as\"", ")", ")", "return", "AS", ";", "break", ";", "case", "'", "'", ":", "if", "(", "matches", "(", "word", ",", "\"break\"", ")", ")", "return", "BREAK", ";", "break", ";", "case", "'", "'", ":", "if", "(", "matches", "(", "word", ",", "\"call\"", ")", ")", "return", "CALL", ";", "if", "(", "matches", "(", "word", ",", "\"class___\"", ")", ")", "return", "CLASS", ";", "if", "(", "matches", "(", "word", ",", "\"continue\"", ")", ")", "return", "CONTINUE", ";", "break", ";", "case", "'", "'", ":", "if", "(", "matches", "(", "word", ",", "\"define\"", ")", ")", "return", "DEFINE", ";", "break", ";", "case", "'", "'", ":", "if", "(", "matches", "(", "word", ",", "\"else\"", ")", ")", "return", "ELSE", ";", "break", ";", "case", "'", "'", ":", "if", "(", "matches", "(", "word", ",", "\"foreach\"", ")", ")", "return", "FOREACH", ";", "if", "(", "matches", "(", "word", ",", "\"false\"", ")", ")", "return", "FALSE", ";", "break", ";", "case", "'", "'", ":", "if", "(", "matches", "(", "word", ",", "\"if\"", ")", ")", "return", "IF", ";", "if", "(", "matches", "(", "word", ",", "\"import\"", ")", ")", "return", "IMPORT", ";", "if", "(", "matches", "(", "word", ",", "\"in\"", ")", ")", "return", "IN", ";", "if", "(", "matches", "(", "word", ",", "\"isa\"", ")", ")", "return", "ISA", ";", "break", ";", "case", "'", "'", ":", "if", "(", "matches", "(", "word", ",", "\"null\"", ")", ")", "return", "NULL", ";", "if", "(", "matches", "(", "word", ",", "\"not\"", ")", ")", "return", "NOT", ";", "break", ";", "case", "'", "'", ":", "if", "(", "matches", "(", "word", ",", "\"or\"", ")", ")", "return", "OR", ";", "break", ";", "case", "'", "'", ":", "if", "(", "matches", "(", "word", ",", "\"reverse\"", ")", ")", "return", "REVERSE", ";", "break", ";", "case", "'", "'", ":", "if", "(", "matches", "(", "word", ",", "\"true\"", ")", ")", "return", "TRUE", ";", "if", "(", "matches", "(", "word", ",", "\"template\"", ")", ")", "return", "TEMPLATE", ";", "break", ";", "}", "return", "UNKNOWN", ";", "}" ]

[ "If", "the", "given", "StringBuilder", "starts", "with", "a", "valid", "token", "type", "its", "ID", "is", "returned", ".", "Otherwise", "the", "token", "ID", "UNKNOWN", "is", "returned", "." ]

[ "private", "static", "boolean", "matches", "(", "StringBuilder", "word", ",", "String", "val", ")", "{", "int", "len", "=", "word", ".", "length", "(", ")", ";", "if", "(", "len", "!=", "val", ".", "length", "(", ")", ")", "return", "false", ";", "// Start at index 1, assuming that the first characters have already", "// been checked to match.", "for", "(", "int", "index", "=", "1", ";", "index", "<", "len", ";", "index", "++", ")", "{", "char", "cw", "=", "word", ".", "charAt", "(", "index", ")", ";", "char", "cv", "=", "val", ".", "charAt", "(", "index", ")", ";", "if", "(", "cw", "!=", "cv", ")", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}" ]

[ "Case", "sensitive", "match", "test", "." ]

[ "public", "final", "void", "dump", "(", "PrintStream", "out", ")", "{", "out", ".", "println", "(", "\"Token [Code: \"", "+", "getCode", "(", ")", "+", "\"] [Image: \"", "+", "getImage", "(", ")", "+", "\"] [Value: \"", "+", "getStringValue", "(", ")", "+", "\"] [Id: \"", "+", "getID", "(", ")", "+", "\"] [start: \"", "+", "mInfo", ".", "getStartPosition", "(", ")", "+", "\"] [end \"", "+", "mInfo", ".", "getEndPosition", "(", ")", "+", "\"]\"", ")", ";", "}" ]

[ "Dumps", "the", "contents", "of", "this", "Token", "." ]

[ "public", "byte", "[", "]", "digest", "(", "String", "algorithm", ",", "byte", "[", "]", "bytes", ")", "{", "try", "{", "MessageDigest", "md", "=", "MessageDigest", ".", "getInstance", "(", "algorithm", ")", ";", "return", "md", ".", "digest", "(", "bytes", ")", ";", "}", "catch", "(", "NoSuchAlgorithmException", "exception", ")", "{", "throw", "new", "IllegalStateException", "(", "\"unable to access MD5 algorithm\"", ",", "exception", ")", ";", "}", "}" ]

[ "Generates", "a", "digest", "based", "on", "the", "given", "algorithm", "." ]

[ "public", "String", "md5HexDigest", "(", "String", "signature", ")", "{", "byte", "[", "]", "bytes", "=", "md5Digest", "(", "signature", ".", "getBytes", "(", ")", ")", ";", "return", "new", "String", "(", "Hex", ".", "encodeHex", "(", "bytes", ")", ")", ";", "}" ]

[ "Creates", "a", "MD5", "digest", "of", "the", "given", "signature", "and", "returns", "the", "result", "as", "a", "hex", "-", "encoded", "string", "." ]

[ "public", "String", "md5Base64Digest", "(", "String", "signature", ")", "{", "byte", "[", "]", "bytes", "=", "md5Digest", "(", "signature", ".", "getBytes", "(", ")", ")", ";", "return", "new", "String", "(", "Base64", ".", "encodeBase64", "(", "bytes", ")", ")", ";", "}" ]

[ "Creates", "a", "MD5", "digest", "of", "the", "given", "signature", "and", "returns", "the", "result", "as", "a", "Base64", "-", "encoded", "string", "." ]

[ "static", "ConstantInterfaceMethodInfo", "make", "(", "ConstantPool", "cp", ",", "ConstantClassInfo", "parentClass", ",", "ConstantNameAndTypeInfo", "nameAndType", ")", "{", "ConstantInfo", "ci", "=", "new", "ConstantInterfaceMethodInfo", "(", "parentClass", ",", "nameAndType", ")", ";", "return", "(", "ConstantInterfaceMethodInfo", ")", "cp", ".", "addConstant", "(", "ci", ")", ";", "}" ]

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

[ "static", "ConstantStringInfo", "make", "(", "ConstantPool", "cp", ",", "String", "str", ")", "{", "ConstantInfo", "ci", "=", "new", "ConstantStringInfo", "(", "cp", ",", "str", ")", ";", "return", "(", "ConstantStringInfo", ")", "cp", ".", "addConstant", "(", "ci", ")", ";", "}" ]

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

[ "public", "static", "int", "setPublic", "(", "int", "modifier", ",", "boolean", "b", ")", "{", "if", "(", "b", ")", "{", "return", "(", "modifier", "|", "PUBLIC", ")", "&", "(", "~", "PROTECTED", "&", "~", "PRIVATE", ")", ";", "}", "else", "{", "return", "modifier", "&", "~", "PUBLIC", ";", "}", "}" ]

[ "When", "set", "public", "the", "modifier", "is", "cleared", "from", "being", "private", "or", "protected", "." ]

[ "public", "static", "int", "setPrivate", "(", "int", "modifier", ",", "boolean", "b", ")", "{", "if", "(", "b", ")", "{", "return", "(", "modifier", "|", "PRIVATE", ")", "&", "(", "~", "PUBLIC", "&", "~", "PROTECTED", ")", ";", "}", "else", "{", "return", "modifier", "&", "~", "PRIVATE", ";", "}", "}" ]

[ "When", "set", "private", "the", "modifier", "is", "cleared", "from", "being", "public", "or", "protected", "." ]

[ "public", "static", "int", "setProtected", "(", "int", "modifier", ",", "boolean", "b", ")", "{", "if", "(", "b", ")", "{", "return", "(", "modifier", "|", "PROTECTED", ")", "&", "(", "~", "PUBLIC", "&", "~", "PRIVATE", ")", ";", "}", "else", "{", "return", "modifier", "&", "~", "PROTECTED", ";", "}", "}" ]

[ "When", "set", "protected", "the", "modifier", "is", "cleared", "from", "being", "public", "or", "private", "." ]

[ "public", "static", "int", "setFinal", "(", "int", "modifier", ",", "boolean", "b", ")", "{", "if", "(", "b", ")", "{", "return", "(", "modifier", "|", "FINAL", ")", "&", "(", "~", "INTERFACE", "&", "~", "ABSTRACT", ")", ";", "}", "else", "{", "return", "modifier", "&", "~", "FINAL", ";", "}", "}" ]

[ "When", "set", "final", "the", "modifier", "is", "cleared", "from", "being", "an", "interface", "or", "abstract", "." ]

[ "public", "static", "int", "setSynchronized", "(", "int", "modifier", ",", "boolean", "b", ")", "{", "if", "(", "b", ")", "{", "return", "(", "modifier", "|", "SYNCHRONIZED", ")", "&", "(", "~", "VOLATILE", "&", "~", "TRANSIENT", "&", "~", "INTERFACE", ")", ";", "}", "else", "{", "return", "modifier", "&", "~", "SYNCHRONIZED", ";", "}", "}" ]

[ "When", "set", "synchronized", "non", "-", "method", "settings", "are", "cleared", "." ]

[ "public", "static", "int", "setVolatile", "(", "int", "modifier", ",", "boolean", "b", ")", "{", "if", "(", "b", ")", "{", "return", "(", "modifier", "|", "VOLATILE", ")", "&", "(", "~", "SYNCHRONIZED", "&", "~", "NATIVE", "&", "~", "INTERFACE", "&", "~", "ABSTRACT", "&", "~", "STRICT", ")", ";", "}", "else", "{", "return", "modifier", "&", "~", "VOLATILE", ";", "}", "}" ]

[ "When", "set", "volatile", "non", "-", "field", "settings", "are", "cleared", "." ]

[ "public", "static", "int", "setTransient", "(", "int", "modifier", ",", "boolean", "b", ")", "{", "if", "(", "b", ")", "{", "return", "(", "modifier", "|", "TRANSIENT", ")", "&", "(", "~", "SYNCHRONIZED", "&", "~", "NATIVE", "&", "~", "INTERFACE", "&", "~", "ABSTRACT", "&", "~", "STRICT", ")", ";", "}", "else", "{", "return", "modifier", "&", "~", "TRANSIENT", ";", "}", "}" ]

[ "When", "set", "transient", "non", "-", "field", "settings", "are", "cleared", "." ]

[ "public", "static", "int", "setNative", "(", "int", "modifier", ",", "boolean", "b", ")", "{", "if", "(", "b", ")", "{", "return", "(", "modifier", "|", "NATIVE", ")", "&", "(", "~", "VOLATILE", "&", "~", "TRANSIENT", "&", "~", "INTERFACE", "&", "~", "ABSTRACT", "&", "~", "STRICT", ")", ";", "}", "else", "{", "return", "modifier", "&", "~", "NATIVE", ";", "}", "}" ]

[ "When", "set", "native", "non", "-", "native", "-", "method", "settings", "are", "cleared", "." ]

[ "public", "static", "int", "setInterface", "(", "int", "modifier", ",", "boolean", "b", ")", "{", "if", "(", "b", ")", "{", "return", "(", "modifier", "|", "(", "INTERFACE", "|", "ABSTRACT", ")", ")", "&", "(", "~", "FINAL", "&", "~", "SYNCHRONIZED", "&", "~", "VOLATILE", "&", "~", "TRANSIENT", "&", "~", "NATIVE", ")", ";", "}", "else", "{", "return", "modifier", "&", "~", "INTERFACE", ";", "}", "}" ]

[ "When", "set", "as", "an", "interface", "non", "-", "interface", "settings", "are", "cleared", "and", "the", "modifier", "is", "set", "abstract", "." ]

[ "public", "static", "int", "setAbstract", "(", "int", "modifier", ",", "boolean", "b", ")", "{", "if", "(", "b", ")", "{", "return", "(", "modifier", "|", "ABSTRACT", ")", "&", "(", "~", "FINAL", "&", "~", "VOLATILE", "&", "~", "TRANSIENT", "&", "~", "NATIVE", "&", "~", "SYNCHRONIZED", "&", "~", "STRICT", ")", ";", "}", "else", "{", "return", "modifier", "&", "~", "ABSTRACT", "&", "~", "INTERFACE", ";", "}", "}" ]

[ "When", "set", "abstract", "the", "modifier", "is", "cleared", "from", "being", "final", "volatile", "transient", "native", "synchronized", "and", "strictfp", ".", "When", "cleared", "from", "being", "abstract", "the", "modifier", "is", "also", "cleared", "from", "being", "an", "interface", "." ]

[ "public", "void", "destroy", "(", ")", "{", "for", "(", "int", "j", "=", "0", ";", "j", "<", "mApplications", ".", "length", ";", "j", "++", ")", "{", "if", "(", "mApplications", "[", "j", "]", "!=", "null", ")", "{", "mApplications", "[", "j", "]", ".", "destroy", "(", ")", ";", "}", "}", "}" ]

[ "This", "method", "destroys", "the", "ApplicationDepot", "." ]

[ "private", "TeaServletContextSource", "createContextSource", "(", "boolean", "http", ")", "throws", "Exception", "{", "return", "new", "TeaServletContextSource", "(", "getClass", "(", ")", ".", "getClassLoader", "(", ")", ",", "this", ",", "mEngine", ".", "getServletContext", "(", ")", ",", "mEngine", ".", "getLog", "(", ")", ",", "http", ",", "mEngine", ".", "getProperties", "(", ")", ".", "getBoolean", "(", "\"management.httpcontext\"", ",", "false", ")", ",", "mEngine", ".", "getProperties", "(", ")", ".", "getInt", "(", "\"management.httpcontext.readUrlCacheSize\"", ",", "500", ")", ",", "mEngine", ".", "getProperties", "(", ")", ".", "getBoolean", "(", "\"profiling.enabled\"", ",", "true", ")", ")", ";", "}" ]

[ "creates", "a", "single", "context", "source", "from", "the", "applications", "in", "the", "depot", "." ]

[ "public", "static", "Set", "<", "MethodEntry", ">", "getMethodsToImplement", "(", "Class", "<", "?", ">", "iface", ",", "Map", "<", "String", ",", "Class", "<", "?", ">", ">", "types", ",", "Class", "<", "?", ">", "parent", ")", "{", "// TODO: this does not take in account type params defined at the", "// method level yet..ie: <C extends Something> C getC() { ... }", "Set", "<", "MethodEntry", ">", "methods", "=", "new", "HashSet", "<", "MethodEntry", ">", "(", ")", ";", "addMethods", "(", "methods", ",", "iface", ",", "types", ",", "parent", ")", ";", "return", "methods", ";", "}" ]

[ "Get", "the", "set", "of", "methods", "that", "require", "implementation", "based", "on", "the", "given", "interface", ".", "If", "the", "types", "are", "specified", "then", "they", "will", "be", "passed", "through", "and", "methods", "overridden", "per", "the", "generic", "types", ".", "This", "may", "result", "in", "bridged", "methods", ".", "If", "parent", "is", "specified", "then", "only", "non", "-", "implemented", "methods", "will", "be", "returned", "." ]

[ "private", "static", "boolean", "isBridgeRequired", "(", "Map", "<", "String", ",", "Class", "<", "?", ">", ">", "types", ",", "Method", "method", ")", "{", "// check return type", "TypeVariable", "<", "?", ">", "var", "=", "getTypeVariable", "(", "method", ".", "getGenericReturnType", "(", ")", ")", ";", "if", "(", "var", "!=", "null", "&&", "types", ".", "containsKey", "(", "var", ".", "getName", "(", ")", ")", ")", "{", "return", "true", ";", "}", "// check param types", "for", "(", "Type", "paramType", ":", "method", ".", "getGenericParameterTypes", "(", ")", ")", "{", "var", "=", "getTypeVariable", "(", "paramType", ")", ";", "if", "(", "var", "!=", "null", "&&", "types", ".", "containsKey", "(", "var", ".", "getName", "(", ")", ")", ")", "{", "return", "true", ";", "}", "}", "// not required", "return", "false", ";", "}" ]

[ "Check", "whether", "a", "bridge", "is", "required", "for", "the", "given", "method", "and", "generic", "type", "information", ".", "If", "the", "return", "type", "or", "any", "parameter", "contains", "a", "type", "variable", "that", "is", "specified", "and", "overridden", "with", "a", "more", "specific", "type", "via", "the", "given", "types", "then", "a", "bridge", "will", "be", "required", "." ]

[ "private", "static", "final", "Class", "<", "?", ">", "getRootType", "(", "Map", "<", "String", ",", "Class", "<", "?", ">", ">", "types", ",", "Type", "type", ")", "{", "// if type explicitly defined, pass thru as is", "if", "(", "type", "instanceof", "Class", ")", "{", "return", "(", "Class", "<", "?", ">", ")", "type", ";", "}", "// if type defined as parameter, pass thru root type", "else", "if", "(", "type", "instanceof", "ParameterizedType", ")", "{", "Type", "raw", "=", "(", "(", "ParameterizedType", ")", "type", ")", ".", "getRawType", "(", ")", ";", "return", "getRootType", "(", "types", ",", "raw", ")", ";", "}", "// if type defined as wildcard, pass thru bounds", "// NOTE: this does not support ? super X format", "else", "if", "(", "type", "instanceof", "WildcardType", ")", "{", "Type", "[", "]", "bounds", "=", "(", "(", "WildcardType", ")", "type", ")", ".", "getUpperBounds", "(", ")", ";", "if", "(", "bounds", ".", "length", ">=", "1", ")", "{", "return", "getRootType", "(", "types", ",", "bounds", "[", "0", "]", ")", ";", "}", "}", "// otherwise, either generic array or plain type variable", "// lookup in types and return specified type if provided", "else", "{", "TypeVariable", "<", "?", ">", "raw", "=", "getTypeVariable", "(", "type", ")", ";", "if", "(", "raw", "!=", "null", ")", "{", "// verify type is overridden", "String", "name", "=", "raw", ".", "getName", "(", ")", ";", "if", "(", "types", ".", "containsKey", "(", "name", ")", ")", "{", "// get actual type and convert to array if necessary", "Class", "<", "?", ">", "actual", "=", "types", ".", "get", "(", "name", ")", ";", "int", "dimensions", "=", "getDimensions", "(", "type", ")", ";", "if", "(", "dimensions", ">=", "1", ")", "{", "actual", "=", "Array", ".", "newInstance", "(", "actual", ",", "dimensions", ")", ".", "getClass", "(", ")", ";", "}", "return", "actual", ";", "}", "}", "}", "// nothing found", "return", "null", ";", "}" ]

[ "Get", "the", "root", "class", "type", "based", "on", "the", "given", "type", "and", "set", "of", "named", "type", "variables", ".", "If", "the", "type", "is", "already", "a", "Class", "it", "is", "renamed", "as", "is", ".", "If", "the", "type", "is", "a", "parameterized", "type", "then", "the", "raw", "type", "is", "returned", ".", "If", "the", "type", "is", "a", "wildcard", "the", "lower", "bounds", "is", "returned", ".", "Otherwise", "if", "the", "type", "is", "a", "type", "variable", "its", "associated", "value", "from", "the", "types", "is", "returned", "." ]

[ "private", "static", "Class", "<", "?", ">", "getMethodType", "(", "Map", "<", "String", ",", "Class", "<", "?", ">", ">", "types", ",", "Type", "type", ",", "Class", "<", "?", ">", "clazz", ")", "{", "// check if type is an actual type variable", "TypeVariable", "<", "?", ">", "variable", "=", "getTypeVariable", "(", "type", ")", ";", "if", "(", "variable", "!=", "null", ")", "{", "// verify type is overridden", "String", "name", "=", "variable", ".", "getName", "(", ")", ";", "if", "(", "types", ".", "containsKey", "(", "name", ")", ")", "{", "// convert to array if necessary", "Class", "<", "?", ">", "actual", "=", "types", ".", "get", "(", "name", ")", ";", "int", "dimensions", "=", "getDimensions", "(", "type", ")", ";", "if", "(", "dimensions", ">", "0", ")", "{", "actual", "=", "Array", ".", "newInstance", "(", "actual", ",", "dimensions", ")", ".", "getClass", "(", ")", ";", "}", "// return overridden type", "return", "actual", ";", "}", "}", "// nothing overriden, so just return base class", "return", "clazz", ";", "}" ]

[ "Get", "the", "actual", "type", "for", "the", "given", "type", ".", "If", "the", "type", "is", "a", "type", "variable", "that", "is", "specified", "in", "the", "given", "types", "then", "the", "associated", "class", "is", "returned", ".", "Otherwise", "the", "specified", "class", "is", "returned", "." ]

[ "private", "static", "void", "addMethod", "(", "Set", "<", "MethodEntry", ">", "methods", ",", "MethodEntry", "method", ")", "{", "if", "(", "!", "method", ".", "isBridged", "(", ")", ")", "{", "methods", ".", "remove", "(", "method", ")", ";", "methods", ".", "add", "(", "method", ")", ";", "}", "else", "if", "(", "!", "methods", ".", "contains", "(", "method", ")", ")", "{", "methods", ".", "add", "(", "method", ")", ";", "}", "}" ]

[ "Add", "a", "method", "to", "the", "set", "of", "existing", "methods", ".", "If", "the", "method", "is", "not", "bridged", "it", "will", "overwrite", "any", "existing", "signature", ".", "Otherwise", "it", "will", "only", "update", "the", "set", "if", "not", "previously", "defined", ".", "Note", "that", "the", "signature", "of", "the", "method", "entry", "includes", "the", "method", "name", "parameter", "types", "and", "the", "return", "type", "." ]

[ "private", "static", "void", "addMethods", "(", "Set", "<", "MethodEntry", ">", "methods", ",", "Class", "<", "?", ">", "clazz", ",", "Map", "<", "String", ",", "Class", "<", "?", ">", ">", "types", ",", "Class", "<", "?", ">", "parent", ")", "{", "// validate interface", "if", "(", "!", "clazz", ".", "isInterface", "(", ")", ")", "{", "throw", "new", "IllegalStateException", "(", "\"class must be interface: \"", "+", "clazz", ")", ";", "}", "// loop through each method (only those declared)", "for", "(", "Method", "method", ":", "clazz", ".", "getDeclaredMethods", "(", ")", ")", "{", "addMethods", "(", "methods", ",", "clazz", ",", "types", ",", "parent", ",", "method", ")", ";", "}", "// recursively add each super interface providing type info if valid", "addParentMethods", "(", "methods", ",", "clazz", ",", "types", ",", "parent", ",", "null", ")", ";", "}" ]

[ "Recursive", "method", "that", "adds", "all", "applicable", "methods", "for", "the", "given", "class", "which", "is", "expected", "to", "be", "an", "interface", ".", "The", "tree", "is", "walked", "for", "the", "class", "and", "all", "super", "interfaces", "in", "recursive", "fashion", "to", "get", "each", "available", "method", ".", "Any", "method", "that", "is", "already", "defined", "by", "the", "given", "parent", "will", "be", "ignored", ".", "Otherwise", "the", "method", "including", "any", "required", "bridged", "methods", "will", "be", "added", ".", "The", "specified", "list", "of", "types", "define", "the", "optional", "type", "parameters", "of", "the", "given", "interface", "class", ".", "These", "types", "will", "propogate", "up", "the", "tree", "as", "necessary", "for", "any", "super", "-", "interfaces", "that", "match", "." ]

[ "private", "static", "void", "addMethods", "(", "Set", "<", "MethodEntry", ">", "methods", ",", "Class", "<", "?", ">", "clazz", ",", "Map", "<", "String", ",", "Class", "<", "?", ">", ">", "types", ",", "Class", "<", "?", ">", "parent", ",", "Method", "method", ")", "{", "// validate interface", "//if (!clazz.isInterface()) { ", "// throw new IllegalStateException(\"class must be interface: \" + clazz);", "//}", "// check if the method requires a bridge and add generic method", "// with overridden type params", "MethodEntry", "impl", "=", "null", ";", "boolean", "bridged", "=", "isBridgeRequired", "(", "types", ",", "method", ")", ";", "// do not add method if already implemented", "// ignore if method already defined on the parent", "if", "(", "!", "bridged", "&&", "parent", "!=", "null", "&&", "findMethod", "(", "parent", ",", "method", ")", "!=", "null", ")", "{", "return", ";", "}", "// bridge if necessary", "if", "(", "bridged", ")", "{", "// get the underying generic type if provided", "Class", "<", "?", ">", "returnType", "=", "getMethodType", "(", "types", ",", "method", ".", "getGenericReturnType", "(", ")", ",", "method", ".", "getReturnType", "(", ")", ")", ";", "// get the underlying generic params if provided", "Type", "[", "]", "paramTypes", "=", "method", ".", "getGenericParameterTypes", "(", ")", ";", "Class", "<", "?", ">", "[", "]", "paramClasses", "=", "method", ".", "getParameterTypes", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "paramClasses", ".", "length", ";", "i", "++", ")", "{", "paramClasses", "[", "i", "]", "=", "getMethodType", "(", "types", ",", "paramTypes", "[", "i", "]", ",", "paramClasses", "[", "i", "]", ")", ";", "}", "// check if only return type is overridden and only add impl", "// if not yet defined...this is possible since return type is", "// not part of a method signature for equality purposes so we", "// only need to implement in a concrete implementation once and", "// bridge all other methods. Parameters, on the other hand", "// must always be explicitly implemented to satisfy their", "// interface definition.", "MethodEntry", "bridgeMethod", "=", "null", ";", "if", "(", "Arrays", ".", "equals", "(", "paramClasses", ",", "method", ".", "getParameterTypes", "(", ")", ")", ")", "{", "for", "(", "MethodEntry", "mentry", ":", "methods", ")", "{", "if", "(", "mentry", ".", "getName", "(", ")", ".", "equals", "(", "method", ".", "getName", "(", ")", ")", "&&", "Arrays", ".", "equals", "(", "mentry", ".", "getParamTypes", "(", ")", ",", "method", ".", "getParameterTypes", "(", ")", ")", ")", "{", "bridgeMethod", "=", "mentry", ";", "}", "}", "}", "// add implementation", "impl", "=", "new", "MethodEntry", "(", "method", ".", "getName", "(", ")", ",", "returnType", ",", "paramClasses", ",", "bridgeMethod", ")", ";", "addMethod", "(", "methods", ",", "impl", ")", ";", "}", "// add actual method definition, bridging if implemented above", "addMethod", "(", "methods", ",", "new", "MethodEntry", "(", "method", ".", "getName", "(", ")", ",", "method", ".", "getReturnType", "(", ")", ",", "method", ".", "getParameterTypes", "(", ")", ",", "impl", ")", ")", ";", "// recursively add each super interface providing type info if valid", "addParentMethods", "(", "methods", ",", "clazz", ",", "types", ",", "parent", ",", "method", ")", ";", "}" ]

[ "Recursive", "method", "that", "adds", "all", "applicable", "methods", "related", "to", "the", "given", "class", "which", "is", "expected", "to", "be", "an", "interface", ".", "The", "tree", "is", "walked", "for", "the", "class", "and", "all", "super", "interfaces", "in", "recursive", "fashion", "to", "get", "each", "available", "method", "that", "matches", "the", "provided", "method", ".", "Any", "method", "that", "is", "already", "defined", "by", "the", "given", "parent", "will", "be", "ignored", ".", "Otherwise", "the", "method", "including", "any", "required", "bridged", "methods", "will", "be", "added", ".", "The", "specified", "list", "of", "types", "define", "the", "optional", "type", "parameters", "of", "the", "given", "interface", "class", ".", "These", "types", "will", "propogate", "up", "the", "tree", "as", "necessary", "for", "any", "super", "-", "interfaces", "that", "match", "." ]

[ "private", "static", "void", "addParentMethods", "(", "Set", "<", "MethodEntry", ">", "methods", ",", "Class", "<", "?", ">", "clazz", ",", "Map", "<", "String", ",", "Class", "<", "?", ">", ">", "types", ",", "Class", "<", "?", ">", "parent", ",", "Method", "method", ")", "{", "// recursively add each super interface providing type info if valid", "Class", "<", "?", ">", "[", "]", "ifaces", "=", "clazz", ".", "getInterfaces", "(", ")", ";", "Type", "[", "]", "generics", "=", "clazz", ".", "getGenericInterfaces", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "ifaces", ".", "length", ";", "i", "++", ")", "{", "Class", "<", "?", ">", "iface", "=", "ifaces", "[", "i", "]", ";", "Type", "generic", "=", "iface", ";", "if", "(", "generics", "!=", "null", "&&", "i", "<", "generics", ".", "length", ")", "{", "generic", "=", "generics", "[", "i", "]", ";", "}", "// check if interface is parameterized and lookup type information", "// cascading current type information if types match", "if", "(", "generic", "instanceof", "ParameterizedType", ")", "{", "TypeVariable", "<", "?", ">", "[", "]", "vars", "=", "iface", ".", "getTypeParameters", "(", ")", ";", "ParameterizedType", "ptype", "=", "(", "ParameterizedType", ")", "generic", ";", "Type", "[", "]", "arguments", "=", "ptype", ".", "getActualTypeArguments", "(", ")", ";", "// check each parameter for specific type ", "Map", "<", "String", ",", "Class", "<", "?", ">", ">", "args", "=", "new", "HashMap", "<", "String", ",", "Class", "<", "?", ">", ">", "(", ")", ";", "for", "(", "int", "j", "=", "0", ";", "j", "<", "vars", ".", "length", ";", "j", "++", ")", "{", "Type", "arg", "=", "arguments", "[", "j", "]", ";", "TypeVariable", "<", "?", ">", "var", "=", "vars", "[", "j", "]", ";", "// check if root type defined and pass type thru", "Class", "<", "?", ">", "root", "=", "getRootType", "(", "types", ",", "arg", ")", ";", "if", "(", "root", "!=", "null", ")", "{", "args", ".", "put", "(", "var", ".", "getName", "(", ")", ",", "root", ")", ";", "}", "}", "// recursively invoke", "if", "(", "method", "==", "null", ")", "{", "addMethods", "(", "methods", ",", "(", "Class", "<", "?", ">", ")", "ptype", ".", "getRawType", "(", ")", ",", "args", ",", "parent", ")", ";", "}", "else", "{", "addMethods", "(", "methods", ",", "(", "Class", "<", "?", ">", ")", "ptype", ".", "getRawType", "(", ")", ",", "args", ",", "parent", ",", "method", ")", ";", "}", "}", "// normal class, so recursively invoke as is", "else", "if", "(", "iface", "instanceof", "Class", "<", "?", ">", ")", "{", "if", "(", "method", "==", "null", ")", "{", "addMethods", "(", "methods", ",", "iface", ",", "new", "HashMap", "<", "String", ",", "Class", "<", "?", ">", ">", "(", ")", ",", "parent", ")", ";", "}", "else", "{", "addMethods", "(", "methods", ",", "iface", ",", "new", "HashMap", "<", "String", ",", "Class", "<", "?", ">", ">", "(", ")", ",", "parent", ",", "method", ")", ";", "}", "}", "}", "}" ]

[ "Recursively", "add", "all", "methods", "walking", "the", "interface", "hiearchy", "for", "the", "given", "class", "." ]

[ "public", "static", "File", "createTemplateClassesDir", "(", "File", "tmpDir", ",", "String", "dirPath", ",", "Log", "log", ")", "{", "File", "destDir", "=", "null", ";", "if", "(", "dirPath", "!=", "null", "&&", "!", "dirPath", ".", "isEmpty", "(", ")", ")", "{", "// handle file-based paths", "if", "(", "dirPath", ".", "startsWith", "(", "\"file:\"", ")", ")", "{", "destDir", "=", "new", "File", "(", "dirPath", ".", "substring", "(", "5", ")", ")", ";", "}", "// otherwise, assume relative path to tmp dir", "else", "{", "destDir", "=", "new", "File", "(", "tmpDir", ",", "dirPath", ")", ";", "try", "{", "if", "(", "!", "destDir", ".", "getCanonicalPath", "(", ")", ".", "startsWith", "(", "tmpDir", ".", "getCanonicalPath", "(", ")", ".", "concat", "(", "File", ".", "separator", ")", ")", ")", "{", "throw", "new", "IllegalStateException", "(", "\"invalid template classes directory: \"", "+", "dirPath", ")", ";", "}", "}", "catch", "(", "IOException", "ioe", ")", "{", "throw", "new", "IllegalStateException", "(", "\"invalid template classes directory: \"", "+", "dirPath", ",", "ioe", ")", ";", "}", "}", "if", "(", "!", "destDir", ".", "isDirectory", "(", ")", ")", "{", "// try creating it but not the parents.", "if", "(", "!", "destDir", ".", "mkdir", "(", ")", ")", "{", "log", ".", "warn", "(", "\"Could not create template classes directory: \"", "+", "destDir", ".", "getAbsolutePath", "(", ")", ")", ";", "destDir", "=", "null", ";", "}", "}", "if", "(", "destDir", "!=", "null", "&&", "!", "destDir", ".", "canWrite", "(", ")", ")", "{", "log", ".", "warn", "(", "\"Unable to write to template classes directory: \"", "+", "destDir", ".", "getAbsolutePath", "(", ")", ")", ";", "destDir", "=", "null", ";", "}", "}", "return", "destDir", ";", "}" ]

[ "converts", "a", "path", "to", "a", "File", "for", "storing", "compiled", "template", "classes", "." ]

[ "protected", "ClassInjector", "createClassInjector", "(", ")", "throws", "Exception", "{", "return", "new", "ResolvingInjector", "(", "mConfig", ".", "getContextSource", "(", ")", ".", "getContextType", "(", ")", ".", "getClassLoader", "(", ")", ",", "new", "File", "[", "]", "{", "mCompiledDir", "}", ",", "mConfig", ".", "getPackagePrefix", "(", ")", ",", "false", ")", ";", "}" ]

[ "provides", "a", "default", "class", "injector", "using", "the", "contextType", "s", "ClassLoader", "as", "a", "parent", "." ]

[ "protected", "boolean", "sourceSignatureChanged", "(", "String", "tName", ",", "Compiler", "compiler", ")", "throws", "IOException", "{", "TemplateRepository", "tRepo", "=", "TemplateRepository", ".", "getInstance", "(", ")", ";", "TemplateInfo", "templateInfo", "=", "tRepo", ".", "getTemplateInfo", "(", "tName", ")", ";", "if", "(", "null", "==", "templateInfo", ")", "{", "return", "false", ";", "}", "CompilationUnit", "unit", "=", "compiler", ".", "getCompilationUnit", "(", "tName", ",", "null", ")", ";", "if", "(", "unit", "==", "null", ")", "{", "return", "false", ";", "}", "return", "!", "unit", ".", "signatureEquals", "(", "tName", ",", "templateInfo", ".", "getParameterTypes", "(", ")", ",", "templateInfo", ".", "getReturnType", "(", ")", ")", ";", "}" ]

[ "parses", "the", "tea", "source", "file", "and", "compares", "the", "signature", "to", "the", "signature", "of", "the", "current", "class", "file", "in", "the", "TemplateRepository" ]

[ "@", "Override", "public", "CompilationSource", "createCompilationSource", "(", "String", "name", ")", "{", "File", "sourceFile", "=", "getSourceFile", "(", "name", ")", ";", "if", "(", "sourceFile", "==", "null", "||", "!", "sourceFile", ".", "exists", "(", ")", ")", "{", "return", "null", ";", "}", "return", "new", "FileSource", "(", "name", ",", "sourceFile", ")", ";", "}" ]

[ "Always", "returns", "an", "instance", "of", "FileCompiler", ".", "Unit", ".", "Any", "errors", "reported", "by", "the", "compiler", "that", "have", "a", "reference", "to", "a", "CompilationUnit", "will", "have", "been", "created", "by", "this", "factory", "method", ".", "Casting", "this", "to", "FileCompiler", ".", "Unit", "allows", "error", "reporters", "to", "access", "the", "source", "file", "via", "the", "getSourceFile", "method", "." ]

[ "protected", "File", "getSourceFile", "(", "String", "name", ")", "{", "String", "fileName", "=", "name", ".", "replace", "(", "'", "'", ",", "File", ".", "separatorChar", ")", "+", "\".tea\"", ";", "File", "file", "=", "new", "File", "(", "mRootSourceDir", ",", "fileName", ")", ";", "return", "file", ";", "}" ]

[ "Get", "the", "source", "file", "relative", "to", "the", "root", "source", "directory", "for", "the", "given", "template", "." ]

[ "public", "boolean", "releaseLock", "(", ")", "{", "LockInfo", "info", "=", "(", "LockInfo", ")", "mLockInfoRef", ".", "get", "(", ")", ";", "int", "type", "=", "info", ".", "mType", ";", "int", "count", "=", "info", ".", "mCount", ";", "if", "(", "count", ">", "0", ")", "{", "count", "--", ";", "}", "else", "{", "info", ".", "mType", "=", "type", "=", "NONE", ";", "count", "=", "0", ";", "}", "if", "(", "(", "info", ".", "mCount", "=", "count", ")", "==", "0", ")", "{", "switch", "(", "type", ")", "{", "case", "NONE", ":", "default", ":", "return", "false", ";", "case", "READ", ":", "synchronized", "(", "this", ")", "{", "mReadLocks", "--", ";", "notifyAll", "(", ")", ";", "}", "break", ";", "case", "UPGRADABLE", ":", "synchronized", "(", "this", ")", "{", "mUpgradableLockHeld", "=", "null", ";", "notifyAll", "(", ")", ";", "}", "break", ";", "case", "WRITE", ":", "synchronized", "(", "this", ")", "{", "mWriteLockHeld", "=", "null", ";", "notifyAll", "(", ")", ";", "}", "break", ";", "}", "info", ".", "mType", "=", "NONE", ";", "}", "else", "if", "(", "type", "==", "WRITE", "&&", "info", ".", "mUpgradeCount", "==", "count", ")", "{", "// Convert write lock back into an upgradable lock.", "info", ".", "mType", "=", "UPGRADABLE", ";", "info", ".", "mUpgradeCount", "=", "0", ";", "synchronized", "(", "this", ")", "{", "mWriteLockHeld", "=", "null", ";", "notifyAll", "(", ")", ";", "}", "}", "return", "true", ";", "}" ]

[ "Release", "the", "lock", "held", "by", "the", "current", "thread", "." ]

[ "private", "boolean", "writeLockAvailable", "(", "int", "type", ")", "{", "if", "(", "mReadLocks", "==", "0", "&&", "mWriteLockHeld", "==", "null", ")", "{", "return", "(", "type", "==", "UPGRADABLE", ")", "?", "true", ":", "mUpgradableLockHeld", "==", "null", ";", "}", "return", "false", ";", "}" ]

[ "Caller", "must", "be", "synchronized", "." ]

[ "private", "void", "writePackageInfos", "(", "File", "rootDir", ",", "File", "outputDir", ")", "throws", "MojoExecutionException", "{", "getLog", "(", ")", ".", "debug", "(", "\"in writePackageInfos(\"", "+", "rootDir", "+", "\", \"", "+", "outputDir", "+", "\")\"", ")", ";", "try", "{", "if", "(", "shouldWritePackageInfo", "(", "rootDir", ")", ")", "{", "if", "(", "!", "outputDir", ".", "exists", "(", ")", "&&", "!", "outputDir", ".", "mkdirs", "(", ")", ")", "{", "throw", "new", "MojoExecutionException", "(", "\"outputDirectory was unable to be created: \"", "+", "outputDir", ")", ";", "}", "writePackageInfo", "(", "outputDir", ")", ";", "}", "else", "{", "getLog", "(", ")", ".", "debug", "(", "\"no files in:\"", "+", "rootDir", ")", ";", "}", "}", "catch", "(", "Throwable", "e", ")", "{", "throw", "new", "MojoExecutionException", "(", "\"could not write PackageInfo.java in: \"", "+", "outputDir", ",", "e", ")", ";", "}", "// get any sub-directories", "File", "[", "]", "subdirs", "=", "rootDir", ".", "listFiles", "(", "new", "FileFilter", "(", ")", "{", "public", "boolean", "accept", "(", "File", "pathname", ")", "{", "return", "pathname", ".", "isDirectory", "(", ")", ";", "}", "}", ")", ";", "// recurse", "if", "(", "subdirs", "!=", "null", ")", "{", "for", "(", "File", "subdir", ":", "subdirs", ")", "{", "writePackageInfos", "(", "subdir", ",", "new", "File", "(", "outputDir", ",", "subdir", ".", "getName", "(", ")", ")", ")", ";", "}", "}", "}" ]

[ "recurse", "into", "rootDir", "writing", "PackageInfos", "on", "the", "way", "in", "." ]

[ "private", "boolean", "shouldWritePackageInfo", "(", "File", "directory", ")", "{", "if", "(", "!", "directory", ".", "isDirectory", "(", ")", ")", "return", "false", ";", "if", "(", "!", "directory", ".", "exists", "(", ")", ")", "return", "false", ";", "// legacy behavior: if mPackageRootDir is a sub-dir of mSrcRootPath, an explicit package was specified", "if", "(", "isChild", "(", "new", "File", "(", "mSrcRootPath", ")", ",", "mPackageRootDir", ")", ")", "{", "// return true if 'directory' passed in equals() or is a child of mPackageRootDir", "return", "mPackageRootDir", ".", "equals", "(", "directory", ")", "||", "isChild", "(", "mPackageRootDir", ",", "directory", ")", ";", "}", "else", "{", "// only return true if 'directory' passed in contains at least one file", "File", "[", "]", "files", "=", "directory", ".", "listFiles", "(", "new", "FileFilter", "(", ")", "{", "public", "boolean", "accept", "(", "File", "pathname", ")", "{", "return", "pathname", ".", "isFile", "(", ")", ";", "}", "}", ")", ";", "return", "files", "!=", "null", "&&", "files", ".", "length", ">", "0", ";", "}", "}" ]

[ "Tests", "if", "a", "PackageInfo", ".", "java", "file", "should", "be", "written", "in", "the", "directory", "passed", "in", "." ]

[ "public", "String", "readLine", "(", ")", "throws", "IOException", "{", "StringBuffer", "buf", "=", "new", "StringBuffer", "(", "80", ")", ";", "int", "line", "=", "mLineNumber", ";", "int", "c", ";", "while", "(", "line", "==", "mLineNumber", "&&", "(", "c", "=", "read", "(", ")", ")", ">=", "0", ")", "{", "buf", ".", "append", "(", "(", "char", ")", "c", ")", ";", "}", "return", "buf", ".", "toString", "(", ")", ";", "}" ]

[ "After", "calling", "readLine", "calling", "getLineNumber", "returns", "the", "next", "line", "number", "." ]