Datasets:

---

CM

/

codexglue_code2text_java

like 4

[ "public", "void", "startGSEXIT", "(", ")", "throws", "IOException", "{", "List", "<", "HubDataSink", ">", "dataSinks", "=", "hubDataStore", ".", "getHubDataSinks", "(", ")", ";", "for", "(", "HubDataSink", "hubDataSink", ":", "dataSinks", ")", "{", "List", "<", "String", ">", "com", "=", "Lists", ".", "newArrayList", "(", ")", ";", "com", ".", "add", "(", "getHostPort", "(", "hubDataStore", ".", "getHubAddress", "(", ")", ")", ")", ";", "com", ".", "add", "(", "hubDataStore", ".", "getInstanceName", "(", ")", ")", ";", "com", ".", "add", "(", "hubDataSink", ".", "getFTAName", "(", ")", ")", ";", "com", ".", "add", "(", "hubDataSink", ".", "getName", "(", ")", ")", ";", "ExternalProgramExecutor", "executorService", "=", "new", "ExternalProgramExecutor", "(", "\"GSEXIT\"", ",", "new", "File", "(", "binLocation", ",", "\"GSEXIT\"", ")", ",", "com", ".", "toArray", "(", "new", "String", "[", "com", ".", "size", "(", ")", "]", ")", ")", ";", "gsExitExecutor", ".", "add", "(", "executorService", ")", ";", "LOG", ".", "info", "(", "\"Starting GSEXIT : {}\"", ",", "executorService", ")", ";", "executorService", ".", "startAndWait", "(", ")", ";", "}", "}" ]

[ "Starts", "GSEXIT", "processes", "." ]

[ "private", "String", "getStringValue", "(", "Object", "instance", ",", "Field", "field", ")", "throws", "IllegalAccessException", "{", "Class", "<", "?", ">", "fieldType", "=", "field", ".", "getType", "(", ")", ";", "// Only support primitive type, boxed type, String and Enum", "Preconditions", ".", "checkArgument", "(", "fieldType", ".", "isPrimitive", "(", ")", "||", "Primitives", ".", "isWrapperType", "(", "fieldType", ")", "||", "String", ".", "class", ".", "equals", "(", "fieldType", ")", "||", "fieldType", ".", "isEnum", "(", ")", ",", "\"Unsupported property type %s of field %s in class %s.\"", ",", "fieldType", ".", "getName", "(", ")", ",", "field", ".", "getName", "(", ")", ",", "field", ".", "getDeclaringClass", "(", ")", ".", "getName", "(", ")", ")", ";", "if", "(", "!", "field", ".", "isAccessible", "(", ")", ")", "{", "field", ".", "setAccessible", "(", "true", ")", ";", "}", "Object", "value", "=", "field", ".", "get", "(", "instance", ")", ";", "if", "(", "value", "==", "null", ")", "{", "return", "null", ";", "}", "// Key name is \"className.fieldName\".", "return", "fieldType", ".", "isEnum", "(", ")", "?", "(", "(", "Enum", "<", "?", ">", ")", "value", ")", ".", "name", "(", ")", ":", "value", ".", "toString", "(", ")", ";", "}" ]

[ "Gets", "the", "value", "of", "the", "field", "in", "the", "given", "instance", "as", "String", ".", "Currently", "only", "allows", "primitive", "types", "boxed", "types", "String", "and", "Enum", "." ]

[ "public", "static", "boolean", "checkSchema", "(", "Set", "<", "Schema", ">", "output", ",", "Set", "<", "Schema", ">", "input", ")", "{", "return", "findSchema", "(", "output", ",", "input", ")", "!=", "null", ";", "}" ]

[ "Given", "two", "schema", "s", "checks", "if", "there", "exists", "compatibility", "or", "equality", "." ]

[ "private", "static", "byte", "[", "]", "serializeEmptyHashKeys", "(", ")", "{", "try", "{", "// we don't synchronize here: the worst thing that go wrong here is repeated assignment to the same value", "ByteArrayOutputStream", "bos", "=", "new", "ByteArrayOutputStream", "(", ")", ";", "Encoder", "encoder", "=", "new", "BinaryEncoder", "(", "bos", ")", ";", "encoder", ".", "writeInt", "(", "0", ")", ";", "return", "bos", ".", "toByteArray", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "new", "RuntimeException", "(", "\"encoding empty hash keys went wrong - bailing out: \"", "+", "e", ".", "getMessage", "(", ")", ",", "e", ")", ";", "}", "}" ]

[ "many", "entries", "will", "have", "no", "hash", "keys", ".", "Serialize", "that", "once", "and", "for", "good" ]

[ "public", "Encoder", "writeRaw", "(", "byte", "[", "]", "rawBytes", ",", "int", "off", ",", "int", "len", ")", "throws", "IOException", "{", "output", ".", "write", "(", "rawBytes", ",", "off", ",", "len", ")", ";", "return", "this", ";", "}" ]

[ "Writes", "raw", "bytes", "to", "the", "buffer", "without", "encoding", "." ]

[ "private", "static", "ClassPath", "getAPIClassPath", "(", ")", "throws", "IOException", "{", "ClassLoader", "classLoader", "=", "Flow", ".", "class", ".", "getClassLoader", "(", ")", ";", "String", "resourceName", "=", "Flow", ".", "class", ".", "getName", "(", ")", ".", "replace", "(", "'", "'", ",", "'", "'", ")", "+", "\".class\"", ";", "URL", "url", "=", "classLoader", ".", "getResource", "(", "resourceName", ")", ";", "if", "(", "url", "==", "null", ")", "{", "throw", "new", "IOException", "(", "\"Resource not found for \"", "+", "resourceName", ")", ";", "}", "try", "{", "URI", "classPathURI", "=", "getClassPathURL", "(", "resourceName", ",", "url", ")", ".", "toURI", "(", ")", ";", "return", "ClassPath", ".", "from", "(", "classPathURI", ",", "classLoader", ")", ";", "}", "catch", "(", "URISyntaxException", "e", ")", "{", "throw", "new", "IOException", "(", "e", ")", ";", "}", "}" ]

[ "Gathers", "all", "resources", "for", "api", "classes", "." ]

[ "private", "static", "URL", "getClassPathURL", "(", "String", "resourceName", ",", "URL", "resourceURL", ")", "{", "try", "{", "if", "(", "\"file\"", ".", "equals", "(", "resourceURL", ".", "getProtocol", "(", ")", ")", ")", "{", "String", "path", "=", "resourceURL", ".", "getFile", "(", ")", ";", "// Compute the directory container the class.", "int", "endIdx", "=", "path", ".", "length", "(", ")", "-", "resourceName", ".", "length", "(", ")", ";", "if", "(", "endIdx", ">", "1", ")", "{", "// If it is not the root directory, return the end index to remove the trailing '/'.", "endIdx", "--", ";", "}", "return", "new", "URL", "(", "\"file\"", ",", "\"\"", ",", "-", "1", ",", "path", ".", "substring", "(", "0", ",", "endIdx", ")", ")", ";", "}", "if", "(", "\"jar\"", ".", "equals", "(", "resourceURL", ".", "getProtocol", "(", ")", ")", ")", "{", "String", "path", "=", "resourceURL", ".", "getFile", "(", ")", ";", "return", "URI", ".", "create", "(", "path", ".", "substring", "(", "0", ",", "path", ".", "indexOf", "(", "\"!/\"", ")", ")", ")", ".", "toURL", "(", ")", ";", "}", "}", "catch", "(", "MalformedURLException", "e", ")", "{", "throw", "Throwables", ".", "propagate", "(", "e", ")", ";", "}", "throw", "new", "IllegalStateException", "(", "\"Unsupported class URL: \"", "+", "resourceURL", ")", ";", "}" ]

[ "Find", "the", "classpath", "that", "contains", "the", "given", "resource", "." ]

[ "private", "HBaseQueueAdmin", "ensureTableExists", "(", "QueueName", "queueName", ")", "throws", "IOException", "{", "HBaseQueueAdmin", "admin", "=", "queueAdmin", ";", "try", "{", "if", "(", "!", "admin", ".", "exists", "(", "queueName", ")", ")", "{", "admin", ".", "create", "(", "queueName", ")", ";", "}", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "IOException", "(", "\"Failed to open table \"", "+", "admin", ".", "getActualTableName", "(", "queueName", ")", ",", "e", ")", ";", "}", "return", "admin", ";", "}" ]

[ "Helper", "method", "to", "select", "the", "queue", "or", "stream", "admin", "and", "to", "ensure", "it", "s", "table", "exists", "." ]

[ "public", "static", "String", "getSerializedSchema", "(", "String", "gdatHeader", ")", "{", "/*Format :\n GDAT\\nVERSION:4\\nSCHEMALENGTH:123\\n\n FTA {\\n\n STREAM <name> {\\n\n <list of fields>\\n\n }\\n\n <query text>\\n\n }\n */", "int", "startBracketIndex", "=", "gdatHeader", ".", "indexOf", "(", "\"{\"", ")", ";", "startBracketIndex", "=", "gdatHeader", ".", "indexOf", "(", "\"{\"", ",", "startBracketIndex", "+", "1", ")", ";", "int", "endBracketIndex", "=", "gdatHeader", ".", "indexOf", "(", "\"}\"", ")", ";", "Preconditions", ".", "checkArgument", "(", "endBracketIndex", ">", "startBracketIndex", ")", ";", "return", "gdatHeader", ".", "substring", "(", "startBracketIndex", "+", "1", ",", "endBracketIndex", ")", ";", "}" ]

[ "Given", "a", "gdatHeader", "extract", "serialized", "Schema", "String", "." ]

[ "public", "static", "int", "getHFTACount", "(", "File", "fileLocation", ")", "{", "Document", "qtree", "=", "getQTree", "(", "fileLocation", ")", ";", "int", "count", ";", "count", "=", "qtree", ".", "getElementsByTagName", "(", "\"HFTA\"", ")", ".", "getLength", "(", ")", ";", "return", "count", ";", "}" ]

[ "This", "method", "returns", "the", "number", "of", "HFTA", "processes", "to", "be", "instantiated", "by", "parsing", "the", "qtree", ".", "xml", "file" ]

[ "public", "Delete", "delete", "(", "Delete", "delete", ")", "{", "delete", ".", "deleteColumns", "(", "QueueEntryRow", ".", "COLUMN_FAMILY", ",", "consumerStateColumn", ")", ";", "return", "delete", ";", "}" ]

[ "Adds", "a", "delete", "of", "this", "consumer", "state", "to", "the", "given", "Delete", "object", "." ]

[ "public", "Object", "decode", "(", "Decoder", "decoder", ")", "throws", "IOException", "{", "try", "{", "return", "outputGenerator", ".", "read", "(", "decoder", ",", "schema", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "LOG", ".", "error", "(", "\"Cannot instantiate object of type {}\"", ",", "outputClass", ".", "getName", "(", ")", ",", "e", ")", ";", "throw", "e", ";", "}", "}" ]

[ "This", "function", "is", "called", "for", "each", "incoming", "byte", "record", "." ]

[ "private", "Table", "<", "String", ",", "Integer", ",", "ProgramController", ">", "createFlowlets", "(", "Program", "program", ",", "RunId", "runId", ",", "FlowSpecification", "flowSpec", ")", "{", "Table", "<", "String", ",", "Integer", ",", "ProgramController", ">", "flowlets", "=", "HashBasedTable", ".", "create", "(", ")", ";", "try", "{", "for", "(", "Map", ".", "Entry", "<", "String", ",", "FlowletDefinition", ">", "entry", ":", "flowSpec", ".", "getFlowlets", "(", ")", ".", "entrySet", "(", ")", ")", "{", "int", "instanceCount", "=", "entry", ".", "getValue", "(", ")", ".", "getInstances", "(", ")", ";", "for", "(", "int", "instanceId", "=", "0", ";", "instanceId", "<", "instanceCount", ";", "instanceId", "++", ")", "{", "flowlets", ".", "put", "(", "entry", ".", "getKey", "(", ")", ",", "instanceId", ",", "startFlowlet", "(", "program", ",", "createFlowletOptions", "(", "entry", ".", "getKey", "(", ")", ",", "instanceId", ",", "instanceCount", ",", "runId", ")", ")", ")", ";", "}", "}", "}", "catch", "(", "Throwable", "t", ")", "{", "try", "{", "// Need to stop all started flowlets", "Futures", ".", "successfulAsList", "(", "Iterables", ".", "transform", "(", "flowlets", ".", "values", "(", ")", ",", "new", "Function", "<", "ProgramController", ",", "ListenableFuture", "<", "?", ">", ">", "(", ")", "{", "@", "Override", "public", "ListenableFuture", "<", "?", ">", "apply", "(", "ProgramController", "controller", ")", "{", "return", "controller", ".", "stop", "(", ")", ";", "}", "}", ")", ")", ".", "get", "(", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "LOG", ".", "error", "(", "\"Fail to stop all flowlets on failure.\"", ")", ";", "}", "throw", "Throwables", ".", "propagate", "(", "t", ")", ";", "}", "return", "flowlets", ";", "}" ]

[ "Starts", "all", "flowlets", "in", "the", "flow", "program", "." ]

[ "@", "Override", "public", "final", "void", "initialize", "(", "FlowletContext", "ctx", ")", "throws", "Exception", "{", "super", ".", "initialize", "(", "ctx", ")", ";", "portsAnnouncementList", "=", "Lists", ".", "newArrayList", "(", ")", ";", "DefaultInputFlowletConfigurer", "configurer", "=", "new", "DefaultInputFlowletConfigurer", "(", "this", ")", ";", "create", "(", "configurer", ")", ";", "InputFlowletSpecification", "spec", "=", "configurer", ".", "createInputFlowletSpec", "(", ")", ";", "dataIngestionPortsMap", "=", "Maps", ".", "newHashMap", "(", ")", ";", "int", "httpPort", "=", "0", ";", "if", "(", "ctx", ".", "getRuntimeArguments", "(", ")", ".", "get", "(", "Constants", ".", "HTTP_PORT", ")", "!=", "null", ")", "{", "httpPort", "=", "Integer", ".", "parseInt", "(", "ctx", ".", "getRuntimeArguments", "(", ")", ".", "get", "(", "Constants", ".", "HTTP_PORT", ")", ")", ";", "}", "dataIngestionPortsMap", ".", "put", "(", "Constants", ".", "HTTP_PORT", ",", "httpPort", ")", ";", "for", "(", "String", "inputName", ":", "spec", ".", "getInputSchemas", "(", ")", ".", "keySet", "(", ")", ")", "{", "int", "tcpPort", "=", "0", ";", "if", "(", "ctx", ".", "getRuntimeArguments", "(", ")", ".", "get", "(", "Constants", ".", "TCP_INGESTION_PORT_PREFIX", "+", "inputName", ")", "!=", "null", ")", "{", "tcpPort", "=", "Integer", ".", "parseInt", "(", "ctx", ".", "getRuntimeArguments", "(", ")", ".", "get", "(", "Constants", ".", "TCP_INGESTION_PORT_PREFIX", "+", "inputName", ")", ")", ";", "}", "dataIngestionPortsMap", ".", "put", "(", "Constants", ".", "TCP_INGESTION_PORT_PREFIX", "+", "inputName", ",", "tcpPort", ")", ";", "}", "// Setup temporary directory structure", "tmpFolder", "=", "Files", ".", "createTempDir", "(", ")", ";", "File", "baseDir", "=", "new", "File", "(", "tmpFolder", ",", "\"baseDir\"", ")", ";", "baseDir", ".", "mkdirs", "(", ")", ";", "InputFlowletConfiguration", "inputFlowletConfiguration", "=", "new", "LocalInputFlowletConfiguration", "(", "baseDir", ",", "spec", ")", ";", "File", "binDir", "=", "inputFlowletConfiguration", ".", "createStreamEngineProcesses", "(", ")", ";", "healthInspector", "=", "new", "HealthInspector", "(", "this", ")", ";", "metricsRecorder", "=", "new", "MetricsRecorder", "(", "metrics", ")", ";", "//Initiating AbstractInputFlowlet Components", "recordQueue", "=", "new", "GDATRecordQueue", "(", ")", ";", "//Initiating Netty TCP I/O ports", "inputFlowletService", "=", "new", "InputFlowletService", "(", "binDir", ",", "spec", ",", "healthInspector", ",", "metricsRecorder", ",", "recordQueue", ",", "dataIngestionPortsMap", ",", "this", ")", ";", "inputFlowletService", ".", "startAndWait", "(", ")", ";", "//Starting health monitor service", "healthInspector", ".", "startAndWait", "(", ")", ";", "//Initializing methodsDriver", "Map", "<", "String", ",", "StreamSchema", ">", "schemaMap", "=", "MetaInformationParser", ".", "getSchemaMap", "(", "new", "File", "(", "binDir", ".", "toURI", "(", ")", ")", ")", ";", "methodsDriver", "=", "new", "MethodsDriver", "(", "this", ",", "schemaMap", ")", ";", "//Initialize stopwatch and retry counter", "stopwatch", "=", "new", "Stopwatch", "(", ")", ";", "retryCounter", "=", "0", ";", "}" ]

[ "This", "method", "initializes", "all", "the", "components", "required", "to", "setup", "the", "SQL", "Compiler", "environment", "." ]

[ "@", "Tick", "(", "delay", "=", "200L", ",", "unit", "=", "TimeUnit", ".", "MILLISECONDS", ")", "protected", "void", "processGDATRecords", "(", ")", "throws", "InvocationTargetException", ",", "IllegalAccessException", "{", "stopwatch", ".", "reset", "(", ")", ";", "stopwatch", ".", "start", "(", ")", ";", "while", "(", "!", "recordQueue", ".", "isEmpty", "(", ")", ")", "{", "// Time since start of processing in Seconds", "long", "elapsedTime", "=", "stopwatch", ".", "elapsedTime", "(", "TimeUnit", ".", "SECONDS", ")", ";", "if", "(", "elapsedTime", ">=", "Constants", ".", "TICKER_TIMEOUT", ")", "{", "break", ";", "}", "Map", ".", "Entry", "<", "String", ",", "GDATDecoder", ">", "record", "=", "recordQueue", ".", "getNext", "(", ")", ";", "methodsDriver", ".", "invokeMethods", "(", "record", ".", "getKey", "(", ")", ",", "record", ".", "getValue", "(", ")", ")", ";", "}", "stopwatch", ".", "stop", "(", ")", ";", "}" ]

[ "This", "process", "method", "consumes", "the", "records", "queued", "in", "dataManager", "and", "invokes", "the", "associated", "process", "methods", "for", "each", "output", "query" ]

[ "@", "Override", "public", "void", "notifyFailure", "(", "Set", "<", "String", ">", "errorProcessNames", ")", "{", "if", "(", "errorProcessNames", "!=", "null", ")", "{", "LOG", ".", "warn", "(", "\"Missing pings from : \"", "+", "errorProcessNames", ".", "toString", "(", ")", ")", ";", "}", "else", "{", "LOG", ".", "warn", "(", "\"No heartbeats registered\"", ")", ";", "}", "healthInspector", ".", "stopAndWait", "(", ")", ";", "healthInspector", "=", "new", "HealthInspector", "(", "this", ")", ";", "inputFlowletService", ".", "restartService", "(", "healthInspector", ")", ";", "healthInspector", ".", "startAndWait", "(", ")", ";", "}" ]

[ "ProcessMonitor", "callback", "function", "Restarts", "SQL", "Compiler", "processes" ]

[ "protected", "void", "updateVersionInPreferences", "(", ")", "{", "SharedPreferences", "sp", "=", "PreferenceManager", ".", "getDefaultSharedPreferences", "(", "mContext", ")", ";", "SharedPreferences", ".", "Editor", "editor", "=", "sp", ".", "edit", "(", ")", ";", "editor", ".", "putInt", "(", "VERSION_KEY", ",", "mCurrentVersionCode", ")", ";", "// TODO: Update preferences from a background thread", "editor", ".", "commit", "(", ")", ";", "}" ]

[ "Write", "current", "version", "code", "to", "the", "preferences", "." ]

[ "public", "List", "<", "ReleaseItem", ">", "getChangeLog", "(", "boolean", "full", ")", "{", "SparseArray", "<", "ReleaseItem", ">", "masterChangelog", "=", "getMasterChangeLog", "(", "full", ")", ";", "SparseArray", "<", "ReleaseItem", ">", "changelog", "=", "getLocalizedChangeLog", "(", "full", ")", ";", "List", "<", "ReleaseItem", ">", "mergedChangeLog", "=", "new", "ArrayList", "<", "ReleaseItem", ">", "(", "masterChangelog", ".", "size", "(", ")", ")", ";", "for", "(", "int", "i", "=", "0", ",", "len", "=", "masterChangelog", ".", "size", "(", ")", ";", "i", "<", "len", ";", "i", "++", ")", "{", "int", "key", "=", "masterChangelog", ".", "keyAt", "(", "i", ")", ";", "// Use release information from localized change log and fall back to the master file", "// if necessary.", "ReleaseItem", "release", "=", "changelog", ".", "get", "(", "key", ",", "masterChangelog", ".", "get", "(", "key", ")", ")", ";", "mergedChangeLog", ".", "add", "(", "release", ")", ";", "}", "Collections", ".", "sort", "(", "mergedChangeLog", ",", "getChangeLogComparator", "(", ")", ")", ";", "return", "mergedChangeLog", ";", "}" ]

[ "Returns", "the", "merged", "change", "log", "." ]

[ "protected", "final", "SparseArray", "<", "ReleaseItem", ">", "readChangeLogFromResource", "(", "int", "resId", ",", "boolean", "full", ")", "{", "XmlResourceParser", "xml", "=", "mContext", ".", "getResources", "(", ")", ".", "getXml", "(", "resId", ")", ";", "try", "{", "return", "readChangeLog", "(", "xml", ",", "full", ")", ";", "}", "finally", "{", "xml", ".", "close", "(", ")", ";", "}", "}" ]

[ "Read", "change", "log", "from", "XML", "resource", "file", "." ]

[ "protected", "SparseArray", "<", "ReleaseItem", ">", "readChangeLog", "(", "XmlPullParser", "xml", ",", "boolean", "full", ")", "{", "SparseArray", "<", "ReleaseItem", ">", "result", "=", "new", "SparseArray", "<", "ReleaseItem", ">", "(", ")", ";", "try", "{", "int", "eventType", "=", "xml", ".", "getEventType", "(", ")", ";", "while", "(", "eventType", "!=", "XmlPullParser", ".", "END_DOCUMENT", ")", "{", "if", "(", "eventType", "==", "XmlPullParser", ".", "START_TAG", "&&", "xml", ".", "getName", "(", ")", ".", "equals", "(", "ReleaseTag", ".", "NAME", ")", ")", "{", "if", "(", "parseReleaseTag", "(", "xml", ",", "full", ",", "result", ")", ")", "{", "// Stop reading more elements if this entry is not newer than the last", "// version.", "break", ";", "}", "}", "eventType", "=", "xml", ".", "next", "(", ")", ";", "}", "}", "catch", "(", "XmlPullParserException", "e", ")", "{", "Log", ".", "e", "(", "LOG_TAG", ",", "e", ".", "getMessage", "(", ")", ",", "e", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "Log", ".", "e", "(", "LOG_TAG", ",", "e", ".", "getMessage", "(", ")", ",", "e", ")", ";", "}", "return", "result", ";", "}" ]

[ "Read", "the", "change", "log", "from", "an", "XML", "file", "." ]

[ "public", "List", "<", "String", ">", "orderedGroups", "(", ")", "{", "int", "groupCount", "=", "groupCount", "(", ")", ";", "List", "<", "String", ">", "groups", "=", "new", "ArrayList", "<", "String", ">", "(", "groupCount", ")", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<=", "groupCount", ";", "i", "++", ")", "{", "groups", ".", "add", "(", "group", "(", "i", ")", ")", ";", "}", "return", "groups", ";", "}" ]

[ "Gets", "a", "list", "of", "the", "matches", "in", "the", "order", "in", "which", "they", "occur", "in", "a", "matching", "input", "string" ]

[ "public", "String", "group", "(", "String", "groupName", ")", "{", "int", "idx", "=", "groupIndex", "(", "groupName", ")", ";", "if", "(", "idx", "<", "0", ")", "{", "throw", "new", "IndexOutOfBoundsException", "(", "\"No group \\\"\"", "+", "groupName", "+", "\"\\\"\"", ")", ";", "}", "return", "group", "(", "idx", ")", ";", "}" ]

[ "Returns", "the", "input", "subsequence", "captured", "by", "the", "named", "group", "during", "the", "previous", "match", "operation", "." ]

[ "public", "List", "<", "Map", "<", "String", ",", "String", ">", ">", "namedGroups", "(", ")", "{", "List", "<", "Map", "<", "String", ",", "String", ">", ">", "result", "=", "new", "ArrayList", "<", "Map", "<", "String", ",", "String", ">", ">", "(", ")", ";", "List", "<", "String", ">", "groupNames", "=", "parentPattern", ".", "groupNames", "(", ")", ";", "if", "(", "groupNames", ".", "isEmpty", "(", ")", ")", "{", "return", "result", ";", "}", "int", "nextIndex", "=", "0", ";", "while", "(", "matcher", ".", "find", "(", "nextIndex", ")", ")", "{", "Map", "<", "String", ",", "String", ">", "matches", "=", "new", "LinkedHashMap", "<", "String", ",", "String", ">", "(", ")", ";", "for", "(", "String", "groupName", ":", "groupNames", ")", "{", "String", "groupValue", "=", "matcher", ".", "group", "(", "groupIndex", "(", "groupName", ")", ")", ";", "matches", ".", "put", "(", "groupName", ",", "groupValue", ")", ";", "nextIndex", "=", "matcher", ".", "end", "(", ")", ";", "}", "result", ".", "add", "(", "matches", ")", ";", "}", "return", "result", ";", "}" ]

[ "Finds", "all", "named", "groups", "that", "exist", "in", "the", "input", "string", ".", "This", "resets", "the", "matcher", "and", "attempts", "to", "match", "the", "input", "against", "the", "pre", "-", "specified", "pattern", "." ]

[ "public", "List", "<", "String", ">", "groupNames", "(", ")", "{", "if", "(", "groupNames", "==", "null", ")", "{", "groupNames", "=", "new", "ArrayList", "<", "String", ">", "(", "groupInfo", ".", "keySet", "(", ")", ")", ";", "}", "return", "Collections", ".", "unmodifiableList", "(", "groupNames", ")", ";", "}" ]

[ "Gets", "the", "names", "of", "all", "capture", "groups" ]

[ "private", "boolean", "groupInfoMatches", "(", "Map", "<", "String", ",", "List", "<", "GroupInfo", ">", ">", "a", ",", "Map", "<", "String", ",", "List", "<", "GroupInfo", ">", ">", "b", ")", "{", "if", "(", "a", "==", "null", "&&", "b", "==", "null", ")", "{", "return", "true", ";", "}", "boolean", "isMatch", "=", "false", ";", "if", "(", "a", "!=", "null", "&&", "b", "!=", "null", ")", "{", "if", "(", "a", ".", "isEmpty", "(", ")", "&&", "b", ".", "isEmpty", "(", ")", ")", "{", "isMatch", "=", "true", ";", "}", "else", "if", "(", "a", ".", "size", "(", ")", "==", "b", ".", "size", "(", ")", ")", "{", "for", "(", "Entry", "<", "String", ",", "List", "<", "GroupInfo", ">", ">", "entry", ":", "a", ".", "entrySet", "(", ")", ")", "{", "List", "<", "GroupInfo", ">", "otherList", "=", "b", ".", "get", "(", "entry", ".", "getKey", "(", ")", ")", ";", "isMatch", "=", "(", "otherList", "!=", "null", ")", ";", "if", "(", "!", "isMatch", ")", "{", "break", ";", "}", "List", "<", "GroupInfo", ">", "thisList", "=", "entry", ".", "getValue", "(", ")", ";", "isMatch", "=", "otherList", ".", "containsAll", "(", "thisList", ")", "&&", "thisList", ".", "containsAll", "(", "otherList", ")", ";", "if", "(", "!", "isMatch", ")", "{", "break", ";", "}", "}", "}", "}", "return", "isMatch", ";", "}" ]

[ "Compares", "the", "keys", "and", "values", "of", "two", "group", "-", "info", "maps" ]

[ "private", "static", "double", "limitHprime", "(", "double", "hPrime", ")", "{", "hPrime", "/=", "360.0", ";", "final", "double", "limited", "=", "360.0", "*", "(", "hPrime", "-", "floor", "(", "hPrime", ")", ")", ";", "if", "(", "limited", "<", "-", "180.0", ")", "{", "return", "limited", "+", "360.0", ";", "}", "else", "if", "(", "limited", ">", "180.0", ")", "{", "return", "limited", "-", "360.0", ";", "}", "else", "{", "return", "limited", ";", "}", "}" ]

[ "limit", "H", "values", "according", "to", "A", ".", "2", ".", "11" ]

[ "public", "String", "lookupHttpCrossDomain", "(", "String", "httpsDomainName", ")", "{", "Iterator", "iter", "=", "crossDomainMappings", ".", "keySet", "(", ")", ".", "iterator", "(", ")", ";", "while", "(", "iter", ".", "hasNext", "(", ")", ")", "{", "String", "httpDomainName", "=", "(", "String", ")", "iter", ".", "next", "(", ")", ";", "if", "(", "crossDomainMappings", ".", "get", "(", "httpDomainName", ")", ".", "equals", "(", "httpsDomainName", ")", ")", "{", "return", "httpDomainName", ";", "}", "}", "return", "null", ";", "}" ]

[ "returns", "the", "HTTP", "domain", "Name" ]

[ "private", "void", "badRequest", "(", "HttpServletResponse", "res", ")", "throws", "IOException", "{", "res", ".", "setContentType", "(", "\"text/html\"", ")", ";", "PrintWriter", "pw", "=", "res", ".", "getWriter", "(", ")", ";", "pw", ".", "write", "(", "BAD_REQUEST", ")", ";", "pw", ".", "close", "(", ")", ";", "}" ]

[ "writes", "the", "Bad", "Request", "String", "in", "the", "Servlet", "response", "if", "condition", "falis" ]

[ "public", "static", "String", "getMD5", "(", "String", "md5Salt", ")", "{", "try", "{", "MessageDigest", "md", "=", "MessageDigest", ".", "getInstance", "(", "MD5", ")", ";", "byte", "[", "]", "array", "=", "md", ".", "digest", "(", "md5Salt", ".", "getBytes", "(", "UTF8", ")", ")", ";", "StringBuffer", "sb", "=", "new", "StringBuffer", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "array", ".", "length", ";", "++", "i", ")", "{", "sb", ".", "append", "(", "Integer", ".", "toHexString", "(", "(", "array", "[", "i", "]", "&", "0xFF", ")", "|", "0x100", ")", ".", "substring", "(", "1", ",", "3", ")", ")", ";", "}", "return", "sb", ".", "toString", "(", ")", ";", "}", "catch", "(", "java", ".", "security", ".", "NoSuchAlgorithmException", "e", ")", "{", "LOG", ".", "error", "(", "e", ".", "getMessage", "(", ")", ")", ";", "}", "catch", "(", "UnsupportedEncodingException", "e", ")", "{", "LOG", ".", "error", "(", "e", ".", "getMessage", "(", ")", ")", ";", "}", "return", "null", ";", "}" ]

[ "generates", "the", "MD5", "Hash", "value", "from", "given", "salt", "value" ]

[ "public", "static", "float", "compare", "(", "final", "int", "numOfBits", ",", "final", "String", "str1", ",", "final", "String", "str2", ")", "{", "return", "compare", "(", "numOfBits", ",", "BaseEncoding", ".", "base64", "(", ")", ".", "decode", "(", "str1", ")", ",", "BaseEncoding", ".", "base64", "(", ")", ".", "decode", "(", "str2", ")", ")", ";", "}" ]

[ "Compare", "base64", "strings", "for", "MinHash", "." ]

[ "public", "static", "float", "compare", "(", "final", "int", "numOfBits", ",", "final", "byte", "[", "]", "data1", ",", "final", "byte", "[", "]", "data2", ")", "{", "if", "(", "data1", ".", "length", "!=", "data2", ".", "length", ")", "{", "return", "0", ";", "}", "final", "int", "count", "=", "countSameBits", "(", "data1", ",", "data2", ")", ";", "return", "(", "float", ")", "count", "/", "(", "float", ")", "numOfBits", ";", "}" ]

[ "Compare", "bytes", "for", "MinHash", "." ]

[ "public", "static", "HashFunction", "[", "]", "createHashFunctions", "(", "final", "int", "seed", ",", "final", "int", "num", ")", "{", "final", "HashFunction", "[", "]", "hashFunctions", "=", "new", "HashFunction", "[", "num", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "num", ";", "i", "++", ")", "{", "hashFunctions", "[", "i", "]", "=", "Hashing", ".", "murmur3_128", "(", "seed", "+", "i", ")", ";", "}", "return", "hashFunctions", ";", "}" ]

[ "Create", "hash", "functions", "." ]

[ "public", "static", "String", "toBinaryString", "(", "final", "byte", "[", "]", "data", ")", "{", "if", "(", "data", "==", "null", ")", "{", "return", "null", ";", "}", "final", "StringBuilder", "buf", "=", "new", "StringBuilder", "(", "data", ".", "length", "*", "8", ")", ";", "for", "(", "final", "byte", "element", ":", "data", ")", "{", "byte", "bits", "=", "element", ";", "for", "(", "int", "j", "=", "0", ";", "j", "<", "8", ";", "j", "++", ")", "{", "if", "(", "(", "bits", "&", "0x80", ")", "==", "0x80", ")", "{", "buf", ".", "append", "(", "'", "'", ")", ";", "}", "else", "{", "buf", ".", "append", "(", "'", "'", ")", ";", "}", "bits", "<<=", "1", ";", "}", "}", "return", "buf", ".", "toString", "(", ")", ";", "}" ]

[ "Returns", "a", "string", "formatted", "by", "bits", "." ]

[ "public", "static", "int", "bitCount", "(", "final", "byte", "[", "]", "data", ")", "{", "int", "count", "=", "0", ";", "for", "(", "final", "byte", "element", ":", "data", ")", "{", "byte", "bits", "=", "element", ";", "for", "(", "int", "j", "=", "0", ";", "j", "<", "8", ";", "j", "++", ")", "{", "if", "(", "(", "bits", "&", "1", ")", "==", "1", ")", "{", "count", "++", ";", "}", "bits", ">>=", "1", ";", "}", "}", "return", "count", ";", "}" ]

[ "Count", "the", "number", "of", "true", "bits", "." ]

[ "public", "static", "Analyzer", "createAnalyzer", "(", "final", "Tokenizer", "tokenizer", ",", "final", "int", "hashBit", ",", "final", "int", "seed", ",", "final", "int", "num", ")", "{", "final", "HashFunction", "[", "]", "hashFunctions", "=", "MinHash", ".", "createHashFunctions", "(", "seed", ",", "num", ")", ";", "final", "Analyzer", "minhashAnalyzer", "=", "new", "Analyzer", "(", ")", "{", "@", "Override", "protected", "TokenStreamComponents", "createComponents", "(", "final", "String", "fieldName", ")", "{", "final", "TokenStream", "stream", "=", "new", "MinHashTokenFilter", "(", "tokenizer", ",", "hashFunctions", ",", "hashBit", ")", ";", "return", "new", "TokenStreamComponents", "(", "tokenizer", ",", "stream", ")", ";", "}", "}", ";", "return", "minhashAnalyzer", ";", "}" ]

[ "Create", "an", "analyzer", "to", "calculate", "a", "minhash", "." ]

[ "public", "static", "Data", "newData", "(", "final", "Analyzer", "analyzer", ",", "final", "String", "text", ",", "final", "int", "numOfBits", ")", "{", "return", "new", "Data", "(", "analyzer", ",", "text", ",", "numOfBits", ")", ";", "}" ]

[ "Create", "a", "target", "data", "which", "has", "analyzer", "text", "and", "the", "number", "of", "bits", "." ]

[ "public", "void", "defineMethod", "(", "String", "methodName", ",", "int", "modifiers", ",", "String", "signature", ",", "CodeBlock", "methodBody", ")", "{", "this", ".", "methods", ".", "add", "(", "new", "MethodDefinition", "(", "methodName", ",", "modifiers", ",", "signature", ",", "methodBody", ")", ")", ";", "}" ]

[ "Defines", "a", "new", "method", "on", "the", "target", "class" ]

[ "public", "FieldDefinition", "defineField", "(", "String", "fieldName", ",", "int", "modifiers", ",", "String", "signature", ",", "Object", "value", ")", "{", "FieldDefinition", "field", "=", "new", "FieldDefinition", "(", "fieldName", ",", "modifiers", ",", "signature", ",", "value", ")", ";", "this", ".", "fields", ".", "add", "(", "field", ")", ";", "return", "field", ";", "}" ]

[ "Defines", "a", "new", "field", "on", "the", "target", "class" ]

[ "public", "byte", "[", "]", "toBytes", "(", "JDKVersion", "version", ")", "{", "ClassNode", "node", "=", "new", "ClassNode", "(", ")", ";", "node", ".", "version", "=", "version", ".", "getVer", "(", ")", ";", "node", ".", "access", "=", "this", ".", "access", "|", "ACC_SUPER", ";", "node", ".", "name", "=", "this", ".", "className", ";", "node", ".", "superName", "=", "this", ".", "superClassName", ";", "node", ".", "sourceFile", "=", "this", ".", "sourceFile", ";", "node", ".", "sourceDebug", "=", "this", ".", "sourceDebug", ";", "if", "(", "parentClassName", "!=", "null", ")", "{", "node", ".", "visitOuterClass", "(", "parentClassName", ",", "null", ",", "null", ")", ";", "}", "for", "(", "ChildEntry", "child", ":", "childClasses", ")", "{", "node", ".", "visitInnerClass", "(", "child", ".", "getClassName", "(", ")", ",", "className", ",", "child", ".", "getInnerName", "(", ")", ",", "child", ".", "getAccess", "(", ")", ")", ";", "}", "if", "(", "!", "this", ".", "interfaces", ".", "isEmpty", "(", ")", ")", "{", "node", ".", "interfaces", ".", "addAll", "(", "this", ".", "interfaces", ")", ";", "}", "for", "(", "MethodDefinition", "def", ":", "methods", ")", "{", "node", ".", "methods", ".", "add", "(", "def", ".", "getMethodNode", "(", ")", ")", ";", "}", "for", "(", "FieldDefinition", "def", ":", "fields", ")", "{", "node", ".", "fields", ".", "add", "(", "def", ".", "getFieldNode", "(", ")", ")", ";", "}", "if", "(", "node", ".", "visibleAnnotations", "==", "null", ")", "{", "node", ".", "visibleAnnotations", "=", "new", "ArrayList", "<", "AnnotationNode", ">", "(", ")", ";", "}", "for", "(", "VisibleAnnotation", "a", ":", "annotations", ")", "{", "node", ".", "visibleAnnotations", ".", "add", "(", "a", ".", "getNode", "(", ")", ")", ";", "}", "ClassWriter", "cw", "=", "new", "ClassWriter", "(", "ClassWriter", ".", "COMPUTE_FRAMES", ")", ";", "node", ".", "accept", "(", "cw", ")", ";", "return", "cw", ".", "toByteArray", "(", ")", ";", "}" ]

[ "Convert", "this", "class", "representation", "to", "JDK", "bytecode" ]

[ "public", "CodeBlock", "frame_same", "(", "final", "Object", "...", "stackArguments", ")", "{", "final", "int", "type", ";", "switch", "(", "stackArguments", ".", "length", ")", "{", "case", "0", ":", "type", "=", "Opcodes", ".", "F_SAME", ";", "break", ";", "case", "1", ":", "type", "=", "Opcodes", ".", "F_SAME1", ";", "break", ";", "default", ":", "throw", "new", "IllegalArgumentException", "(", "\"same frame should have 0\"", "+", "\" or 1 arguments on stack\"", ")", ";", "}", "instructionList", ".", "add", "(", "new", "FrameNode", "(", "type", ",", "0", ",", "null", ",", "stackArguments", ".", "length", ",", "stackArguments", ")", ")", ";", "return", "this", ";", "}" ]

[ "adds", "a", "compressed", "frame", "to", "the", "stack" ]

[ "public", "void", "registerServiceConfiguration", "(", "String", "id", ",", "String", "configFile", ",", "DescribeService", "service", ")", "throws", "POIProxyException", "{", "if", "(", "service", "==", "null", "||", "configFile", "==", "null", "||", "service", ".", "getId", "(", ")", "==", "null", ")", "{", "throw", "new", "POIProxyException", "(", "\"Null service configuration\"", ")", ";", "}", "this", ".", "registeredConfigurations", ".", "put", "(", "id", ",", "configFile", ")", ";", "this", ".", "parsedConfigurations", ".", "put", "(", "id", ",", "service", ")", ";", "try", "{", "this", ".", "save", "(", "id", ",", "configFile", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "new", "POIProxyException", "(", "\"Unable to write service configuration\"", ")", ";", "}", "}" ]

[ "Registers", "a", "new", "service", "into", "the", "library" ]

[ "public", "String", "getServiceAsJSON", "(", "String", "id", ")", "{", "String", "path", "=", "this", ".", "registeredConfigurations", ".", "get", "(", "id", ")", ";", "if", "(", "path", "==", "null", ")", "{", "return", "null", ";", "}", "// cargar fichero de disco obtener el json y parsearlo", "File", "f", "=", "new", "File", "(", "CONFIGURATION_DIR", "+", "File", ".", "separator", "+", "path", ")", ";", "FileInputStream", "fis", "=", "null", ";", "InputStream", "in", "=", "null", ";", "OutputStream", "out", "=", "null", ";", "String", "res", "=", "null", ";", "try", "{", "fis", "=", "new", "FileInputStream", "(", "f", ")", ";", "in", "=", "new", "BufferedInputStream", "(", "fis", ",", "Constants", ".", "IO_BUFFER_SIZE", ")", ";", "final", "ByteArrayOutputStream", "dataStream", "=", "new", "ByteArrayOutputStream", "(", ")", ";", "out", "=", "new", "BufferedOutputStream", "(", "dataStream", ",", "Constants", ".", "IO_BUFFER_SIZE", ")", ";", "byte", "[", "]", "b", "=", "new", "byte", "[", "8", "*", "1024", "]", ";", "int", "read", ";", "while", "(", "(", "read", "=", "in", ".", "read", "(", "b", ")", ")", "!=", "-", "1", ")", "{", "out", ".", "write", "(", "b", ",", "0", ",", "read", ")", ";", "}", "out", ".", "flush", "(", ")", ";", "res", "=", "new", "String", "(", "dataStream", ".", "toByteArray", "(", ")", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "e", ".", "printStackTrace", "(", ")", ";", "return", "null", ";", "}", "finally", "{", "Constants", ".", "closeStream", "(", "fis", ")", ";", "Constants", ".", "closeStream", "(", "in", ")", ";", "Constants", ".", "closeStream", "(", "out", ")", ";", "}", "return", "res", ";", "}" ]

[ "Returns", "the", "content", "of", "the", "json", "document", "describing", "a", "service", "given", "its", "id" ]

[ "static", "void", "printClassPath", "(", ")", "{", "URLClassLoader", "sysLoader", "=", "(", "URLClassLoader", ")", "ClassLoader", ".", "getSystemClassLoader", "(", ")", ";", "if", "(", "sysLoader", "==", "null", ")", "{", "System", ".", "out", ".", "println", "(", "\"No system class loader. (Maybe means bootstrap class loader is being used?)\"", ")", ";", "}", "else", "{", "System", ".", "out", ".", "println", "(", "\"Classpath:\"", ")", ";", "for", "(", "URL", "url", ":", "sysLoader", ".", "getURLs", "(", ")", ")", "{", "System", ".", "out", ".", "println", "(", "url", ".", "getFile", "(", ")", ")", ";", "}", "}", "}" ]

[ "Print", "the", "classpath", "." ]

[ "public", "String", "[", "]", "parse", "(", "String", "[", "]", "args", ")", "throws", "ArgException", "{", "List", "<", "String", ">", "nonOptions", "=", "new", "ArrayList", "<>", "(", ")", ";", "// If true, then \"--\" has been seen and any argument starting with \"-\"", "// is processed as an ordinary argument, not as an option.", "boolean", "ignoreOptions", "=", "false", ";", "// Loop through each argument", "String", "tail", "=", "\"\"", ";", "String", "arg", ";", "for", "(", "int", "ii", "=", "0", ";", "ii", "<", "args", ".", "length", ";", ")", "{", "// If there was a ',' separator in previous arg, use the tail as", "// current arg; otherwise, fetch the next arg from args list.", "if", "(", "tail", ".", "length", "(", ")", ">", "0", ")", "{", "arg", "=", "tail", ";", "tail", "=", "\"\"", ";", "}", "else", "{", "arg", "=", "args", "[", "ii", "]", ";", "}", "if", "(", "arg", ".", "equals", "(", "\"--\"", ")", ")", "{", "ignoreOptions", "=", "true", ";", "}", "else", "if", "(", "(", "arg", ".", "startsWith", "(", "\"--\"", ")", "||", "arg", ".", "startsWith", "(", "\"-\"", ")", ")", "&&", "!", "ignoreOptions", ")", "{", "String", "argName", ";", "String", "argValue", ";", "// Allow ',' as an argument separator to get around", "// some command line quoting problems. (markro)", "int", "splitPos", "=", "arg", ".", "indexOf", "(", "\",-\"", ")", ";", "if", "(", "splitPos", "==", "0", ")", "{", "// Just discard the ',' if \",-\" occurs at begining of string", "arg", "=", "arg", ".", "substring", "(", "1", ")", ";", "splitPos", "=", "arg", ".", "indexOf", "(", "\",-\"", ")", ";", "}", "if", "(", "splitPos", ">", "0", ")", "{", "tail", "=", "arg", ".", "substring", "(", "splitPos", "+", "1", ")", ";", "arg", "=", "arg", ".", "substring", "(", "0", ",", "splitPos", ")", ";", "}", "int", "eqPos", "=", "arg", ".", "indexOf", "(", "'", "'", ")", ";", "if", "(", "eqPos", "==", "-", "1", ")", "{", "argName", "=", "arg", ";", "argValue", "=", "null", ";", "}", "else", "{", "argName", "=", "arg", ".", "substring", "(", "0", ",", "eqPos", ")", ";", "argValue", "=", "arg", ".", "substring", "(", "eqPos", "+", "1", ")", ";", "}", "OptionInfo", "oi", "=", "nameMap", ".", "get", "(", "argName", ")", ";", "if", "(", "oi", "==", "null", ")", "{", "StringBuilder", "msg", "=", "new", "StringBuilder", "(", ")", ";", "msg", ".", "append", "(", "String", ".", "format", "(", "\"unknown option name '%s' in arg '%s'\"", ",", "argName", ",", "arg", ")", ")", ";", "if", "(", "false", ")", "{", "// for debugging", "msg", ".", "append", "(", "\"; known options:\"", ")", ";", "for", "(", "String", "optionName", ":", "sortedKeySet", "(", "nameMap", ")", ")", "{", "msg", ".", "append", "(", "\" \"", ")", ";", "msg", ".", "append", "(", "optionName", ")", ";", "}", "}", "throw", "new", "ArgException", "(", "msg", ".", "toString", "(", ")", ")", ";", "}", "if", "(", "oi", ".", "argumentRequired", "(", ")", "&&", "(", "argValue", "==", "null", ")", ")", "{", "ii", "++", ";", "if", "(", "ii", ">=", "args", ".", "length", ")", "{", "throw", "new", "ArgException", "(", "\"option %s requires an argument\"", ",", "arg", ")", ";", "}", "argValue", "=", "args", "[", "ii", "]", ";", "}", "// System.out.printf (\"argName = '%s', argValue='%s'%n\", argName,", "// argValue);", "setArg", "(", "oi", ",", "argName", ",", "argValue", ")", ";", "}", "else", "{", "// not an option", "if", "(", "!", "parseAfterArg", ")", "{", "ignoreOptions", "=", "true", ";", "}", "nonOptions", ".", "add", "(", "arg", ")", ";", "}", "// If no ',' tail, advance to next args option", "if", "(", "tail", ".", "length", "(", ")", "==", "0", ")", "{", "ii", "++", ";", "}", "}", "String", "[", "]", "result", "=", "nonOptions", ".", "toArray", "(", "new", "String", "[", "nonOptions", ".", "size", "(", ")", "]", ")", ";", "return", "result", ";", "}" ]

[ "Sets", "option", "variables", "from", "the", "given", "command", "line", "." ]

[ "public", "String", "[", "]", "parse", "(", "String", "message", ",", "String", "[", "]", "args", ")", "{", "String", "[", "]", "nonOptions", "=", "null", ";", "try", "{", "nonOptions", "=", "parse", "(", "args", ")", ";", "}", "catch", "(", "ArgException", "ae", ")", "{", "String", "exceptionMessage", "=", "ae", ".", "getMessage", "(", ")", ";", "if", "(", "exceptionMessage", "!=", "null", ")", "{", "System", ".", "out", ".", "println", "(", "exceptionMessage", ")", ";", "}", "System", ".", "out", ".", "println", "(", "message", ")", ";", "System", ".", "exit", "(", "-", "1", ")", ";", "// throw new Error (\"message error: \", ae);", "}", "return", "nonOptions", ";", "}" ]

[ "Sets", "option", "variables", "from", "the", "given", "command", "line", ";", "if", "any", "command", "-", "line", "argument", "is", "illegal", "prints", "the", "given", "message", "and", "terminates", "the", "program", "." ]

[ "public", "void", "printUsage", "(", "PrintStream", "ps", ")", "{", "hasListOption", "=", "false", ";", "if", "(", "usageSynopsis", "!=", "null", ")", "{", "ps", ".", "printf", "(", "\"Usage: %s%n\"", ",", "usageSynopsis", ")", ";", "}", "ps", ".", "println", "(", "usage", "(", ")", ")", ";", "if", "(", "hasListOption", ")", "{", "ps", ".", "println", "(", ")", ";", "ps", ".", "println", "(", "LIST_HELP", ")", ";", "}", "}" ]

[ "Prints", "usage", "information", "to", "the", "given", "PrintStream", ".", "Uses", "the", "usage", "synopsis", "passed", "into", "the", "constructor", "if", "any", "." ]

[ "public", "String", "usage", "(", "boolean", "showUnpublicized", ",", "String", "...", "groupNames", ")", "{", "if", "(", "!", "hasGroups", ")", "{", "if", "(", "groupNames", ".", "length", ">", "0", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"This instance of Options does not have any option groups defined\"", ")", ";", "}", "return", "formatOptions", "(", "options", ",", "maxOptionLength", "(", "options", ",", "showUnpublicized", ")", ",", "showUnpublicized", ")", ";", "}", "List", "<", "OptionGroupInfo", ">", "groups", "=", "new", "ArrayList", "<>", "(", ")", ";", "if", "(", "groupNames", ".", "length", ">", "0", ")", "{", "for", "(", "String", "groupName", ":", "groupNames", ")", "{", "if", "(", "!", "groupMap", ".", "containsKey", "(", "groupName", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"invalid option group: \"", "+", "groupName", ")", ";", "}", "OptionGroupInfo", "gi", "=", "groupMap", ".", "get", "(", "groupName", ")", ";", "if", "(", "!", "showUnpublicized", "&&", "!", "gi", ".", "anyPublicized", "(", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"group does not contain any publicized options: \"", "+", "groupName", ")", ";", "}", "else", "{", "groups", ".", "add", "(", "groupMap", ".", "get", "(", "groupName", ")", ")", ";", "}", "}", "}", "else", "{", "// return usage for all groups that are not unpublicized", "for", "(", "OptionGroupInfo", "gi", ":", "groupMap", ".", "values", "(", ")", ")", "{", "if", "(", "(", "gi", ".", "unpublicized", "||", "!", "gi", ".", "anyPublicized", "(", ")", ")", "&&", "!", "showUnpublicized", ")", "{", "continue", ";", "}", "groups", ".", "add", "(", "gi", ")", ";", "}", "}", "List", "<", "Integer", ">", "lengths", "=", "new", "ArrayList", "<>", "(", ")", ";", "for", "(", "OptionGroupInfo", "gi", ":", "groups", ")", "{", "lengths", ".", "add", "(", "maxOptionLength", "(", "gi", ".", "optionList", ",", "showUnpublicized", ")", ")", ";", "}", "int", "maxLength", "=", "Collections", ".", "max", "(", "lengths", ")", ";", "StringJoiner", "buf", "=", "new", "StringJoiner", "(", "lineSeparator", ")", ";", "for", "(", "OptionGroupInfo", "gi", ":", "groups", ")", "{", "buf", ".", "add", "(", "String", ".", "format", "(", "\"%n%s:\"", ",", "gi", ".", "name", ")", ")", ";", "buf", ".", "add", "(", "formatOptions", "(", "gi", ".", "optionList", ",", "maxLength", ",", "showUnpublicized", ")", ")", ";", "}", "return", "buf", ".", "toString", "(", ")", ";", "}" ]

[ "Returns", "a", "usage", "message", "for", "command", "-", "line", "options", "." ]

[ "private", "int", "maxOptionLength", "(", "List", "<", "OptionInfo", ">", "optList", ",", "boolean", "showUnpublicized", ")", "{", "int", "maxLength", "=", "0", ";", "for", "(", "OptionInfo", "oi", ":", "optList", ")", "{", "if", "(", "oi", ".", "unpublicized", "&&", "!", "showUnpublicized", ")", "{", "continue", ";", "}", "int", "len", "=", "oi", ".", "synopsis", "(", ")", ".", "length", "(", ")", ";", "if", "(", "len", ">", "maxLength", ")", "{", "maxLength", "=", "len", ";", "}", "}", "return", "maxLength", ";", "}" ]

[ "Return", "the", "length", "of", "the", "longest", "synopsis", "message", "in", "a", "list", "of", "options", ".", "Useful", "for", "aligning", "options", "in", "usage", "strings", "." ]

[ "@", "SuppressWarnings", "(", "\"nullness\"", ")", "// static method, so null first arg is OK: oi.factory", "private", "@", "NonNull", "Object", "getRefArg", "(", "OptionInfo", "oi", ",", "String", "argName", ",", "String", "argValue", ")", "throws", "ArgException", "{", "Object", "val", ";", "try", "{", "if", "(", "oi", ".", "constructor", "!=", "null", ")", "{", "val", "=", "oi", ".", "constructor", ".", "newInstance", "(", "new", "Object", "[", "]", "{", "argValue", "}", ")", ";", "}", "else", "if", "(", "oi", ".", "baseType", ".", "isEnum", "(", ")", ")", "{", "@", "SuppressWarnings", "(", "{", "\"unchecked\"", ",", "\"rawtypes\"", "}", ")", "Object", "tmpVal", "=", "getEnumValue", "(", "(", "Class", "<", "Enum", ">", ")", "oi", ".", "baseType", ",", "argValue", ")", ";", "val", "=", "tmpVal", ";", "}", "else", "{", "if", "(", "oi", ".", "factory", "==", "null", ")", "{", "throw", "new", "Error", "(", "\"No constructor or factory for argument \"", "+", "argName", ")", ";", "}", "if", "(", "oi", ".", "factoryArg2", "==", "null", ")", "{", "val", "=", "oi", ".", "factory", ".", "invoke", "(", "null", ",", "argValue", ")", ";", "}", "else", "{", "val", "=", "oi", ".", "factory", ".", "invoke", "(", "null", ",", "argValue", ",", "oi", ".", "factoryArg2", ")", ";", "}", "}", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "ArgException", "(", "\"Invalid argument (%s) for argument %s\"", ",", "argValue", ",", "argName", ")", ";", "}", "return", "val", ";", "}" ]

[ "Given", "a", "value", "string", "supplied", "on", "the", "command", "line", "create", "an", "object", ".", "The", "only", "expected", "error", "is", "some", "sort", "of", "parse", "error", "from", "the", "constructor", "." ]

[ "public", "String", "settings", "(", "boolean", "showUnpublicized", ")", "{", "StringJoiner", "out", "=", "new", "StringJoiner", "(", "lineSeparator", ")", ";", "// Determine the length of the longest name", "int", "maxLength", "=", "maxOptionLength", "(", "options", ",", "showUnpublicized", ")", ";", "// Create the settings string", "for", "(", "OptionInfo", "oi", ":", "options", ")", "{", "@", "SuppressWarnings", "(", "\"formatter\"", ")", "// format string computed from maxLength", "String", "use", "=", "String", ".", "format", "(", "\"%-\"", "+", "maxLength", "+", "\"s = \"", ",", "oi", ".", "longName", ")", ";", "try", "{", "use", "+=", "oi", ".", "field", ".", "get", "(", "oi", ".", "obj", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "Error", "(", "\"unexpected exception reading field \"", "+", "oi", ".", "field", ",", "e", ")", ";", "}", "out", ".", "add", "(", "use", ")", ";", "}", "return", "out", ".", "toString", "(", ")", ";", "}" ]

[ "Returns", "a", "string", "containing", "the", "current", "setting", "for", "each", "option", "in", "command", "-", "line", "format", "that", "can", "be", "parsed", "by", "Options", ".", "Contains", "every", "known", "option", "even", "if", "the", "option", "was", "not", "specified", "on", "the", "command", "line", ".", "Never", "contains", "duplicates", "." ]

[ "public", "String", "payload", "(", "int", "index", ")", "{", "return", "payload", ".", "size", "(", ")", ">", "index", "?", "payload", ".", "get", "(", "index", ")", ":", "null", ";", "}" ]

[ "Returns", "a", "payload", "at", "index", "or", "null", "if", "no", "payload", "found", "there" ]

[ "public", "static", "String", "generateToken", "(", "byte", "[", "]", "secret", ",", "long", "seconds", ",", "String", "oid", ",", "String", "...", "payload", ")", "{", "long", "due", "=", "Life", ".", "due", "(", "seconds", ")", ";", "List", "<", "String", ">", "l", "=", "new", "ArrayList", "<", "String", ">", "(", "2", "+", "payload", ".", "length", ")", ";", "l", ".", "add", "(", "oid", ")", ";", "l", ".", "add", "(", "String", ".", "valueOf", "(", "due", ")", ")", ";", "l", ".", "addAll", "(", "C", ".", "listOf", "(", "payload", ")", ")", ";", "String", "s", "=", "S", ".", "join", "(", "\"|\"", ",", "l", ")", ";", "return", "Crypto", ".", "encryptAES", "(", "s", ",", "secret", ")", ";", "}" ]

[ "Generate", "a", "token", "string", "with", "secret", "key", "ID", "and", "optionally", "payloads" ]

[ "@", "SuppressWarnings", "(", "\"unused\"", ")", "public", "static", "boolean", "isTokenValid", "(", "byte", "[", "]", "secret", ",", "String", "oid", ",", "String", "token", ")", "{", "if", "(", "S", ".", "anyBlank", "(", "oid", ",", "token", ")", ")", "{", "return", "false", ";", "}", "String", "s", "=", "Crypto", ".", "decryptAES", "(", "token", ",", "secret", ")", ";", "String", "[", "]", "sa", "=", "s", ".", "split", "(", "\"\\\\|\"", ")", ";", "if", "(", "sa", ".", "length", "<", "2", ")", "return", "false", ";", "if", "(", "!", "S", ".", "isEqual", "(", "oid", ",", "sa", "[", "0", "]", ")", ")", "return", "false", ";", "try", "{", "long", "due", "=", "Long", ".", "parseLong", "(", "sa", "[", "1", "]", ")", ";", "return", "(", "due", "<", "1", "||", "due", ">", "System", ".", "currentTimeMillis", "(", ")", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "return", "false", ";", "}", "}" ]

[ "Check", "if", "a", "string", "is", "a", "valid", "token" ]

[ "public", "DescribeService", "parse", "(", "String", "json", ")", "{", "Gson", "gson", "=", "createGSON", "(", ")", ";", "return", "gson", ".", "fromJson", "(", "json", ",", "DescribeService", ".", "class", ")", ";", "}" ]

[ "Parses", "a", "describe", "service", "json", "document", "passed", "as", "a", "String" ]

[ "public", "List", "<", "List", "<", "List", "<", "Double", ">", ">", ">", "getCoordinates", "(", ")", "{", "List", "<", "List", "<", "List", "<", "Double", ">>>", "polygon", "=", "new", "ArrayList", "<", "List", "<", "List", "<", "Double", ">", ">", ">", "(", ")", ";", "for", "(", "LineString", "lineString", ":", "coordinates", ")", "{", "polygon", ".", "add", "(", "lineString", ".", "getCoordinates", "(", ")", ")", ";", "}", "return", "polygon", ";", "}" ]

[ "Should", "throw", "is", "not", "a", "polygon", "exception" ]

[ "public", "List", "<", "String", ">", "getServicesIDByCategory", "(", "String", "category", ")", "{", "Set", "<", "String", ">", "servicesID", "=", "services", ".", "keySet", "(", ")", ";", "Iterator", "<", "String", ">", "it", "=", "servicesID", ".", "iterator", "(", ")", ";", "List", "<", "String", ">", "ids", "=", "new", "ArrayList", "<", "String", ">", "(", ")", ";", "if", "(", "category", "==", "null", ")", "{", "return", "ids", ";", "}", "String", "key", ";", "while", "(", "it", ".", "hasNext", "(", ")", ")", "{", "key", "=", "it", ".", "next", "(", ")", ";", "DescribeService", "service", "=", "services", ".", "get", "(", "key", ")", ";", "if", "(", "service", ".", "containsCategory", "(", "category", ")", ")", "{", "ids", ".", "add", "(", "key", ")", ";", "}", "}", "return", "ids", ";", "}" ]

[ "Iterates", "the", "list", "of", "registered", "services", "and", "for", "those", "that", "support", "the", "category", "passed", "as", "a", "parameter", "return", "their", "ID" ]

[ "public", "boolean", "supportsCategory", "(", "String", "category", ")", "{", "if", "(", "category", "==", "null", ")", "{", "return", "false", ";", "}", "List", "<", "String", ">", "categories", "=", "this", ".", "getCategories", "(", ")", ";", "for", "(", "String", "cat", ":", "categories", ")", "{", "if", "(", "cat", ".", "compareToIgnoreCase", "(", "category", ")", "==", "0", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Returns", "true", "if", "there", "is", "any", "service", "registered", "that", "supports", "the", "category", "parameter" ]

[ "private", "Param", "getQueryParam", "(", "List", "<", "Param", ">", "optionalParams", ")", "{", "for", "(", "Param", "p", ":", "optionalParams", ")", "{", "if", "(", "p", "==", "null", ")", "{", "continue", ";", "}", "if", "(", "p", ".", "getType", "(", ")", ".", "equals", "(", "ParamEnum", ".", "QUERY", ".", "name", ")", ")", "{", "return", "p", ";", "}", "}", "return", "null", ";", "}" ]

[ "FIXME", "Extract", "the", "ArrayList", "to", "a", "Class" ]

[ "public", "static", "boolean", "start", "(", "RootDoc", "root", ")", "{", "List", "<", "Object", ">", "objs", "=", "new", "ArrayList", "<>", "(", ")", ";", "for", "(", "ClassDoc", "doc", ":", "root", ".", "specifiedClasses", "(", ")", ")", "{", "// TODO: Class.forName() expects a binary name but doc.qualifiedName()", "// returns a fully qualified name. I do not know a good way to convert", "// between these two name formats. For now, we simply ignore inner", "// classes. This limitation can be removed when we figure out a better", "// way to go from ClassDoc to Class<?>.", "if", "(", "doc", ".", "containingClass", "(", ")", "!=", "null", ")", "{", "continue", ";", "}", "Class", "<", "?", ">", "clazz", ";", "try", "{", "@", "SuppressWarnings", "(", "\"signature\"", ")", "// Javadoc source code is not yet annotated", "@", "BinaryName", "String", "className", "=", "doc", ".", "qualifiedName", "(", ")", ";", "clazz", "=", "Class", ".", "forName", "(", "className", ",", "true", ",", "Thread", ".", "currentThread", "(", ")", ".", "getContextClassLoader", "(", ")", ")", ";", "}", "catch", "(", "ClassNotFoundException", "e", ")", "{", "e", ".", "printStackTrace", "(", ")", ";", "Options", ".", "printClassPath", "(", ")", ";", "return", "false", ";", "}", "if", "(", "needsInstantiation", "(", "clazz", ")", ")", "{", "try", "{", "Constructor", "<", "?", ">", "c", "=", "clazz", ".", "getDeclaredConstructor", "(", ")", ";", "c", ".", "setAccessible", "(", "true", ")", ";", "objs", ".", "add", "(", "c", ".", "newInstance", "(", "new", "Object", "[", "0", "]", ")", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "e", ".", "printStackTrace", "(", ")", ";", "return", "false", ";", "}", "}", "else", "{", "objs", ".", "add", "(", "clazz", ")", ";", "}", "}", "if", "(", "objs", ".", "isEmpty", "(", ")", ")", "{", "System", ".", "out", ".", "println", "(", "\"Error: no classes found\"", ")", ";", "return", "false", ";", "}", "Object", "[", "]", "objarray", "=", "objs", ".", "toArray", "(", ")", ";", "Options", "options", "=", "new", "Options", "(", "objarray", ")", ";", "if", "(", "options", ".", "getOptions", "(", ")", ".", "size", "(", ")", "<", "1", ")", "{", "System", ".", "out", ".", "println", "(", "\"Error: no @Option-annotated fields found\"", ")", ";", "return", "false", ";", "}", "OptionsDoclet", "o", "=", "new", "OptionsDoclet", "(", "root", ",", "options", ")", ";", "o", ".", "setOptions", "(", "root", ".", "options", "(", ")", ")", ";", "o", ".", "processJavadoc", "(", ")", ";", "try", "{", "o", ".", "write", "(", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "e", ".", "printStackTrace", "(", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Entry", "point", "for", "the", "doclet", "." ]

[ "public", "static", "int", "optionLength", "(", "String", "option", ")", "{", "if", "(", "option", ".", "equals", "(", "\"-help\"", ")", ")", "{", "System", ".", "out", ".", "printf", "(", "USAGE", ")", ";", "return", "1", ";", "}", "if", "(", "option", ".", "equals", "(", "\"-i\"", ")", "||", "option", ".", "equals", "(", "\"-classdoc\"", ")", "||", "option", ".", "equals", "(", "\"-singledash\"", ")", ")", "{", "return", "1", ";", "}", "if", "(", "option", ".", "equals", "(", "\"-docfile\"", ")", "||", "option", ".", "equals", "(", "\"-outfile\"", ")", "||", "option", ".", "equals", "(", "\"-format\"", ")", "||", "option", ".", "equals", "(", "\"-d\"", ")", ")", "{", "return", "2", ";", "}", "return", "0", ";", "}" ]

[ "Given", "a", "command", "-", "line", "option", "of", "this", "doclet", "returns", "the", "number", "of", "arguments", "you", "must", "specify", "on", "the", "command", "line", "for", "the", "given", "option", ".", "Returns", "0", "if", "the", "argument", "is", "not", "recognized", ".", "This", "method", "is", "automatically", "invoked", "by", "Javadoc", "." ]

[ "@", "SuppressWarnings", "(", "\"index\"", ")", "// dependent: os[1] is legal when optionLength(os[0])==2", "public", "static", "boolean", "validOptions", "(", "String", "[", "]", "@", "MinLen", "(", "1", ")", "[", "]", "options", ",", "DocErrorReporter", "reporter", ")", "{", "boolean", "hasDocFile", "=", "false", ";", "boolean", "hasOutFile", "=", "false", ";", "boolean", "hasDestDir", "=", "false", ";", "boolean", "hasFormat", "=", "false", ";", "boolean", "inPlace", "=", "false", ";", "String", "docFile", "=", "null", ";", "String", "outFile", "=", "null", ";", "for", "(", "int", "oi", "=", "0", ";", "oi", "<", "options", ".", "length", ";", "oi", "++", ")", "{", "String", "[", "]", "os", "=", "options", "[", "oi", "]", ";", "String", "opt", "=", "os", "[", "0", "]", ".", "toLowerCase", "(", ")", ";", "if", "(", "opt", ".", "equals", "(", "\"-docfile\"", ")", ")", "{", "if", "(", "hasDocFile", ")", "{", "reporter", ".", "printError", "(", "\"-docfile option specified twice\"", ")", ";", "return", "false", ";", "}", "docFile", "=", "os", "[", "1", "]", ";", "File", "f", "=", "new", "File", "(", "docFile", ")", ";", "if", "(", "!", "f", ".", "exists", "(", ")", ")", "{", "reporter", ".", "printError", "(", "\"-docfile file not found: \"", "+", "docFile", ")", ";", "return", "false", ";", "}", "hasDocFile", "=", "true", ";", "}", "if", "(", "opt", ".", "equals", "(", "\"-outfile\"", ")", ")", "{", "if", "(", "hasOutFile", ")", "{", "reporter", ".", "printError", "(", "\"-outfile option specified twice\"", ")", ";", "return", "false", ";", "}", "if", "(", "inPlace", ")", "{", "reporter", ".", "printError", "(", "\"-i and -outfile can not be used at the same time\"", ")", ";", "return", "false", ";", "}", "outFile", "=", "os", "[", "1", "]", ";", "hasOutFile", "=", "true", ";", "}", "if", "(", "opt", ".", "equals", "(", "\"-i\"", ")", ")", "{", "if", "(", "hasOutFile", ")", "{", "reporter", ".", "printError", "(", "\"-i and -outfile can not be used at the same time\"", ")", ";", "return", "false", ";", "}", "inPlace", "=", "true", ";", "}", "if", "(", "opt", ".", "equals", "(", "\"-format\"", ")", ")", "{", "if", "(", "hasFormat", ")", "{", "reporter", ".", "printError", "(", "\"-format option specified twice\"", ")", ";", "return", "false", ";", "}", "String", "format", "=", "os", "[", "1", "]", ";", "if", "(", "!", "format", ".", "equals", "(", "\"javadoc\"", ")", "&&", "!", "format", ".", "equals", "(", "\"html\"", ")", ")", "{", "reporter", ".", "printError", "(", "\"unrecognized output format: \"", "+", "format", ")", ";", "return", "false", ";", "}", "hasFormat", "=", "true", ";", "}", "if", "(", "opt", ".", "equals", "(", "\"-d\"", ")", ")", "{", "if", "(", "hasDestDir", ")", "{", "reporter", ".", "printError", "(", "\"-d specified twice\"", ")", ";", "return", "false", ";", "}", "hasDestDir", "=", "true", ";", "}", "}", "if", "(", "docFile", "!=", "null", "&&", "outFile", "!=", "null", "&&", "outFile", ".", "equals", "(", "docFile", ")", ")", "{", "reporter", ".", "printError", "(", "\"docfile must be different from outfile\"", ")", ";", "return", "false", ";", "}", "if", "(", "inPlace", "&&", "docFile", "==", "null", ")", "{", "reporter", ".", "printError", "(", "\"-i supplied but -docfile was not\"", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Tests", "the", "validity", "of", "command", "-", "line", "arguments", "passed", "to", "this", "doclet", ".", "Returns", "true", "if", "the", "option", "usage", "is", "valid", "and", "false", "otherwise", ".", "This", "method", "is", "automatically", "invoked", "by", "Javadoc", "." ]

[ "public", "void", "write", "(", ")", "throws", "Exception", "{", "PrintWriter", "out", ";", "String", "output", "=", "output", "(", ")", ";", "if", "(", "outFile", "!=", "null", ")", "{", "out", "=", "new", "PrintWriter", "(", "Files", ".", "newBufferedWriter", "(", "outFile", ".", "toPath", "(", ")", ",", "UTF_8", ")", ")", ";", "}", "else", "if", "(", "inPlace", ")", "{", "assert", "docFile", "!=", "null", ":", "\"@AssumeAssertion(nullness): dependent: docFile is non-null if inPlace is true\"", ";", "out", "=", "new", "PrintWriter", "(", "Files", ".", "newBufferedWriter", "(", "docFile", ".", "toPath", "(", ")", ",", "UTF_8", ")", ")", ";", "}", "else", "{", "out", "=", "new", "PrintWriter", "(", "new", "BufferedWriter", "(", "new", "OutputStreamWriter", "(", "System", ".", "out", ",", "UTF_8", ")", ")", ")", ";", "}", "out", ".", "println", "(", "output", ")", ";", "out", ".", "flush", "(", ")", ";", "out", ".", "close", "(", ")", ";", "}" ]

[ "Write", "the", "output", "of", "this", "doclet", "to", "the", "correct", "file", "." ]

[ "@", "RequiresNonNull", "(", "\"docFile\"", ")", "private", "String", "newDocFileText", "(", ")", "throws", "Exception", "{", "StringJoiner", "b", "=", "new", "StringJoiner", "(", "lineSep", ")", ";", "BufferedReader", "doc", "=", "Files", ".", "newBufferedReader", "(", "docFile", ".", "toPath", "(", ")", ",", "UTF_8", ")", ";", "String", "docline", ";", "boolean", "replacing", "=", "false", ";", "boolean", "replacedOnce", "=", "false", ";", "String", "prefix", "=", "null", ";", "while", "(", "(", "docline", "=", "doc", ".", "readLine", "(", ")", ")", "!=", "null", ")", "{", "if", "(", "replacing", ")", "{", "if", "(", "docline", ".", "trim", "(", ")", ".", "equals", "(", "endDelim", ")", ")", "{", "replacing", "=", "false", ";", "}", "else", "{", "continue", ";", "}", "}", "b", ".", "add", "(", "docline", ")", ";", "if", "(", "!", "replacedOnce", "&&", "docline", ".", "trim", "(", ")", ".", "equals", "(", "startDelim", ")", ")", "{", "if", "(", "formatJavadoc", ")", "{", "int", "starIndex", "=", "docline", ".", "indexOf", "(", "'", "'", ")", ";", "b", ".", "add", "(", "docline", ".", "substring", "(", "0", ",", "starIndex", "+", "1", ")", ")", ";", "String", "jdoc", "=", "optionsToJavadoc", "(", "starIndex", ",", "100", ")", ";", "b", ".", "add", "(", "jdoc", ")", ";", "if", "(", "jdoc", ".", "endsWith", "(", "\"</ul>\"", ")", ")", "{", "b", ".", "add", "(", "docline", ".", "substring", "(", "0", ",", "starIndex", "+", "1", ")", ")", ";", "}", "}", "else", "{", "b", ".", "add", "(", "optionsToHtml", "(", "0", ")", ")", ";", "}", "replacedOnce", "=", "true", ";", "replacing", "=", "true", ";", "}", "}", "doc", ".", "close", "(", ")", ";", "return", "b", ".", "toString", "(", ")", ";", "}" ]

[ "Get", "the", "result", "of", "inserting", "the", "options", "documentation", "into", "the", "docfile", "." ]

[ "public", "String", "optionsToHtml", "(", "int", "refillWidth", ")", "{", "StringJoiner", "b", "=", "new", "StringJoiner", "(", "lineSep", ")", ";", "if", "(", "includeClassDoc", "&&", "root", ".", "classes", "(", ")", ".", "length", ">", "0", ")", "{", "b", ".", "add", "(", "OptionsDoclet", ".", "javadocToHtml", "(", "root", ".", "classes", "(", ")", "[", "0", "]", ")", ")", ";", "b", ".", "add", "(", "\"<p>Command line options:</p>\"", ")", ";", "}", "b", ".", "add", "(", "\"<ul>\"", ")", ";", "if", "(", "!", "options", ".", "hasGroups", "(", ")", ")", "{", "b", ".", "add", "(", "optionListToHtml", "(", "options", ".", "getOptions", "(", ")", ",", "6", ",", "2", ",", "refillWidth", ")", ")", ";", "}", "else", "{", "for", "(", "Options", ".", "OptionGroupInfo", "gi", ":", "options", ".", "getOptionGroups", "(", ")", ")", "{", "// Do not include groups without publicized options in output", "if", "(", "!", "gi", ".", "anyPublicized", "(", ")", ")", "{", "continue", ";", "}", "String", "ogroupHeader", "=", "\" <li id=\\\"optiongroup:\"", "+", "gi", ".", "name", ".", "replace", "(", "\" \"", ",", "\"-\"", ")", ".", "replace", "(", "\"/\"", ",", "\"-\"", ")", "+", "\"\\\">\"", "+", "gi", ".", "name", ";", "b", ".", "add", "(", "refill", "(", "ogroupHeader", ",", "6", ",", "2", ",", "refillWidth", ")", ")", ";", "b", ".", "add", "(", "\" <ul>\"", ")", ";", "b", ".", "add", "(", "optionListToHtml", "(", "gi", ".", "optionList", ",", "12", ",", "8", ",", "refillWidth", ")", ")", ";", "b", ".", "add", "(", "\" </ul>\"", ")", ";", "// b.add(\" </li>\");", "}", "}", "b", ".", "add", "(", "\"</ul>\"", ")", ";", "for", "(", "Options", ".", "OptionInfo", "oi", ":", "options", ".", "getOptions", "(", ")", ")", "{", "if", "(", "oi", ".", "list", "!=", "null", "&&", "!", "oi", ".", "unpublicized", ")", "{", "b", ".", "add", "(", "\"\"", ")", ";", "b", ".", "add", "(", "LIST_HELP", ")", ";", "break", ";", "}", "}", "return", "b", ".", "toString", "(", ")", ";", "}" ]

[ "Get", "the", "HTML", "documentation", "for", "the", "underlying", "Options", "instance", "." ]

[ "public", "String", "optionsToJavadoc", "(", "int", "padding", ",", "int", "refillWidth", ")", "{", "StringJoiner", "b", "=", "new", "StringJoiner", "(", "lineSep", ")", ";", "Scanner", "s", "=", "new", "Scanner", "(", "optionsToHtml", "(", "refillWidth", "-", "padding", "-", "2", ")", ")", ";", "while", "(", "s", ".", "hasNextLine", "(", ")", ")", "{", "String", "line", "=", "s", ".", "nextLine", "(", ")", ";", "StringBuilder", "bb", "=", "new", "StringBuilder", "(", ")", ";", "bb", ".", "append", "(", "StringUtils", ".", "repeat", "(", "\" \"", ",", "padding", ")", ")", ";", "if", "(", "line", ".", "trim", "(", ")", ".", "equals", "(", "\"\"", ")", ")", "{", "bb", ".", "append", "(", "\"*\"", ")", ";", "}", "else", "{", "bb", ".", "append", "(", "\"* \"", ")", ".", "append", "(", "line", ")", ";", "}", "b", ".", "add", "(", "bb", ")", ";", "}", "return", "b", ".", "toString", "(", ")", ";", "}" ]

[ "Get", "the", "HTML", "documentation", "for", "the", "underlying", "Options", "instance", "formatted", "as", "a", "Javadoc", "comment", "." ]

[ "private", "String", "optionListToHtml", "(", "List", "<", "Options", ".", "OptionInfo", ">", "optList", ",", "int", "padding", ",", "int", "firstLinePadding", ",", "int", "refillWidth", ")", "{", "StringJoiner", "b", "=", "new", "StringJoiner", "(", "lineSep", ")", ";", "for", "(", "Options", ".", "OptionInfo", "oi", ":", "optList", ")", "{", "if", "(", "oi", ".", "unpublicized", ")", "{", "continue", ";", "}", "StringBuilder", "bb", "=", "new", "StringBuilder", "(", ")", ";", "String", "optHtml", "=", "optionToHtml", "(", "oi", ",", "padding", ")", ";", "bb", ".", "append", "(", "StringUtils", ".", "repeat", "(", "\" \"", ",", "padding", ")", ")", ";", "bb", ".", "append", "(", "\"<li id=\\\"option:\"", "+", "oi", ".", "longName", "+", "\"\\\">\"", ")", ".", "append", "(", "optHtml", ")", ";", "// .append(\"</li>\");", "if", "(", "refillWidth", "<=", "0", ")", "{", "b", ".", "add", "(", "bb", ")", ";", "}", "else", "{", "b", ".", "add", "(", "refill", "(", "bb", ".", "toString", "(", ")", ",", "padding", ",", "firstLinePadding", ",", "refillWidth", ")", ")", ";", "}", "}", "return", "b", ".", "toString", "(", ")", ";", "}" ]

[ "Get", "the", "HTML", "describing", "many", "options", "formatted", "as", "an", "HTML", "list", "." ]

[ "public", "String", "optionToHtml", "(", "Options", ".", "OptionInfo", "oi", ",", "int", "padding", ")", "{", "StringBuilder", "b", "=", "new", "StringBuilder", "(", ")", ";", "Formatter", "f", "=", "new", "Formatter", "(", "b", ")", ";", "if", "(", "oi", ".", "shortName", "!=", "null", ")", "{", "f", ".", "format", "(", "\"<b>-%s</b> \"", ",", "oi", ".", "shortName", ")", ";", "}", "for", "(", "String", "a", ":", "oi", ".", "aliases", ")", "{", "f", ".", "format", "(", "\"<b>%s</b> \"", ",", "a", ")", ";", "}", "String", "prefix", "=", "getUseSingleDash", "(", ")", "?", "\"-\"", ":", "\"--\"", ";", "f", ".", "format", "(", "\"<b>%s%s=</b><i>%s</i>\"", ",", "prefix", ",", "oi", ".", "longName", ",", "oi", ".", "typeName", ")", ";", "if", "(", "oi", ".", "list", "!=", "null", ")", "{", "b", ".", "append", "(", "\" <code>[+]</code>\"", ")", ";", "}", "f", ".", "format", "(", "\".%n \"", ")", ";", "f", ".", "format", "(", "\"%s\"", ",", "StringUtils", ".", "repeat", "(", "\" \"", ",", "padding", ")", ")", ";", "String", "jdoc", "=", "(", "(", "oi", ".", "jdoc", "==", "null", ")", "?", "\"\"", ":", "oi", ".", "jdoc", ")", ";", "if", "(", "oi", ".", "noDocDefault", "||", "oi", ".", "defaultStr", "==", "null", ")", "{", "f", ".", "format", "(", "\"%s\"", ",", "jdoc", ")", ";", "}", "else", "{", "String", "defaultStr", "=", "\"default \"", "+", "oi", ".", "defaultStr", ";", "// The default string must be HTML-escaped since it comes from a string", "// rather than a Javadoc comment.", "String", "suffix", "=", "\"\"", ";", "if", "(", "jdoc", ".", "endsWith", "(", "\"</p>\"", ")", ")", "{", "suffix", "=", "\"</p>\"", ";", "jdoc", "=", "jdoc", ".", "substring", "(", "0", ",", "jdoc", ".", "length", "(", ")", "-", "suffix", ".", "length", "(", ")", ")", ";", "}", "f", ".", "format", "(", "\"%s [%s]%s\"", ",", "jdoc", ",", "StringEscapeUtils", ".", "escapeHtml4", "(", "defaultStr", ")", ",", "suffix", ")", ";", "}", "if", "(", "oi", ".", "baseType", ".", "isEnum", "(", ")", ")", "{", "b", ".", "append", "(", "lineSep", ")", ".", "append", "(", "\"<ul>\"", ")", ".", "append", "(", "lineSep", ")", ";", "assert", "oi", ".", "enumJdoc", "!=", "null", ":", "\"@AssumeAssertion(nullness): dependent: non-null if oi.baseType is an enum\"", ";", "for", "(", "Map", ".", "Entry", "<", "String", ",", "String", ">", "entry", ":", "oi", ".", "enumJdoc", ".", "entrySet", "(", ")", ")", "{", "b", ".", "append", "(", "\" <li><b>\"", ")", ".", "append", "(", "entry", ".", "getKey", "(", ")", ")", ".", "append", "(", "\"</b>\"", ")", ";", "if", "(", "entry", ".", "getValue", "(", ")", ".", "length", "(", ")", "!=", "0", ")", "{", "b", ".", "append", "(", "\" \"", ")", ".", "append", "(", "entry", ".", "getValue", "(", ")", ")", ";", "}", "// b.append(\"</li>\");", "b", ".", "append", "(", "lineSep", ")", ";", "}", "b", ".", "append", "(", "\"</ul>\"", ")", ".", "append", "(", "lineSep", ")", ";", "}", "return", "b", ".", "toString", "(", ")", ";", "}" ]

[ "Get", "the", "line", "of", "HTML", "describing", "one", "Option", "." ]

[ "public", "void", "setFormatJavadoc", "(", "boolean", "val", ")", "{", "if", "(", "val", "&&", "!", "formatJavadoc", ")", "{", "startDelim", "=", "\"* \"", "+", "startDelim", ";", "endDelim", "=", "\"* \"", "+", "endDelim", ";", "}", "else", "if", "(", "!", "val", "&&", "formatJavadoc", ")", "{", "startDelim", "=", "StringUtils", ".", "removeStart", "(", "\"* \"", ",", "startDelim", ")", ";", "endDelim", "=", "StringUtils", ".", "removeStart", "(", "\"* \"", ",", "endDelim", ")", ";", "}", "this", ".", "formatJavadoc", "=", "val", ";", "}" ]

[ "Supply", "true", "to", "set", "the", "output", "format", "to", "Javadoc", "false", "to", "set", "the", "output", "format", "to", "HTML", "." ]

[ "public", "synchronized", "void", "onLowMemory", "(", ")", "{", "try", "{", "this", ".", "mCachedTiles", ".", "clear", "(", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "log", ".", "log", "(", "Level", ".", "SEVERE", ",", "\"onLowMemory\"", ",", "e", ")", ";", "}", "}" ]

[ "This", "method", "clears", "the", "memory", "cache" ]

[ "public", "TransportApiResult", "<", "Journey", ">", "getJourney", "(", "String", "journeyId", ",", "String", "exclude", ")", "{", "if", "(", "Extensions", ".", "isNullOrWhiteSpace", "(", "journeyId", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"JourneyId is required.\"", ")", ";", "}", "return", "TransportApiClientCalls", ".", "getJourney", "(", "tokenComponent", ",", "settings", ",", "journeyId", ",", "exclude", ")", ";", "}" ]

[ "Gets", "a", "journey", "previously", "requested", "through", "the", "POST", "journey", "call", "." ]

[ "public", "TransportApiResult", "<", "Itinerary", ">", "getItinerary", "(", "String", "journeyId", ",", "String", "itineraryId", ",", "String", "exclude", ")", "{", "if", "(", "Extensions", ".", "isNullOrWhiteSpace", "(", "journeyId", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"JourneyId is required.\"", ")", ";", "}", "if", "(", "Extensions", ".", "isNullOrWhiteSpace", "(", "itineraryId", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"ItineraryId is required.\"", ")", ";", "}", "return", "TransportApiClientCalls", ".", "getItinerary", "(", "tokenComponent", ",", "settings", ",", "journeyId", ",", "itineraryId", ",", "exclude", ")", ";", "}" ]

[ "Gets", "a", "specific", "itinerary", "of", "a", "journey", "previously", "requested", "through", "the", "POST", "journey", "call", "." ]

[ "public", "TransportApiResult", "<", "List", "<", "Agency", ">", ">", "getAgencies", "(", "AgencyQueryOptions", "options", ")", "{", "if", "(", "options", "==", "null", ")", "{", "options", "=", "AgencyQueryOptions", ".", "defaultQueryOptions", "(", ")", ";", "}", "return", "TransportApiClientCalls", ".", "getAgencies", "(", "tokenComponent", ",", "settings", ",", "options", ",", "null", ",", "null", ",", "null", ")", ";", "}" ]

[ "Gets", "a", "list", "of", "all", "agencies", "in", "the", "system", "." ]

[ "public", "TransportApiResult", "<", "List", "<", "Agency", ">", ">", "getAgenciesByBoundingBox", "(", "AgencyQueryOptions", "options", ",", "String", "boundingBox", ")", "{", "if", "(", "options", "==", "null", ")", "{", "options", "=", "AgencyQueryOptions", ".", "defaultQueryOptions", "(", ")", ";", "}", "if", "(", "boundingBox", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"BoundingBox is required.\"", ")", ";", "}", "String", "[", "]", "bbox", "=", "boundingBox", ".", "split", "(", "\",\"", ",", "-", "1", ")", ";", "if", "(", "bbox", ".", "length", "!=", "4", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Invalid bounding box. See valid examples here: http://developer.whereismytransport.com/documentation#bounding-box.\"", ")", ";", "}", "return", "TransportApiClientCalls", ".", "getAgencies", "(", "tokenComponent", ",", "settings", ",", "options", ",", "null", ",", "null", ",", "boundingBox", ")", ";", "}" ]

[ "Gets", "a", "list", "of", "all", "agencies", "within", "a", "bounding", "box", "." ]

[ "public", "TransportApiResult", "<", "Agency", ">", "getAgency", "(", "String", "agencyId", ")", "{", "if", "(", "Extensions", ".", "isNullOrWhiteSpace", "(", "agencyId", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"AgencyId is required.\"", ")", ";", "}", "return", "TransportApiClientCalls", ".", "getAgency", "(", "tokenComponent", ",", "settings", ",", "agencyId", ")", ";", "}" ]

[ "Gets", "a", "specific", "agency", "." ]

[ "public", "TransportApiResult", "<", "List", "<", "Line", ">", ">", "getLines", "(", "LineQueryOptions", "options", ")", "{", "if", "(", "options", "==", "null", ")", "{", "options", "=", "LineQueryOptions", ".", "defaultQueryOptions", "(", ")", ";", "}", "return", "TransportApiClientCalls", ".", "getLines", "(", "tokenComponent", ",", "settings", ",", "options", ",", "null", ",", "null", ",", "null", ")", ";", "}" ]

[ "Gets", "a", "list", "of", "all", "lines", "in", "the", "system", "." ]

[ "public", "TransportApiResult", "<", "List", "<", "Line", ">", ">", "getLinesNearby", "(", "LineQueryOptions", "options", ",", "double", "latitude", ",", "double", "longitude", ",", "int", "radiusInMeters", ")", "{", "if", "(", "options", "==", "null", ")", "{", "options", "=", "LineQueryOptions", ".", "defaultQueryOptions", "(", ")", ";", "}", "if", "(", "radiusInMeters", "<", "0", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Invalid limit. Valid values are positive numbers only.\"", ")", ";", "}", "return", "TransportApiClientCalls", ".", "getLines", "(", "tokenComponent", ",", "settings", ",", "options", ",", "new", "Point", "(", "longitude", ",", "latitude", ")", ",", "radiusInMeters", ",", "null", ")", ";", "}" ]

[ "Gets", "a", "list", "of", "lines", "nearby", "ordered", "by", "distance", "from", "the", "point", "specified", "." ]

[ "public", "TransportApiResult", "<", "List", "<", "Line", ">", ">", "getLinesByBoundingBox", "(", "LineQueryOptions", "options", ",", "String", "boundingBox", ")", "{", "if", "(", "options", "==", "null", ")", "{", "options", "=", "LineQueryOptions", ".", "defaultQueryOptions", "(", ")", ";", "}", "if", "(", "boundingBox", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"BoundingBox is required.\"", ")", ";", "}", "String", "[", "]", "bbox", "=", "boundingBox", ".", "split", "(", "\",\"", ",", "-", "1", ")", ";", "if", "(", "bbox", ".", "length", "!=", "4", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Invalid bounding box. See valid examples here: http://developer.whereismytransport.com/documentation#bounding-box.\"", ")", ";", "}", "return", "TransportApiClientCalls", ".", "getLines", "(", "tokenComponent", ",", "settings", ",", "options", ",", "null", ",", "null", ",", "boundingBox", ")", ";", "}" ]

[ "Gets", "a", "list", "of", "all", "lines", "within", "a", "bounding", "box", "." ]

[ "public", "TransportApiResult", "<", "Line", ">", "getLine", "(", "String", "lineId", ")", "{", "if", "(", "Extensions", ".", "isNullOrWhiteSpace", "(", "lineId", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"LineId is required.\"", ")", ";", "}", "return", "TransportApiClientCalls", ".", "getLine", "(", "tokenComponent", ",", "settings", ",", "lineId", ")", ";", "}" ]

[ "Gets", "a", "specific", "line", "." ]

[ "public", "TransportApiResult", "<", "List", "<", "LineTimetable", ">", ">", "getLineTimetable", "(", "String", "lineId", ",", "LineTimetableQueryOptions", "options", ")", "{", "if", "(", "Extensions", ".", "isNullOrWhiteSpace", "(", "lineId", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"LineId is required.\"", ")", ";", "}", "if", "(", "options", "==", "null", ")", "{", "options", "=", "LineTimetableQueryOptions", ".", "defaultQueryOptions", "(", ")", ";", "}", "return", "TransportApiClientCalls", ".", "getLineTimetable", "(", "tokenComponent", ",", "settings", ",", "lineId", ",", "options", ")", ";", "}" ]

[ "Gets", "a", "timetable", "for", "a", "specific", "line", "." ]

[ "public", "TransportApiResult", "<", "List", "<", "Stop", ">", ">", "getStops", "(", "StopQueryOptions", "options", ")", "{", "if", "(", "options", "==", "null", ")", "{", "options", "=", "StopQueryOptions", ".", "defaultQueryOptions", "(", ")", ";", "}", "return", "TransportApiClientCalls", ".", "getStops", "(", "tokenComponent", ",", "settings", ",", "options", ",", "null", ",", "null", ",", "null", ")", ";", "}" ]

[ "Gets", "a", "list", "of", "all", "stops", "in", "the", "system", "." ]

[ "public", "TransportApiResult", "<", "List", "<", "Stop", ">", ">", "getStopsNearby", "(", "StopQueryOptions", "options", ",", "double", "latitude", ",", "double", "longitude", ",", "int", "radiusInMeters", ")", "{", "if", "(", "options", "==", "null", ")", "{", "options", "=", "StopQueryOptions", ".", "defaultQueryOptions", "(", ")", ";", "}", "if", "(", "radiusInMeters", "<", "0", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Invalid limit. Valid values are positive numbers only.\"", ")", ";", "}", "return", "TransportApiClientCalls", ".", "getStops", "(", "tokenComponent", ",", "settings", ",", "options", ",", "new", "Point", "(", "longitude", ",", "latitude", ")", ",", "radiusInMeters", ",", "null", ")", ";", "}" ]

[ "Gets", "a", "list", "of", "stops", "nearby", "ordered", "by", "distance", "from", "the", "point", "specified", "." ]

[ "public", "TransportApiResult", "<", "List", "<", "Stop", ">", ">", "getStopsByBoundingBox", "(", "StopQueryOptions", "options", ",", "String", "boundingBox", ")", "{", "if", "(", "options", "==", "null", ")", "{", "options", "=", "StopQueryOptions", ".", "defaultQueryOptions", "(", ")", ";", "}", "if", "(", "boundingBox", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"BoundingBox is required.\"", ")", ";", "}", "String", "[", "]", "bbox", "=", "boundingBox", ".", "split", "(", "\",\"", ",", "-", "1", ")", ";", "if", "(", "bbox", ".", "length", "!=", "4", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Invalid bounding box. See valid examples here: http://developer.whereismytransport.com/documentation#bounding-box.\"", ")", ";", "}", "return", "TransportApiClientCalls", ".", "getStops", "(", "tokenComponent", ",", "settings", ",", "options", ",", "null", ",", "null", ",", "boundingBox", ")", ";", "}" ]

[ "Gets", "a", "list", "of", "all", "stops", "within", "a", "bounding", "box", "." ]

[ "public", "TransportApiResult", "<", "Stop", ">", "getStop", "(", "String", "stopId", ")", "{", "if", "(", "Extensions", ".", "isNullOrWhiteSpace", "(", "stopId", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"StopId is required.\"", ")", ";", "}", "return", "TransportApiClientCalls", ".", "getStop", "(", "tokenComponent", ",", "settings", ",", "stopId", ")", ";", "}" ]

[ "Gets", "a", "specific", "stop", "." ]

[ "public", "TransportApiResult", "<", "List", "<", "StopTimetable", ">", ">", "getStopTimetable", "(", "String", "stopId", ",", "StopTimetableQueryOptions", "options", ")", "{", "if", "(", "Extensions", ".", "isNullOrWhiteSpace", "(", "stopId", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"StopId is required.\"", ")", ";", "}", "if", "(", "options", "==", "null", ")", "{", "options", "=", "StopTimetableQueryOptions", ".", "defaultQueryOptions", "(", ")", ";", "}", "return", "TransportApiClientCalls", ".", "getStopTimetable", "(", "tokenComponent", ",", "settings", ",", "stopId", ",", "options", ")", ";", "}" ]

[ "Gets", "a", "timetable", "for", "a", "specific", "stop", "." ]

[ "public", "TransportApiResult", "<", "List", "<", "FareProduct", ">", ">", "getFareProducts", "(", "FareProductQueryOptions", "options", ")", "{", "if", "(", "options", "==", "null", ")", "{", "options", "=", "FareProductQueryOptions", ".", "defaultQueryOptions", "(", ")", ";", "}", "return", "TransportApiClientCalls", ".", "getFareProducts", "(", "tokenComponent", ",", "settings", ",", "options", ")", ";", "}" ]

[ "Gets", "a", "list", "of", "all", "fare", "products", "in", "the", "system", "." ]

[ "public", "TransportApiResult", "<", "FareProduct", ">", "getFareProduct", "(", "String", "fareProductId", ")", "{", "if", "(", "Extensions", ".", "isNullOrWhiteSpace", "(", "fareProductId", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"FareProductId is required.\"", ")", ";", "}", "return", "TransportApiClientCalls", ".", "getFareProduct", "(", "tokenComponent", ",", "settings", ",", "fareProductId", ")", ";", "}" ]

[ "Gets", "a", "specific", "fare", "product", "." ]

[ "private", "static", "String", "getBookParam", "(", "Map", "<", "String", ",", "String", ">", "bookParams", ",", "String", "paramName", ")", "{", "String", "value", "=", "bookParams", ".", "get", "(", "paramName", ")", ";", "if", "(", "value", "!=", "null", "&&", "value", ".", "isEmpty", "(", ")", ")", "value", "=", "null", ";", "return", "value", ";", "}" ]

[ "Gets", "a", "book", "parameter", "null", "if", "empty", "." ]

[ "private", "static", "View", "findNewsView", "(", "HtmlRenderer", "htmlRenderer", ")", "throws", "ServletException", "{", "// Find the news view, which this RSS extends and iteroperates with", "View", "view", "=", "htmlRenderer", ".", "getViewsByName", "(", ")", ".", "get", "(", "NewsView", ".", "VIEW_NAME", ")", ";", "if", "(", "view", "==", "null", ")", "throw", "new", "ServletException", "(", "\"View not found: \"", "+", "NewsView", ".", "VIEW_NAME", ")", ";", "return", "view", ";", "}" ]

[ "Finds", "the", "news", "view", "." ]

[ "public", "String", "getAvailableServices", "(", ")", "throws", "JsonGenerationException", ",", "JsonMappingException", ",", "IOException", "{", "DescribeServices", "services", "=", "serviceManager", ".", "getAvailableServices", "(", ")", ";", "return", "services", ".", "asJSON", "(", ")", ";", "}" ]

[ "Returns", "a", "JSON", "containing", "the", "describe", "service", "document", "of", "each", "service", "registered", "into", "the", "library" ]

[ "public", "String", "getPOIs", "(", "String", "id", ",", "double", "lon", ",", "double", "lat", ",", "double", "distanceInMeters", ",", "List", "<", "Param", ">", "optionalParams", ")", "throws", "Exception", "{", "DescribeService", "describeService", "=", "getDescribeServiceByID", "(", "id", ")", ";", "double", "[", "]", "bbox", "=", "Calculator", ".", "boundingCoordinates", "(", "lon", ",", "lat", ",", "distanceInMeters", ")", ";", "POIProxyEvent", "beforeEvent", "=", "new", "POIProxyEvent", "(", "POIProxyEventEnum", ".", "BeforeBrowseLonLat", ",", "describeService", ",", "new", "Extent", "(", "bbox", "[", "0", "]", ",", "bbox", "[", "1", "]", ",", "bbox", "[", "2", "]", ",", "bbox", "[", "3", "]", ")", ",", "null", ",", "null", ",", "null", ",", "lon", ",", "lat", ",", "distanceInMeters", ",", "null", ",", "null", ",", "null", ")", ";", "notifyListenersBeforeRequest", "(", "beforeEvent", ")", ";", "String", "geoJSON", "=", "getCacheData", "(", "beforeEvent", ")", ";", "boolean", "fromCache", "=", "true", ";", "if", "(", "geoJSON", "==", "null", ")", "{", "fromCache", "=", "false", ";", "geoJSON", "=", "getResponseAsGeoJSON", "(", "id", ",", "optionalParams", ",", "describeService", ",", "bbox", "[", "0", "]", ",", "bbox", "[", "1", "]", ",", "bbox", "[", "2", "]", ",", "bbox", "[", "3", "]", ",", "lon", ",", "lat", ",", "beforeEvent", ")", ";", "}", "POIProxyEvent", "afterEvent", "=", "new", "POIProxyEvent", "(", "POIProxyEventEnum", ".", "AfterBrowseLonLat", ",", "describeService", ",", "new", "Extent", "(", "bbox", "[", "0", "]", ",", "bbox", "[", "1", "]", ",", "bbox", "[", "2", "]", ",", "bbox", "[", "3", "]", ")", ",", "null", ",", "null", ",", "null", ",", "lon", ",", "lat", ",", "distanceInMeters", ",", "null", ",", "geoJSON", ",", "null", ")", ";", "if", "(", "!", "fromCache", ")", "{", "storeData", "(", "afterEvent", ")", ";", "}", "notifyListenersBeforeRequest", "(", "afterEvent", ")", ";", "return", "geoJSON", ";", "}" ]

[ "This", "method", "is", "used", "to", "get", "the", "pois", "from", "a", "service", "and", "return", "a", "GeoJSON", "document", "with", "the", "data", "retrieved", "given", "a", "longitude", "latitude", "and", "a", "radius", "in", "meters", "." ]

[ "public", "String", "getPOIs", "(", "String", "id", ",", "double", "minX", ",", "double", "minY", ",", "double", "maxX", ",", "double", "maxY", ",", "List", "<", "Param", ">", "optionalParams", ")", "throws", "Exception", "{", "DescribeService", "describeService", "=", "getDescribeServiceByID", "(", "id", ")", ";", "POIProxyEvent", "beforeEvent", "=", "new", "POIProxyEvent", "(", "POIProxyEventEnum", ".", "BeforeBrowseExtent", ",", "describeService", ",", "new", "Extent", "(", "minX", ",", "minY", ",", "maxX", ",", "maxY", ")", ",", "null", ",", "null", ",", "null", ",", "null", ",", "null", ",", "null", ",", "null", ",", "null", ",", "null", ")", ";", "notifyListenersBeforeRequest", "(", "beforeEvent", ")", ";", "String", "geoJSON", "=", "this", ".", "getCacheData", "(", "beforeEvent", ")", ";", "boolean", "fromCache", "=", "true", ";", "if", "(", "geoJSON", "==", "null", ")", "{", "fromCache", "=", "false", ";", "geoJSON", "=", "getResponseAsGeoJSON", "(", "id", ",", "optionalParams", ",", "describeService", ",", "minX", ",", "minY", ",", "maxX", ",", "maxY", ",", "0", ",", "0", ",", "beforeEvent", ")", ";", "}", "POIProxyEvent", "afterEvent", "=", "new", "POIProxyEvent", "(", "POIProxyEventEnum", ".", "AfterBrowseExtent", ",", "describeService", ",", "new", "Extent", "(", "minX", ",", "minY", ",", "maxX", ",", "maxY", ")", ",", "null", ",", "null", ",", "null", ",", "null", ",", "null", ",", "null", ",", "null", ",", "geoJSON", ",", "null", ")", ";", "if", "(", "!", "fromCache", ")", "{", "storeData", "(", "afterEvent", ")", ";", "}", "notifyListenersAfterParse", "(", "afterEvent", ")", ";", "return", "geoJSON", ";", "}" ]

[ "This", "method", "is", "used", "to", "get", "the", "pois", "from", "a", "service", "and", "return", "a", "GeoJSON", "document", "with", "the", "data", "retrieved", "given", "a", "bounding", "box", "corners" ]

[ "public", "int", "getDistanceMeters", "(", "Extent", "boundingBox", ")", "{", "return", "new", "Double", "(", "Math", ".", "floor", "(", "Calculator", ".", "latLonDist", "(", "boundingBox", ".", "getMinX", "(", ")", ",", "boundingBox", ".", "getMinY", "(", ")", ",", "boundingBox", ".", "getMaxX", "(", ")", ",", "boundingBox", ".", "getMaxY", "(", ")", ")", ")", ")", ".", "intValue", "(", ")", ";", "}" ]

[ "Utility", "method", "to", "get", "the", "distance", "from", "the", "bottom", "left", "corner", "of", "the", "bounding", "box", "to", "the", "upper", "right", "corner" ]

[ "private", "String", "getErrorForUnknownService", "(", "String", "id", ")", "{", "StringBuffer", "error", "=", "new", "StringBuffer", "(", ")", ";", "error", ".", "append", "(", "\"Services path: \"", "+", "ServiceConfigurationManager", ".", "CONFIGURATION_DIR", ")", ";", "error", ".", "append", "(", "\"The service with id: \"", "+", "id", "+", "\" is not registered\"", ")", ";", "error", ".", "append", "(", "\"\\n Available services are: \"", ")", ";", "Set", "<", "String", ">", "keys", "=", "serviceManager", ".", "getRegisteredConfigurations", "(", ")", ".", "keySet", "(", ")", ";", "Iterator", "<", "String", ">", "it", "=", "keys", ".", "iterator", "(", ")", ";", "while", "(", "it", ".", "hasNext", "(", ")", ")", "{", "error", ".", "append", "(", "it", ".", "next", "(", ")", ")", ".", "append", "(", "\" \"", ")", ";", "}", "return", "error", ".", "toString", "(", ")", ";", "}" ]

[ "Exception", "text", "when", "a", "service", "requested", "is", "not", "registered", "into", "the", "library" ]

[ "public", "void", "register", "(", "DescribeService", "service", ",", "String", "describeService", ")", "throws", "POIProxyException", "{", "serviceManager", ".", "registerServiceConfiguration", "(", "service", ".", "getId", "(", ")", ",", "describeService", ",", "service", ")", ";", "}" ]

[ "Interface", "for", "registering", "a", "new", "service", "in", "POIProxy" ]

[ "public", "JTSFeature", "parseFeature", "(", "JSONObject", "feature", ")", "throws", "JSONException", "{", "JTSFeature", "feat", "=", "new", "JTSFeature", "(", "null", ")", ";", "JSONObject", "geometry", "=", "(", "JSONObject", ")", "feature", ".", "get", "(", "\"geometry\"", ")", ";", "String", "geomType", "=", "geometry", ".", "get", "(", "\"type\"", ")", ".", "toString", "(", ")", ";", "if", "(", "geomType", ".", "compareTo", "(", "\"Point\"", ")", "==", "0", ")", "{", "JSONArray", "coords", "=", "geometry", ".", "getJSONArray", "(", "\"coordinates\"", ")", ";", "double", "x", "=", "coords", ".", "getDouble", "(", "0", ")", ";", "double", "y", "=", "coords", ".", "getDouble", "(", "1", ")", ";", "GeometryFactory", "factory", "=", "new", "GeometryFactory", "(", ")", ";", "Coordinate", "c", "=", "new", "Coordinate", "(", ")", ";", "c", ".", "x", "=", "x", ";", "c", ".", "y", "=", "y", ";", "Point", "p", "=", "factory", ".", "createPoint", "(", "c", ")", ";", "feat", ".", "setGeometry", "(", "new", "JTSGeometry", "(", "p", ")", ")", ";", "}", "// TODO process other geometry types", "JSONObject", "props", "=", "feature", ".", "getJSONObject", "(", "\"properties\"", ")", ";", "Iterator", "it", "=", "props", ".", "keys", "(", ")", ";", "String", "key", ";", "String", "val", ";", "feat", ".", "setText", "(", "\"\"", ")", ";", "while", "(", "it", ".", "hasNext", "(", ")", ")", "{", "key", "=", "it", ".", "next", "(", ")", ".", "toString", "(", ")", ";", "val", "=", "props", ".", "getString", "(", "key", ")", ";", "feat", ".", "addField", "(", "key", ",", "val", ",", "0", ")", ";", "if", "(", "val", ".", "indexOf", "(", "\"http\"", ")", "==", "-", "1", ")", "{", "feat", ".", "setText", "(", "feat", ".", "getText", "(", ")", "+", "\" \"", "+", "val", ")", ";", "}", "}", "return", "feat", ";", "}" ]

[ "Parses", "a", "single", "feature", "with", "a", "Point" ]

[ "public", "synchronized", "Object", "put", "(", "final", "String", "key", ",", "final", "Object", "value", ")", "{", "try", "{", "if", "(", "maxCacheSize", "==", "0", ")", "{", "return", "null", ";", "}", "// if the key isn't in the cache and the cache is full...", "if", "(", "!", "super", ".", "containsKey", "(", "key", ")", "&&", "!", "list", ".", "isEmpty", "(", ")", "&&", "list", ".", "size", "(", ")", "+", "1", ">", "maxCacheSize", ")", "{", "final", "Object", "deadKey", "=", "list", ".", "removeLast", "(", ")", ";", "super", ".", "remove", "(", "deadKey", ")", ";", "}", "updateKey", "(", "key", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "log", ".", "log", "(", "Level", ".", "SEVERE", ",", "\"put\"", ",", "e", ")", ";", "}", "return", "super", ".", "put", "(", "key", ",", "value", ")", ";", "}" ]

[ "Adds", "an", "Object", "to", "the", "cache", ".", "If", "the", "cache", "is", "full", "removes", "the", "last" ]

[ "public", "synchronized", "Object", "get", "(", "final", "String", "key", ")", "{", "try", "{", "final", "Object", "value", "=", "super", ".", "get", "(", "key", ")", ";", "if", "(", "value", "!=", "null", ")", "{", "updateKey", "(", "key", ")", ";", "}", "return", "value", ";", "}", "catch", "(", "Exception", "e", ")", "{", "log", ".", "log", "(", "Level", ".", "SEVERE", ",", "\"get\"", ",", "e", ")", ";", "return", "null", ";", "}", "}" ]

[ "Returns", "a", "cached", "Object", "given", "a", "key" ]

[ "public", "synchronized", "void", "remove", "(", "final", "String", "key", ")", "{", "try", "{", "list", ".", "remove", "(", "key", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "log", ".", "log", "(", "Level", ".", "SEVERE", ",", "\"remove\"", ",", "e", ")", ";", "}", "super", ".", "remove", "(", "key", ")", ";", "}" ]

[ "Removes", "a", "Object", "from", "the", "cache" ]

[ "public", "void", "setEscapeMode", "(", "int", "escapeMode", ")", "throws", "IllegalArgumentException", "{", "if", "(", "escapeMode", "!=", "ESCAPE_MODE_DOUBLED", "&&", "escapeMode", "!=", "ESCAPE_MODE_BACKSLASH", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Parameter escapeMode must be a valid value.\"", ")", ";", "}", "userSettings", ".", "EscapeMode", "=", "escapeMode", ";", "}" ]

[ "Sets", "the", "current", "way", "to", "escape", "an", "occurance", "of", "the", "text", "qualifier", "inside", "qualified", "data", "." ]

[ "public", "String", "[", "]", "getHeaders", "(", ")", "throws", "IOException", "{", "checkClosed", "(", ")", ";", "if", "(", "headersHolder", ".", "Headers", "==", "null", ")", "{", "return", "null", ";", "}", "else", "{", "// use clone here to prevent the outside code from", "// setting values on the array directly, which would", "// throw off the index lookup based on header name", "String", "[", "]", "clone", "=", "new", "String", "[", "headersHolder", ".", "Length", "]", ";", "System", ".", "arraycopy", "(", "headersHolder", ".", "Headers", ",", "0", ",", "clone", ",", "0", ",", "headersHolder", ".", "Length", ")", ";", "return", "clone", ";", "}", "}" ]

[ "Returns", "the", "header", "values", "as", "a", "string", "array", "." ]