Datasets:

---

CM

/

codexglue_code2text_java

like 4

[ "public", "synchronized", "String", "requestBlock", "(", "String", "name", ")", "{", "if", "(", "blocks", ".", "isEmpty", "(", ")", ")", "{", "return", "\"exit\"", ";", "}", "remainingBlocks", ".", "decrementAndGet", "(", ")", ";", "return", "blocks", ".", "poll", "(", ")", ".", "createResponse", "(", ")", ";", "}" ]

[ "Returns", "a", "description", "a", "block", "of", "work", "or", "exit", "if", "no", "more", "blocks", "exist" ]

[ "public", "String", "makeReport", "(", "String", "name", ",", "String", "report", ")", "{", "long", "increment", "=", "Long", ".", "valueOf", "(", "report", ")", ";", "long", "currentLineCount", "=", "globalLineCounter", ".", "addAndGet", "(", "increment", ")", ";", "if", "(", "currentLineCount", ">=", "maxScenarios", ")", "{", "return", "\"exit\"", ";", "}", "else", "{", "return", "\"ok\"", ";", "}", "}" ]

[ "Handles", "reports", "by", "consumers" ]

[ "public", "void", "prepareStatus", "(", ")", "{", "globalLineCounter", "=", "new", "AtomicLong", "(", "0", ")", ";", "time", "=", "new", "AtomicLong", "(", "System", ".", "currentTimeMillis", "(", ")", ")", ";", "startTime", "=", "System", ".", "currentTimeMillis", "(", ")", ";", "lastCount", "=", "0", ";", "// Status thread regularly reports on what is happening", "Thread", "statusThread", "=", "new", "Thread", "(", ")", "{", "public", "void", "run", "(", ")", "{", "while", "(", "true", ")", "{", "try", "{", "Thread", ".", "sleep", "(", "1000", ")", ";", "}", "catch", "(", "InterruptedException", "e", ")", "{", "System", ".", "out", ".", "println", "(", "\"Status thread interrupted\"", ")", ";", "}", "long", "thisTime", "=", "System", ".", "currentTimeMillis", "(", ")", ";", "long", "currentCount", "=", "globalLineCounter", ".", "get", "(", ")", ";", "if", "(", "thisTime", "-", "time", ".", "get", "(", ")", ">", "1000", ")", "{", "long", "oldTime", "=", "time", ".", "get", "(", ")", ";", "time", ".", "set", "(", "thisTime", ")", ";", "double", "avgRate", "=", "1000.0", "*", "currentCount", "/", "(", "thisTime", "-", "startTime", ")", ";", "double", "instRate", "=", "1000.0", "*", "(", "currentCount", "-", "lastCount", ")", "/", "(", "thisTime", "-", "oldTime", ")", ";", "lastCount", "=", "currentCount", ";", "System", ".", "out", ".", "println", "(", "currentCount", "+", "\" AvgRage:\"", "+", "(", "(", "int", ")", "avgRate", ")", "+", "\" lines/sec instRate:\"", "+", "(", "(", "int", ")", "instRate", ")", "+", "\" lines/sec Unassigned Work: \"", "+", "remainingBlocks", ".", "get", "(", ")", "+", "\" blocks\"", ")", ";", "}", "}", "}", "}", ";", "statusThread", ".", "start", "(", ")", ";", "}" ]

[ "Establishes", "a", "thread", "that", "on", "one", "second", "intervals", "reports", "the", "number", "of", "remaining", "WorkBlocks", "enqueued", "and", "the", "total", "number", "of", "lines", "written", "and", "reported", "by", "consumers" ]

[ "public", "void", "prepareServer", "(", ")", "{", "try", "{", "server", "=", "new", "Server", "(", "0", ")", ";", "jettyHandler", "=", "new", "AbstractHandler", "(", ")", "{", "public", "void", "handle", "(", "String", "target", ",", "Request", "req", ",", "HttpServletRequest", "request", ",", "HttpServletResponse", "response", ")", "throws", "IOException", ",", "ServletException", "{", "response", ".", "setContentType", "(", "\"text/plain\"", ")", ";", "String", "[", "]", "operands", "=", "request", ".", "getRequestURI", "(", ")", ".", "split", "(", "\"/\"", ")", ";", "String", "name", "=", "\"\"", ";", "String", "command", "=", "\"\"", ";", "String", "value", "=", "\"\"", ";", "//operands[0] = \"\", request starts with a \"/\"", "if", "(", "operands", ".", "length", ">=", "2", ")", "{", "name", "=", "operands", "[", "1", "]", ";", "}", "if", "(", "operands", ".", "length", ">=", "3", ")", "{", "command", "=", "operands", "[", "2", "]", ";", "}", "if", "(", "operands", ".", "length", ">=", "4", ")", "{", "value", "=", "operands", "[", "3", "]", ";", "}", "if", "(", "command", ".", "equals", "(", "\"report\"", ")", ")", "{", "//report a number of lines written", "response", ".", "getWriter", "(", ")", ".", "write", "(", "makeReport", "(", "name", ",", "value", ")", ")", ";", "}", "else", "if", "(", "command", ".", "equals", "(", "\"request\"", ")", "&&", "value", ".", "equals", "(", "\"block\"", ")", ")", "{", "//request a new block of work", "response", ".", "getWriter", "(", ")", ".", "write", "(", "requestBlock", "(", "name", ")", ")", ";", "}", "else", "if", "(", "command", ".", "equals", "(", "\"request\"", ")", "&&", "value", ".", "equals", "(", "\"name\"", ")", ")", "{", "//request a new name to report with", "response", ".", "getWriter", "(", ")", ".", "write", "(", "requestName", "(", ")", ")", ";", "}", "else", "{", "//non recognized response", "response", ".", "getWriter", "(", ")", ".", "write", "(", "\"exit\"", ")", ";", "}", "(", "(", "Request", ")", "request", ")", ".", "setHandled", "(", "true", ")", ";", "}", "}", ";", "server", ".", "setHandler", "(", "jettyHandler", ")", ";", "// Select any available port", "server", ".", "start", "(", ")", ";", "Connector", "[", "]", "connectors", "=", "server", ".", "getConnectors", "(", ")", ";", "NetworkConnector", "nc", "=", "(", "NetworkConnector", ")", "connectors", "[", "0", "]", ";", "listeningPort", "=", "nc", ".", "getLocalPort", "(", ")", ";", "hostName", "=", "InetAddress", ".", "getLocalHost", "(", ")", ".", "getHostName", "(", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "e", ".", "printStackTrace", "(", ")", ";", "}", "}" ]

[ "Prepares", "a", "Jetty", "server", "for", "communicating", "with", "consumers", "." ]

[ "public", "String", "getXmlFormatted", "(", "Map", "<", "String", ",", "String", ">", "dataMap", ")", "{", "StringBuilder", "sb", "=", "new", "StringBuilder", "(", ")", ";", "for", "(", "String", "var", ":", "outTemplate", ")", "{", "sb", ".", "append", "(", "appendXmlStartTag", "(", "var", ")", ")", ";", "sb", ".", "append", "(", "dataMap", ".", "get", "(", "var", ")", ")", ";", "sb", ".", "append", "(", "appendXmlEndingTag", "(", "var", ")", ")", ";", "}", "return", "sb", ".", "toString", "(", ")", ";", "}" ]

[ "Given", "an", "array", "of", "variable", "names", "returns", "an", "Xml", "String", "of", "values", "." ]

[ "private", "String", "appendXmlStartTag", "(", "String", "value", ")", "{", "StringBuilder", "sb", "=", "new", "StringBuilder", "(", ")", ";", "sb", ".", "append", "(", "\"<\"", ")", ".", "append", "(", "value", ")", ".", "append", "(", "\">\"", ")", ";", "return", "sb", ".", "toString", "(", ")", ";", "}" ]

[ "Helper", "xml", "start", "tag", "writer" ]

[ "private", "String", "appendXmlEndingTag", "(", "String", "value", ")", "{", "StringBuilder", "sb", "=", "new", "StringBuilder", "(", ")", ";", "sb", ".", "append", "(", "\"</\"", ")", ".", "append", "(", "value", ")", ".", "append", "(", "\">\"", ")", ";", "return", "sb", ".", "toString", "(", ")", ";", "}" ]

[ "Helper", "xml", "end", "tag", "writer" ]

[ "private", "Map", "<", "String", ",", "String", ">", "fillInitialVariables", "(", ")", "{", "Map", "<", "String", ",", "TransitionTarget", ">", "targets", "=", "model", ".", "getChildren", "(", ")", ";", "Set", "<", "String", ">", "variables", "=", "new", "HashSet", "<>", "(", ")", ";", "for", "(", "TransitionTarget", "target", ":", "targets", ".", "values", "(", ")", ")", "{", "OnEntry", "entry", "=", "target", ".", "getOnEntry", "(", ")", ";", "List", "<", "Action", ">", "actions", "=", "entry", ".", "getActions", "(", ")", ";", "for", "(", "Action", "action", ":", "actions", ")", "{", "if", "(", "action", "instanceof", "Assign", ")", "{", "String", "variable", "=", "(", "(", "Assign", ")", "action", ")", ".", "getName", "(", ")", ";", "variables", ".", "add", "(", "variable", ")", ";", "}", "else", "if", "(", "action", "instanceof", "SetAssignExtension", ".", "SetAssignTag", ")", "{", "String", "variable", "=", "(", "(", "SetAssignExtension", ".", "SetAssignTag", ")", "action", ")", ".", "getName", "(", ")", ";", "variables", ".", "add", "(", "variable", ")", ";", "}", "}", "}", "Map", "<", "String", ",", "String", ">", "result", "=", "new", "HashMap", "<>", "(", ")", ";", "for", "(", "String", "variable", ":", "variables", ")", "{", "result", ".", "put", "(", "variable", ",", "\"\"", ")", ";", "}", "return", "result", ";", "}" ]

[ "Searches", "the", "model", "for", "all", "variable", "assignments", "and", "makes", "a", "default", "map", "of", "those", "variables", "setting", "them", "to" ]

[ "public", "List", "<", "PossibleState", ">", "bfs", "(", "int", "min", ")", "throws", "ModelException", "{", "List", "<", "PossibleState", ">", "bootStrap", "=", "new", "LinkedList", "<>", "(", ")", ";", "TransitionTarget", "initial", "=", "model", ".", "getInitialTarget", "(", ")", ";", "PossibleState", "initialState", "=", "new", "PossibleState", "(", "initial", ",", "fillInitialVariables", "(", ")", ")", ";", "bootStrap", ".", "add", "(", "initialState", ")", ";", "while", "(", "bootStrap", ".", "size", "(", ")", "<", "min", ")", "{", "PossibleState", "state", "=", "bootStrap", ".", "remove", "(", "0", ")", ";", "TransitionTarget", "nextState", "=", "state", ".", "nextState", ";", "if", "(", "nextState", ".", "getId", "(", ")", ".", "equalsIgnoreCase", "(", "\"end\"", ")", ")", "{", "throw", "new", "ModelException", "(", "\"Could not achieve required bootstrap without reaching end state\"", ")", ";", "}", "//run every action in series\r", "List", "<", "Map", "<", "String", ",", "String", ">", ">", "product", "=", "new", "LinkedList", "<>", "(", ")", ";", "product", ".", "add", "(", "new", "HashMap", "<>", "(", "state", ".", "variables", ")", ")", ";", "OnEntry", "entry", "=", "nextState", ".", "getOnEntry", "(", ")", ";", "List", "<", "Action", ">", "actions", "=", "entry", ".", "getActions", "(", ")", ";", "for", "(", "Action", "action", ":", "actions", ")", "{", "for", "(", "CustomTagExtension", "tagExtension", ":", "tagExtensionList", ")", "{", "if", "(", "tagExtension", ".", "getTagActionClass", "(", ")", ".", "isInstance", "(", "action", ")", ")", "{", "product", "=", "tagExtension", ".", "pipelinePossibleStates", "(", "action", ",", "product", ")", ";", "}", "}", "}", "//go through every transition and see which of the products are valid, adding them to the list\r", "List", "<", "Transition", ">", "transitions", "=", "nextState", ".", "getTransitionsList", "(", ")", ";", "for", "(", "Transition", "transition", ":", "transitions", ")", "{", "String", "condition", "=", "transition", ".", "getCond", "(", ")", ";", "TransitionTarget", "target", "=", "(", "(", "List", "<", "TransitionTarget", ">", ")", "transition", ".", "getTargets", "(", ")", ")", ".", "get", "(", "0", ")", ";", "for", "(", "Map", "<", "String", ",", "String", ">", "p", ":", "product", ")", "{", "Boolean", "pass", ";", "if", "(", "condition", "==", "null", ")", "{", "pass", "=", "true", ";", "}", "else", "{", "//scrub the context clean so we may use it to evaluate transition conditional\r", "Context", "context", "=", "this", ".", "getRootContext", "(", ")", ";", "context", ".", "reset", "(", ")", ";", "//set up new context\r", "for", "(", "Map", ".", "Entry", "<", "String", ",", "String", ">", "e", ":", "p", ".", "entrySet", "(", ")", ")", "{", "context", ".", "set", "(", "e", ".", "getKey", "(", ")", ",", "e", ".", "getValue", "(", ")", ")", ";", "}", "//evaluate condition\r", "try", "{", "pass", "=", "(", "Boolean", ")", "this", ".", "getEvaluator", "(", ")", ".", "eval", "(", "context", ",", "condition", ")", ";", "}", "catch", "(", "SCXMLExpressionException", "ex", ")", "{", "pass", "=", "false", ";", "}", "}", "//transition condition satisfied, add to bootstrap list\r", "if", "(", "pass", ")", "{", "PossibleState", "result", "=", "new", "PossibleState", "(", "target", ",", "p", ")", ";", "bootStrap", ".", "add", "(", "result", ")", ";", "}", "}", "}", "}", "return", "bootStrap", ";", "}" ]

[ "Performs", "a", "partial", "BFS", "on", "model", "until", "the", "search", "frontier", "reaches", "the", "desired", "bootstrap", "size" ]

[ "public", "void", "process", "(", "SearchDistributor", "distributor", ")", "{", "List", "<", "PossibleState", ">", "bootStrap", ";", "try", "{", "bootStrap", "=", "bfs", "(", "bootStrapMin", ")", ";", "}", "catch", "(", "ModelException", "e", ")", "{", "bootStrap", "=", "new", "LinkedList", "<>", "(", ")", ";", "}", "List", "<", "Frontier", ">", "frontiers", "=", "new", "LinkedList", "<>", "(", ")", ";", "for", "(", "PossibleState", "p", ":", "bootStrap", ")", "{", "SCXMLFrontier", "dge", "=", "new", "SCXMLFrontier", "(", "p", ",", "model", ",", "tagExtensionList", ")", ";", "frontiers", ".", "add", "(", "dge", ")", ";", "}", "distributor", ".", "distribute", "(", "frontiers", ")", ";", "}" ]

[ "Performs", "the", "BFS", "and", "gives", "the", "results", "to", "a", "distributor", "to", "distribute" ]

[ "public", "void", "setModelByInputFileStream", "(", "InputStream", "inputFileStream", ")", "{", "try", "{", "this", ".", "model", "=", "SCXMLParser", ".", "parse", "(", "new", "InputSource", "(", "inputFileStream", ")", ",", "null", ",", "customActionsFromTagExtensions", "(", ")", ")", ";", "this", ".", "setStateMachine", "(", "this", ".", "model", ")", ";", "}", "catch", "(", "IOException", "|", "SAXException", "|", "ModelException", "e", ")", "{", "e", ".", "printStackTrace", "(", ")", ";", "}", "}" ]

[ "Sets", "the", "SCXML", "model", "with", "an", "InputStream" ]

[ "public", "void", "setModelByText", "(", "String", "model", ")", "{", "try", "{", "InputStream", "is", "=", "new", "ByteArrayInputStream", "(", "model", ".", "getBytes", "(", ")", ")", ";", "this", ".", "model", "=", "SCXMLParser", ".", "parse", "(", "new", "InputSource", "(", "is", ")", ",", "null", ",", "customActionsFromTagExtensions", "(", ")", ")", ";", "this", ".", "setStateMachine", "(", "this", ".", "model", ")", ";", "}", "catch", "(", "IOException", "|", "SAXException", "|", "ModelException", "e", ")", "{", "e", ".", "printStackTrace", "(", ")", ";", "}", "}" ]

[ "Sets", "the", "SCXML", "model", "with", "a", "string" ]

[ "public", "List", "<", "Set", "<", "String", ">", ">", "makeNWiseTuples", "(", "String", "[", "]", "variables", ",", "int", "nWise", ")", "{", "List", "<", "Set", "<", "String", ">>", "completeTuples", "=", "new", "ArrayList", "<>", "(", ")", ";", "makeNWiseTuplesHelper", "(", "completeTuples", ",", "variables", ",", "0", ",", "new", "HashSet", "<", "String", ">", "(", ")", ",", "nWise", ")", ";", "return", "completeTuples", ";", "}" ]

[ "Produces", "all", "tuples", "of", "size", "n", "chosen", "from", "a", "list", "of", "variable", "names" ]

[ "public", "List", "<", "Map", "<", "String", ",", "String", ">", ">", "produceNWise", "(", "int", "nWise", ",", "String", "[", "]", "coVariables", ",", "Map", "<", "String", ",", "String", "[", "]", ">", "variableDomains", ")", "{", "List", "<", "Set", "<", "String", ">>", "tuples", "=", "makeNWiseTuples", "(", "coVariables", ",", "nWise", ")", ";", "List", "<", "Map", "<", "String", ",", "String", ">", ">", "testCases", "=", "new", "ArrayList", "<>", "(", ")", ";", "for", "(", "Set", "<", "String", ">", "tuple", ":", "tuples", ")", "{", "testCases", ".", "addAll", "(", "expandTupleIntoTestCases", "(", "tuple", ",", "variableDomains", ")", ")", ";", "}", "return", "testCases", ";", "}" ]

[ "Finds", "all", "nWise", "combinations", "of", "a", "set", "of", "variables", "each", "with", "a", "given", "domain", "of", "values" ]

[ "public", "List", "<", "Map", "<", "String", ",", "String", ">", ">", "pipelinePossibleStates", "(", "NWiseAction", "action", ",", "List", "<", "Map", "<", "String", ",", "String", ">", ">", "possibleStateList", ")", "{", "String", "[", "]", "coVariables", "=", "action", ".", "getCoVariables", "(", ")", ".", "split", "(", "\",\"", ")", ";", "int", "n", "=", "Integer", ".", "valueOf", "(", "action", ".", "getN", "(", ")", ")", ";", "List", "<", "Map", "<", "String", ",", "String", ">", ">", "newPossibleStateList", "=", "new", "ArrayList", "<>", "(", ")", ";", "for", "(", "Map", "<", "String", ",", "String", ">", "possibleState", ":", "possibleStateList", ")", "{", "Map", "<", "String", ",", "String", "[", "]", ">", "variableDomains", "=", "new", "HashMap", "<>", "(", ")", ";", "Map", "<", "String", ",", "String", ">", "defaultVariableValues", "=", "new", "HashMap", "<>", "(", ")", ";", "for", "(", "String", "variable", ":", "coVariables", ")", "{", "String", "variableMetaInfo", "=", "possibleState", ".", "get", "(", "variable", ")", ";", "String", "[", "]", "variableDomain", "=", "variableMetaInfo", ".", "split", "(", "\",\"", ")", ";", "variableDomains", ".", "put", "(", "variable", ",", "variableDomain", ")", ";", "defaultVariableValues", ".", "put", "(", "variable", ",", "variableDomain", "[", "0", "]", ")", ";", "}", "List", "<", "Map", "<", "String", ",", "String", ">", ">", "nWiseCombinations", "=", "produceNWise", "(", "n", ",", "coVariables", ",", "variableDomains", ")", ";", "for", "(", "Map", "<", "String", ",", "String", ">", "nWiseCombination", ":", "nWiseCombinations", ")", "{", "Map", "<", "String", ",", "String", ">", "newPossibleState", "=", "new", "HashMap", "<>", "(", "possibleState", ")", ";", "newPossibleState", ".", "putAll", "(", "defaultVariableValues", ")", ";", "newPossibleState", ".", "putAll", "(", "nWiseCombination", ")", ";", "newPossibleStateList", ".", "add", "(", "newPossibleState", ")", ";", "}", "}", "return", "newPossibleStateList", ";", "}" ]

[ "Uses", "current", "variable", "assignments", "and", "info", "in", "an", "NWiseActionTag", "to", "expand", "on", "an", "n", "wise", "combinatorial", "set" ]

[ "public", "void", "transform", "(", "DataPipe", "cr", ")", "{", "Map", "<", "String", ",", "String", ">", "map", "=", "cr", ".", "getDataMap", "(", ")", ";", "for", "(", "String", "key", ":", "map", ".", "keySet", "(", ")", ")", "{", "String", "value", "=", "map", ".", "get", "(", "key", ")", ";", "if", "(", "value", ".", "equals", "(", "\"#{customplaceholder}\"", ")", ")", "{", "// Generate a random number", "int", "ran", "=", "rand", ".", "nextInt", "(", ")", ";", "map", ".", "put", "(", "key", ",", "String", ".", "valueOf", "(", "ran", ")", ")", ";", "}", "else", "if", "(", "value", ".", "equals", "(", "\"#{divideBy2}\"", ")", ")", "{", "String", "i", "=", "map", ".", "get", "(", "\"var_out_V3\"", ")", ";", "String", "result", "=", "String", ".", "valueOf", "(", "Integer", ".", "valueOf", "(", "i", ")", "/", "2", ")", ";", "map", ".", "put", "(", "key", ",", "result", ")", ";", "}", "}", "}" ]

[ "Replace", "known", "tags", "in", "the", "current", "data", "values", "with", "actual", "values", "as", "appropriate" ]

[ "@", "Override", "public", "void", "processOutput", "(", "Map", "<", "String", ",", "String", ">", "resultsMap", ")", "{", "queue", ".", "add", "(", "resultsMap", ")", ";", "if", "(", "queue", ".", "size", "(", ")", ">", "10000", ")", "{", "log", ".", "info", "(", "\"Queue size \"", "+", "queue", ".", "size", "(", ")", "+", "\", waiting\"", ")", ";", "try", "{", "Thread", ".", "sleep", "(", "500", ")", ";", "}", "catch", "(", "InterruptedException", "ex", ")", "{", "log", ".", "info", "(", "\"Interrupted \"", ",", "ex", ")", ";", "}", "}", "}" ]

[ "Stores", "the", "output", "from", "a", "Frontier", "into", "the", "queue", "pausing", "and", "waiting", "if", "the", "given", "queue", "is", "too", "large" ]

[ "public", "void", "writeOutput", "(", "DataPipe", "cr", ")", "{", "try", "{", "context", ".", "write", "(", "NullWritable", ".", "get", "(", ")", ",", "new", "Text", "(", "cr", ".", "getPipeDelimited", "(", "outTemplate", ")", ")", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "RuntimeException", "(", "\"Exception occurred while writing to Context\"", ",", "e", ")", ";", "}", "}" ]

[ "Write", "to", "a", "context", ".", "Uses", "NullWritable", "for", "key", "so", "that", "only", "value", "of", "output", "string", "is", "ultimately", "written" ]

[ "public", "Map", "<", "String", ",", "String", ">", "decompose", "(", "Frontier", "frontier", ",", "String", "modelText", ")", "{", "if", "(", "!", "(", "frontier", "instanceof", "SCXMLFrontier", ")", ")", "{", "return", "null", ";", "}", "TransitionTarget", "target", "=", "(", "(", "SCXMLFrontier", ")", "frontier", ")", ".", "getRoot", "(", ")", ".", "nextState", ";", "Map", "<", "String", ",", "String", ">", "variables", "=", "(", "(", "SCXMLFrontier", ")", "frontier", ")", ".", "getRoot", "(", ")", ".", "variables", ";", "Map", "<", "String", ",", "String", ">", "decomposition", "=", "new", "HashMap", "<", "String", ",", "String", ">", "(", ")", ";", "decomposition", ".", "put", "(", "\"target\"", ",", "target", ".", "getId", "(", ")", ")", ";", "StringBuilder", "packedVariables", "=", "new", "StringBuilder", "(", ")", ";", "for", "(", "Map", ".", "Entry", "<", "String", ",", "String", ">", "variable", ":", "variables", ".", "entrySet", "(", ")", ")", "{", "packedVariables", ".", "append", "(", "variable", ".", "getKey", "(", ")", ")", ";", "packedVariables", ".", "append", "(", "\"::\"", ")", ";", "packedVariables", ".", "append", "(", "variable", ".", "getValue", "(", ")", ")", ";", "packedVariables", ".", "append", "(", "\";\"", ")", ";", "}", "decomposition", ".", "put", "(", "\"variables\"", ",", "packedVariables", ".", "toString", "(", ")", ")", ";", "decomposition", ".", "put", "(", "\"model\"", ",", "modelText", ")", ";", "return", "decomposition", ";", "}" ]

[ "Takes", "a", "model", "and", "an", "SCXMLFrontier", "and", "decomposes", "the", "Frontier", "into", "a", "Map", "of", "Strings", "to", "Strings", "These", "strings", "can", "be", "sent", "over", "a", "network", "to", "get", "a", "Frontier", "past", "a", "gap" ]

[ "public", "static", "void", "printHelp", "(", "final", "Options", "options", ")", "{", "Collection", "<", "Option", ">", "c", "=", "options", ".", "getOptions", "(", ")", ";", "System", ".", "out", ".", "println", "(", "\"Command line options are:\"", ")", ";", "int", "longestLongOption", "=", "0", ";", "for", "(", "Option", "op", ":", "c", ")", "{", "if", "(", "op", ".", "getLongOpt", "(", ")", ".", "length", "(", ")", ">", "longestLongOption", ")", "{", "longestLongOption", "=", "op", ".", "getLongOpt", "(", ")", ".", "length", "(", ")", ";", "}", "}", "longestLongOption", "+=", "2", ";", "String", "spaces", "=", "StringUtils", ".", "repeat", "(", "\" \"", ",", "longestLongOption", ")", ";", "for", "(", "Option", "op", ":", "c", ")", "{", "System", ".", "out", ".", "print", "(", "\"\\t-\"", "+", "op", ".", "getOpt", "(", ")", "+", "\" --\"", "+", "op", ".", "getLongOpt", "(", ")", ")", ";", "if", "(", "op", ".", "getLongOpt", "(", ")", ".", "length", "(", ")", "<", "spaces", ".", "length", "(", ")", ")", "{", "System", ".", "out", ".", "print", "(", "spaces", ".", "substring", "(", "op", ".", "getLongOpt", "(", ")", ".", "length", "(", ")", ")", ")", ";", "}", "else", "{", "System", ".", "out", ".", "print", "(", "\" \"", ")", ";", "}", "System", ".", "out", ".", "println", "(", "op", ".", "getDescription", "(", ")", ")", ";", "}", "}" ]

[ "Prints", "the", "help", "on", "the", "command", "line" ]

[ "public", "static", "void", "main", "(", "String", "[", "]", "args", ")", "{", "CmdLine", "cmd", "=", "new", "CmdLine", "(", ")", ";", "Configuration", "conf", "=", "new", "Configuration", "(", ")", ";", "int", "res", "=", "0", ";", "try", "{", "res", "=", "ToolRunner", ".", "run", "(", "conf", ",", "cmd", ",", "args", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "System", ".", "err", ".", "println", "(", "\"Error while running MR job\"", ")", ";", "e", ".", "printStackTrace", "(", ")", ";", "}", "System", ".", "exit", "(", "res", ")", ";", "}" ]

[ "Entry", "point", "for", "this", "example", "Uses", "HDFS", "ToolRunner", "to", "wrap", "processing", "of" ]

[ "public", "static", "scala", ".", "collection", ".", "Iterable", "linkedListToScalaIterable", "(", "LinkedList", "<", "?", ">", "linkedList", ")", "{", "return", "JavaConverters", ".", "asScalaIterableConverter", "(", "linkedList", ")", ".", "asScala", "(", ")", ";", "}" ]

[ "Convert", "a", "Java", "LinkedList", "to", "a", "Scala", "Iterable", "." ]

[ "public", "static", "<", "T", ">", "T", "flattenOption", "(", "scala", ".", "Option", "<", "T", ">", "option", ")", "{", "if", "(", "option", ".", "isEmpty", "(", ")", ")", "{", "return", "null", ";", "}", "else", "{", "return", "option", ".", "get", "(", ")", ";", "}", "}" ]

[ "Flattens", "an", "option", "into", "its", "value", "or", "else", "null", "which", "is", "not", "great", "but", "is", "usually", "more", "convenient", "in", "Java", "." ]

[ "public", "List", "<", "Map", "<", "String", ",", "String", ">", ">", "pipelinePossibleStates", "(", "Assign", "action", ",", "List", "<", "Map", "<", "String", ",", "String", ">", ">", "possibleStateList", ")", "{", "for", "(", "Map", "<", "String", ",", "String", ">", "possibleState", ":", "possibleStateList", ")", "{", "possibleState", ".", "put", "(", "action", ".", "getName", "(", ")", ",", "action", ".", "getExpr", "(", ")", ")", ";", "}", "return", "possibleStateList", ";", "}" ]

[ "Assigns", "one", "variable", "to", "one", "value" ]

[ "public", "JSONObject", "getJsonFormatted", "(", "Map", "<", "String", ",", "String", ">", "dataMap", ")", "{", "JSONObject", "oneRowJson", "=", "new", "JSONObject", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "outTemplate", ".", "length", ";", "i", "++", ")", "{", "oneRowJson", ".", "put", "(", "outTemplate", "[", "i", "]", ",", "dataMap", ".", "get", "(", "outTemplate", "[", "i", "]", ")", ")", ";", "}", "return", "oneRowJson", ";", "}" ]

[ "Given", "an", "array", "of", "variable", "names", "returns", "a", "JsonObject", "of", "values", "." ]

[ "public", "Vector", "<", "Graph", "<", "UserStub", ">", ">", "generateAllNodeDataTypeGraphCombinationsOfMaxLength", "(", "int", "length", ")", "{", "Vector", "<", "Graph", "<", "UserStub", ">>", "graphs", "=", "super", ".", "generateAllNodeDataTypeGraphCombinationsOfMaxLength", "(", "length", ")", ";", "if", "(", "WRITE_STRUCTURES_IN_PARALLEL", ")", "{", "// Left as an exercise to the student.\r", "throw", "new", "NotImplementedError", "(", ")", ";", "}", "else", "{", "int", "i", "=", "0", ";", "for", "(", "Iterator", "<", "Graph", "<", "UserStub", ">", ">", "iter", "=", "graphs", ".", "toIterator", "(", ")", ";", "iter", ".", "hasNext", "(", ")", ";", ")", "{", "Graph", "<", "UserStub", ">", "graph", "=", "iter", ".", "next", "(", ")", ";", "graph", ".", "setGraphId", "(", "\"S_\"", "+", "++", "i", "+", "\"_\"", "+", "graph", ".", "allNodes", "(", ")", ".", "size", "(", ")", ")", ";", "graph", ".", "writeDotFile", "(", "outDir", "+", "graph", ".", "graphId", "(", ")", "+", "\".gv\"", ",", "false", ",", "ALSO_WRITE_AS_PNG", ")", ";", "}", "System", ".", "out", ".", "println", "(", "\"Wrote \"", "+", "i", "+", "\" graph files in DOT format to \"", "+", "outDir", "+", "\"\"", ")", ";", "}", "return", "graphs", ";", "}" ]

[ "Build", "all", "combinations", "of", "graph", "structures", "for", "generic", "event", "stubs", "of", "a", "maximum", "length" ]

[ "public", "int", "consume", "(", "Map", "<", "String", ",", "String", ">", "initialVars", ")", "{", "this", ".", "dataPipe", "=", "new", "DataPipe", "(", "this", ")", ";", "// Set initial variables\r", "for", "(", "Map", ".", "Entry", "<", "String", ",", "String", ">", "ent", ":", "initialVars", ".", "entrySet", "(", ")", ")", "{", "dataPipe", ".", "getDataMap", "(", ")", ".", "put", "(", "ent", ".", "getKey", "(", ")", ",", "ent", ".", "getValue", "(", ")", ")", ";", "}", "// Call transformers\r", "for", "(", "DataTransformer", "dc", ":", "dataTransformers", ")", "{", "dc", ".", "transform", "(", "dataPipe", ")", ";", "}", "// Call writers\r", "for", "(", "DataWriter", "oneOw", ":", "dataWriters", ")", "{", "try", "{", "oneOw", ".", "writeOutput", "(", "dataPipe", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "//NOPMD\r", "log", ".", "error", "(", "\"Exception in DataWriter\"", ",", "e", ")", ";", "}", "}", "return", "1", ";", "}" ]

[ "Consumes", "a", "produced", "result", ".", "Calls", "every", "transformer", "in", "sequence", "then", "calls", "every", "dataWriter", "in", "sequence", "." ]

[ "public", "Future", "<", "String", ">", "sendRequest", "(", "final", "String", "path", ",", "final", "ReportingHandler", "reportingHandler", ")", "{", "return", "threadPool", ".", "submit", "(", "new", "Callable", "<", "String", ">", "(", ")", "{", "@", "Override", "public", "String", "call", "(", ")", "{", "String", "response", "=", "getResponse", "(", "path", ")", ";", "if", "(", "reportingHandler", "!=", "null", ")", "{", "reportingHandler", ".", "handleResponse", "(", "response", ")", ";", "}", "return", "response", ";", "}", "}", ")", ";", "}" ]

[ "Creates", "a", "future", "that", "will", "send", "a", "request", "to", "the", "reporting", "host", "and", "call", "the", "handler", "with", "the", "response" ]

[ "public", "void", "transform", "(", "DataPipe", "cr", ")", "{", "for", "(", "Map", ".", "Entry", "<", "String", ",", "String", ">", "entry", ":", "cr", ".", "getDataMap", "(", ")", ".", "entrySet", "(", ")", ")", "{", "String", "value", "=", "entry", ".", "getValue", "(", ")", ";", "if", "(", "value", ".", "equals", "(", "\"#{customplaceholder}\"", ")", ")", "{", "// Generate a random number", "int", "ran", "=", "rand", ".", "nextInt", "(", ")", ";", "entry", ".", "setValue", "(", "String", ".", "valueOf", "(", "ran", ")", ")", ";", "}", "}", "}" ]

[ "The", "transform", "method", "for", "this", "DataTransformer" ]

[ "public", "boolean", "isExit", "(", ")", "{", "if", "(", "currentRow", ">", "finalRow", ")", "{", "//request new block of work", "String", "newBlock", "=", "this", ".", "sendRequestSync", "(", "\"this/request/block\"", ")", ";", "LineCountManager", ".", "LineCountBlock", "block", "=", "new", "LineCountManager", ".", "LineCountBlock", "(", "0", ",", "0", ")", ";", "if", "(", "newBlock", ".", "contains", "(", "\"exit\"", ")", ")", "{", "getExitFlag", "(", ")", ".", "set", "(", "true", ")", ";", "makeReport", "(", "true", ")", ";", "return", "true", ";", "}", "else", "{", "block", ".", "buildFromResponse", "(", "newBlock", ")", ";", "}", "currentRow", "=", "block", ".", "getStart", "(", ")", ";", "finalRow", "=", "block", ".", "getStop", "(", ")", ";", "}", "else", "{", "//report the number of lines written", "makeReport", "(", "false", ")", ";", "if", "(", "exit", ".", "get", "(", ")", ")", "{", "getExitFlag", "(", ")", ".", "set", "(", "true", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Exit", "reporting", "up", "to", "distributor", "using", "information", "gained", "from", "status", "reports", "to", "the", "LineCountManager" ]

[ "@", "Override", "public", "View", "getDropDownView", "(", "int", "position", ",", "View", "convertView", ",", "ViewGroup", "parent", ")", "{", "final", "ViewHolder", "viewHolder", ";", "if", "(", "convertView", "==", "null", ")", "{", "convertView", "=", "mLayoutInflater", ".", "inflate", "(", "R", ".", "layout", ".", "item_country", ",", "parent", ",", "false", ")", ";", "viewHolder", "=", "new", "ViewHolder", "(", ")", ";", "viewHolder", ".", "mImageView", "=", "(", "ImageView", ")", "convertView", ".", "findViewById", "(", "R", ".", "id", ".", "intl_phone_edit__country__item_image", ")", ";", "viewHolder", ".", "mNameView", "=", "(", "TextView", ")", "convertView", ".", "findViewById", "(", "R", ".", "id", ".", "intl_phone_edit__country__item_name", ")", ";", "viewHolder", ".", "mDialCode", "=", "(", "TextView", ")", "convertView", ".", "findViewById", "(", "R", ".", "id", ".", "intl_phone_edit__country__item_dialcode", ")", ";", "convertView", ".", "setTag", "(", "viewHolder", ")", ";", "}", "else", "{", "viewHolder", "=", "(", "ViewHolder", ")", "convertView", ".", "getTag", "(", ")", ";", "}", "Country", "country", "=", "getItem", "(", "position", ")", ";", "viewHolder", ".", "mImageView", ".", "setImageResource", "(", "getFlagResource", "(", "country", ")", ")", ";", "viewHolder", ".", "mNameView", ".", "setText", "(", "country", ".", "getName", "(", ")", ")", ";", "viewHolder", ".", "mDialCode", ".", "setText", "(", "String", ".", "format", "(", "\"+%s\"", ",", "country", ".", "getDialCode", "(", ")", ")", ")", ";", "return", "convertView", ";", "}" ]

[ "Drop", "down", "item", "view" ]

[ "@", "Override", "public", "View", "getView", "(", "int", "position", ",", "View", "convertView", ",", "ViewGroup", "parent", ")", "{", "Country", "country", "=", "getItem", "(", "position", ")", ";", "if", "(", "convertView", "==", "null", ")", "{", "convertView", "=", "new", "ImageView", "(", "getContext", "(", ")", ")", ";", "}", "(", "(", "ImageView", ")", "convertView", ")", ".", "setImageResource", "(", "getFlagResource", "(", "country", ")", ")", ";", "return", "convertView", ";", "}" ]

[ "Drop", "down", "selected", "view" ]

[ "private", "int", "getFlagResource", "(", "Country", "country", ")", "{", "return", "getContext", "(", ")", ".", "getResources", "(", ")", ".", "getIdentifier", "(", "\"country_\"", "+", "country", ".", "getIso", "(", ")", ".", "toLowerCase", "(", ")", ",", "\"drawable\"", ",", "getContext", "(", ")", ".", "getPackageName", "(", ")", ")", ";", "}" ]

[ "Fetch", "flag", "resource", "by", "Country" ]

[ "private", "static", "String", "getJsonFromRaw", "(", "Context", "context", ",", "int", "resource", ")", "{", "String", "json", ";", "try", "{", "InputStream", "inputStream", "=", "context", ".", "getResources", "(", ")", ".", "openRawResource", "(", "resource", ")", ";", "int", "size", "=", "inputStream", ".", "available", "(", ")", ";", "byte", "[", "]", "buffer", "=", "new", "byte", "[", "size", "]", ";", "inputStream", ".", "read", "(", "buffer", ")", ";", "inputStream", ".", "close", "(", ")", ";", "json", "=", "new", "String", "(", "buffer", ",", "\"UTF-8\"", ")", ";", "}", "catch", "(", "IOException", "ex", ")", "{", "ex", ".", "printStackTrace", "(", ")", ";", "return", "null", ";", "}", "return", "json", ";", "}" ]

[ "Fetch", "JSON", "from", "RAW", "resource" ]

[ "public", "static", "CountryList", "getCountries", "(", "Context", "context", ")", "{", "if", "(", "mCountries", "!=", "null", ")", "{", "return", "mCountries", ";", "}", "mCountries", "=", "new", "CountryList", "(", ")", ";", "try", "{", "JSONArray", "countries", "=", "new", "JSONArray", "(", "getJsonFromRaw", "(", "context", ",", "R", ".", "raw", ".", "countries", ")", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "countries", ".", "length", "(", ")", ";", "i", "++", ")", "{", "try", "{", "JSONObject", "country", "=", "(", "JSONObject", ")", "countries", ".", "get", "(", "i", ")", ";", "mCountries", ".", "add", "(", "new", "Country", "(", "country", ".", "getString", "(", "\"name\"", ")", ",", "country", ".", "getString", "(", "\"iso2\"", ")", ",", "country", ".", "getInt", "(", "\"dialCode\"", ")", ")", ")", ";", "}", "catch", "(", "JSONException", "e", ")", "{", "e", ".", "printStackTrace", "(", ")", ";", "}", "}", "}", "catch", "(", "JSONException", "e", ")", "{", "e", ".", "printStackTrace", "(", ")", ";", "}", "return", "mCountries", ";", "}" ]

[ "Import", "CountryList", "from", "RAW", "resource" ]

[ "private", "void", "init", "(", "AttributeSet", "attrs", ")", "{", "inflate", "(", "getContext", "(", ")", ",", "R", ".", "layout", ".", "intl_phone_input", ",", "this", ")", ";", "/**+\n * Country spinner\n */", "mCountrySpinner", "=", "(", "Spinner", ")", "findViewById", "(", "R", ".", "id", ".", "intl_phone_edit__country", ")", ";", "mCountrySpinnerAdapter", "=", "new", "CountrySpinnerAdapter", "(", "getContext", "(", ")", ")", ";", "mCountrySpinner", ".", "setAdapter", "(", "mCountrySpinnerAdapter", ")", ";", "mCountries", "=", "CountriesFetcher", ".", "getCountries", "(", "getContext", "(", ")", ")", ";", "mCountrySpinnerAdapter", ".", "addAll", "(", "mCountries", ")", ";", "mCountrySpinner", ".", "setOnItemSelectedListener", "(", "mCountrySpinnerListener", ")", ";", "setFlagDefaults", "(", "attrs", ")", ";", "/**\n * Phone text field\n */", "mPhoneEdit", "=", "(", "EditText", ")", "findViewById", "(", "R", ".", "id", ".", "intl_phone_edit__phone", ")", ";", "mPhoneEdit", ".", "addTextChangedListener", "(", "mPhoneNumberWatcher", ")", ";", "setDefault", "(", ")", ";", "setEditTextDefaults", "(", "attrs", ")", ";", "}" ]

[ "Init", "after", "constructor" ]

[ "public", "void", "hideKeyboard", "(", ")", "{", "InputMethodManager", "inputMethodManager", "=", "(", "InputMethodManager", ")", "getContext", "(", ")", ".", "getApplicationContext", "(", ")", ".", "getSystemService", "(", "Context", ".", "INPUT_METHOD_SERVICE", ")", ";", "inputMethodManager", ".", "hideSoftInputFromWindow", "(", "mPhoneEdit", ".", "getWindowToken", "(", ")", ",", "0", ")", ";", "}" ]

[ "Hide", "keyboard", "from", "phoneEdit", "field" ]

[ "public", "void", "setDefault", "(", ")", "{", "try", "{", "TelephonyManager", "telephonyManager", "=", "(", "TelephonyManager", ")", "getContext", "(", ")", ".", "getSystemService", "(", "Context", ".", "TELEPHONY_SERVICE", ")", ";", "String", "phone", "=", "telephonyManager", ".", "getLine1Number", "(", ")", ";", "if", "(", "phone", "!=", "null", "&&", "!", "phone", ".", "isEmpty", "(", ")", ")", "{", "this", ".", "setNumber", "(", "phone", ")", ";", "}", "else", "{", "String", "iso", "=", "telephonyManager", ".", "getNetworkCountryIso", "(", ")", ";", "setEmptyDefault", "(", "iso", ")", ";", "}", "}", "catch", "(", "SecurityException", "e", ")", "{", "setEmptyDefault", "(", ")", ";", "}", "}" ]

[ "Set", "default", "value", "Will", "try", "to", "retrieve", "phone", "number", "from", "device" ]

[ "public", "void", "setEmptyDefault", "(", "String", "iso", ")", "{", "if", "(", "iso", "==", "null", "||", "iso", ".", "isEmpty", "(", ")", ")", "{", "iso", "=", "DEFAULT_COUNTRY", ";", "}", "int", "defaultIdx", "=", "mCountries", ".", "indexOfIso", "(", "iso", ")", ";", "mSelectedCountry", "=", "mCountries", ".", "get", "(", "defaultIdx", ")", ";", "mCountrySpinner", ".", "setSelection", "(", "defaultIdx", ")", ";", "}" ]

[ "Set", "default", "value", "with" ]

[ "private", "void", "setHint", "(", ")", "{", "if", "(", "mPhoneEdit", "!=", "null", "&&", "mSelectedCountry", "!=", "null", "&&", "mSelectedCountry", ".", "getIso", "(", ")", "!=", "null", ")", "{", "Phonenumber", ".", "PhoneNumber", "phoneNumber", "=", "mPhoneUtil", ".", "getExampleNumberForType", "(", "mSelectedCountry", ".", "getIso", "(", ")", ",", "PhoneNumberUtil", ".", "PhoneNumberType", ".", "MOBILE", ")", ";", "if", "(", "phoneNumber", "!=", "null", ")", "{", "mPhoneEdit", ".", "setHint", "(", "mPhoneUtil", ".", "format", "(", "phoneNumber", ",", "PhoneNumberUtil", ".", "PhoneNumberFormat", ".", "NATIONAL", ")", ")", ";", "}", "}", "}" ]

[ "Set", "hint", "number", "for", "country" ]

[ "@", "SuppressWarnings", "(", "\"unused\"", ")", "public", "Phonenumber", ".", "PhoneNumber", "getPhoneNumber", "(", ")", "{", "try", "{", "String", "iso", "=", "null", ";", "if", "(", "mSelectedCountry", "!=", "null", ")", "{", "iso", "=", "mSelectedCountry", ".", "getIso", "(", ")", ";", "}", "return", "mPhoneUtil", ".", "parse", "(", "mPhoneEdit", ".", "getText", "(", ")", ".", "toString", "(", ")", ",", "iso", ")", ";", "}", "catch", "(", "NumberParseException", "ignored", ")", "{", "return", "null", ";", "}", "}" ]

[ "Get", "PhoneNumber", "object" ]

[ "@", "SuppressWarnings", "(", "\"unused\"", ")", "public", "boolean", "isValid", "(", ")", "{", "Phonenumber", ".", "PhoneNumber", "phoneNumber", "=", "getPhoneNumber", "(", ")", ";", "return", "phoneNumber", "!=", "null", "&&", "mPhoneUtil", ".", "isValidNumber", "(", "phoneNumber", ")", ";", "}" ]

[ "Check", "if", "number", "is", "valid" ]

[ "@", "SuppressWarnings", "(", "\"unused\"", ")", "public", "void", "setError", "(", "CharSequence", "error", ",", "Drawable", "icon", ")", "{", "mPhoneEdit", ".", "setError", "(", "error", ",", "icon", ")", ";", "}" ]

[ "Sets", "an", "error", "message", "that", "will", "be", "displayed", "in", "a", "popup", "when", "the", "EditText", "has", "focus", "along", "with", "an", "icon", "displayed", "at", "the", "right", "-", "hand", "side", "." ]

[ "public", "void", "setOnKeyboardDone", "(", "final", "IntlPhoneInputListener", "listener", ")", "{", "mPhoneEdit", ".", "setOnEditorActionListener", "(", "new", "TextView", ".", "OnEditorActionListener", "(", ")", "{", "@", "Override", "public", "boolean", "onEditorAction", "(", "TextView", "v", ",", "int", "actionId", ",", "KeyEvent", "event", ")", "{", "if", "(", "actionId", "==", "EditorInfo", ".", "IME_ACTION_DONE", ")", "{", "listener", ".", "done", "(", "IntlPhoneInput", ".", "this", ",", "isValid", "(", ")", ")", ";", "}", "return", "false", ";", "}", "}", ")", ";", "}" ]

[ "Set", "keyboard", "done", "listener", "to", "detect", "when", "the", "user", "click", "DONE", "on", "his", "keyboard" ]

[ "private", "synchronized", "Client", "allocateClient", "(", "int", "targetPlayer", ",", "String", "description", ")", "throws", "IOException", "{", "Client", "result", "=", "openClients", ".", "get", "(", "targetPlayer", ")", ";", "if", "(", "result", "==", "null", ")", "{", "// We need to open a new connection.", "final", "DeviceAnnouncement", "deviceAnnouncement", "=", "DeviceFinder", ".", "getInstance", "(", ")", ".", "getLatestAnnouncementFrom", "(", "targetPlayer", ")", ";", "if", "(", "deviceAnnouncement", "==", "null", ")", "{", "throw", "new", "IllegalStateException", "(", "\"Player \"", "+", "targetPlayer", "+", "\" could not be found \"", "+", "description", ")", ";", "}", "final", "int", "dbServerPort", "=", "getPlayerDBServerPort", "(", "targetPlayer", ")", ";", "if", "(", "dbServerPort", "<", "0", ")", "{", "throw", "new", "IllegalStateException", "(", "\"Player \"", "+", "targetPlayer", "+", "\" does not have a db server \"", "+", "description", ")", ";", "}", "final", "byte", "posingAsPlayerNumber", "=", "(", "byte", ")", "chooseAskingPlayerNumber", "(", "targetPlayer", ")", ";", "Socket", "socket", "=", "null", ";", "try", "{", "InetSocketAddress", "address", "=", "new", "InetSocketAddress", "(", "deviceAnnouncement", ".", "getAddress", "(", ")", ",", "dbServerPort", ")", ";", "socket", "=", "new", "Socket", "(", ")", ";", "socket", ".", "connect", "(", "address", ",", "socketTimeout", ".", "get", "(", ")", ")", ";", "socket", ".", "setSoTimeout", "(", "socketTimeout", ".", "get", "(", ")", ")", ";", "result", "=", "new", "Client", "(", "socket", ",", "targetPlayer", ",", "posingAsPlayerNumber", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "try", "{", "socket", ".", "close", "(", ")", ";", "}", "catch", "(", "IOException", "e2", ")", "{", "logger", ".", "error", "(", "\"Problem closing socket for failed client creation attempt \"", "+", "description", ")", ";", "}", "throw", "e", ";", "}", "openClients", ".", "put", "(", "targetPlayer", ",", "result", ")", ";", "useCounts", ".", "put", "(", "result", ",", "0", ")", ";", "}", "useCounts", ".", "put", "(", "result", ",", "useCounts", ".", "get", "(", "result", ")", "+", "1", ")", ";", "return", "result", ";", "}" ]

[ "Finds", "or", "opens", "a", "client", "to", "talk", "to", "the", "dbserver", "on", "the", "specified", "player", "incrementing", "its", "use", "count", "." ]

[ "private", "void", "closeClient", "(", "Client", "client", ")", "{", "logger", ".", "debug", "(", "\"Closing client {}\"", ",", "client", ")", ";", "client", ".", "close", "(", ")", ";", "openClients", ".", "remove", "(", "client", ".", "targetPlayer", ")", ";", "useCounts", ".", "remove", "(", "client", ")", ";", "timestamps", ".", "remove", "(", "client", ")", ";", "}" ]

[ "When", "it", "is", "time", "to", "actually", "close", "a", "client", "do", "so", "and", "clean", "up", "the", "related", "data", "structures", "." ]

[ "private", "synchronized", "void", "freeClient", "(", "Client", "client", ")", "{", "int", "current", "=", "useCounts", ".", "get", "(", "client", ")", ";", "if", "(", "current", ">", "0", ")", "{", "timestamps", ".", "put", "(", "client", ",", "System", ".", "currentTimeMillis", "(", ")", ")", ";", "// Mark that it was used until now.", "useCounts", ".", "put", "(", "client", ",", "current", "-", "1", ")", ";", "if", "(", "(", "current", "==", "1", ")", "&&", "(", "idleLimit", ".", "get", "(", ")", "==", "0", ")", ")", "{", "closeClient", "(", "client", ")", ";", "// This was the last use, and we are supposed to immediately close idle clients.", "}", "}", "else", "{", "logger", ".", "error", "(", "\"Ignoring attempt to free a client that is not allocated: {}\"", ",", "client", ")", ";", "}", "}" ]

[ "Decrements", "the", "client", "s", "use", "count", "and", "makes", "it", "eligible", "for", "closing", "if", "it", "is", "no", "longer", "in", "use", "." ]

[ "public", "<", "T", ">", "T", "invokeWithClientSession", "(", "int", "targetPlayer", ",", "ClientTask", "<", "T", ">", "task", ",", "String", "description", ")", "throws", "Exception", "{", "if", "(", "!", "isRunning", "(", ")", ")", "{", "throw", "new", "IllegalStateException", "(", "\"ConnectionManager is not running, aborting \"", "+", "description", ")", ";", "}", "final", "Client", "client", "=", "allocateClient", "(", "targetPlayer", ",", "description", ")", ";", "try", "{", "return", "task", ".", "useClient", "(", "client", ")", ";", "}", "finally", "{", "freeClient", "(", "client", ")", ";", "}", "}" ]

[ "Obtain", "a", "dbserver", "client", "session", "that", "can", "be", "used", "to", "perform", "some", "task", "call", "that", "task", "with", "the", "client", "then", "release", "the", "client", "." ]

[ "@", "SuppressWarnings", "(", "\"WeakerAccess\"", ")", "public", "int", "getPlayerDBServerPort", "(", "int", "player", ")", "{", "ensureRunning", "(", ")", ";", "Integer", "result", "=", "dbServerPorts", ".", "get", "(", "player", ")", ";", "if", "(", "result", "==", "null", ")", "{", "return", "-", "1", ";", "}", "return", "result", ";", "}" ]

[ "Look", "up", "the", "database", "server", "port", "reported", "by", "a", "given", "player", ".", "You", "should", "not", "use", "this", "port", "directly", ";", "instead", "ask", "this", "class", "for", "a", "session", "to", "use", "while", "you", "communicate", "with", "the", "database", "." ]

[ "private", "void", "requestPlayerDBServerPort", "(", "DeviceAnnouncement", "announcement", ")", "{", "Socket", "socket", "=", "null", ";", "try", "{", "InetSocketAddress", "address", "=", "new", "InetSocketAddress", "(", "announcement", ".", "getAddress", "(", ")", ",", "DB_SERVER_QUERY_PORT", ")", ";", "socket", "=", "new", "Socket", "(", ")", ";", "socket", ".", "connect", "(", "address", ",", "socketTimeout", ".", "get", "(", ")", ")", ";", "InputStream", "is", "=", "socket", ".", "getInputStream", "(", ")", ";", "OutputStream", "os", "=", "socket", ".", "getOutputStream", "(", ")", ";", "socket", ".", "setSoTimeout", "(", "socketTimeout", ".", "get", "(", ")", ")", ";", "os", ".", "write", "(", "DB_SERVER_QUERY_PACKET", ")", ";", "byte", "[", "]", "response", "=", "readResponseWithExpectedSize", "(", "is", ",", "2", ",", "\"database server port query packet\"", ")", ";", "if", "(", "response", ".", "length", "==", "2", ")", "{", "setPlayerDBServerPort", "(", "announcement", ".", "getNumber", "(", ")", ",", "(", "int", ")", "Util", ".", "bytesToNumber", "(", "response", ",", "0", ",", "2", ")", ")", ";", "}", "}", "catch", "(", "java", ".", "net", ".", "ConnectException", "ce", ")", "{", "logger", ".", "info", "(", "\"Player \"", "+", "announcement", ".", "getNumber", "(", ")", "+", "\" doesn't answer rekordbox port queries, connection refused. Won't attempt to request metadata.\"", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "logger", ".", "warn", "(", "\"Problem requesting database server port number\"", ",", "e", ")", ";", "}", "finally", "{", "if", "(", "socket", "!=", "null", ")", "{", "try", "{", "socket", ".", "close", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "logger", ".", "warn", "(", "\"Problem closing database server port request socket\"", ",", "e", ")", ";", "}", "}", "}", "}" ]

[ "Query", "a", "player", "to", "determine", "the", "port", "on", "which", "its", "database", "server", "is", "running", "." ]

[ "private", "byte", "[", "]", "receiveBytes", "(", "InputStream", "is", ")", "throws", "IOException", "{", "byte", "[", "]", "buffer", "=", "new", "byte", "[", "8192", "]", ";", "int", "len", "=", "(", "is", ".", "read", "(", "buffer", ")", ")", ";", "if", "(", "len", "<", "1", ")", "{", "throw", "new", "IOException", "(", "\"receiveBytes read \"", "+", "len", "+", "\" bytes.\"", ")", ";", "}", "return", "Arrays", ".", "copyOf", "(", "buffer", ",", "len", ")", ";", "}" ]

[ "Receive", "some", "bytes", "from", "the", "player", "we", "are", "requesting", "metadata", "from", "." ]

[ "@", "SuppressWarnings", "(", "\"SameParameterValue\"", ")", "private", "byte", "[", "]", "readResponseWithExpectedSize", "(", "InputStream", "is", ",", "int", "size", ",", "String", "description", ")", "throws", "IOException", "{", "byte", "[", "]", "result", "=", "receiveBytes", "(", "is", ")", ";", "if", "(", "result", ".", "length", "!=", "size", ")", "{", "logger", ".", "warn", "(", "\"Expected \"", "+", "size", "+", "\" bytes while reading \"", "+", "description", "+", "\" response, received \"", "+", "result", ".", "length", ")", ";", "}", "return", "result", ";", "}" ]

[ "Receive", "an", "expected", "number", "of", "bytes", "from", "the", "player", "logging", "a", "warning", "if", "we", "get", "a", "different", "number", "of", "them", "." ]

[ "private", "synchronized", "void", "closeIdleClients", "(", ")", "{", "List", "<", "Client", ">", "candidates", "=", "new", "LinkedList", "<", "Client", ">", "(", "openClients", ".", "values", "(", ")", ")", ";", "logger", ".", "debug", "(", "\"Scanning for idle clients; \"", "+", "candidates", ".", "size", "(", ")", "+", "\" candidates.\"", ")", ";", "for", "(", "Client", "client", ":", "candidates", ")", "{", "if", "(", "(", "useCounts", ".", "get", "(", "client", ")", "<", "1", ")", "&&", "(", "(", "timestamps", ".", "get", "(", "client", ")", "+", "idleLimit", ".", "get", "(", ")", "*", "1000", ")", "<=", "System", ".", "currentTimeMillis", "(", ")", ")", ")", "{", "logger", ".", "debug", "(", "\"Idle time reached for unused client {}\"", ",", "client", ")", ";", "closeClient", "(", "client", ")", ";", "}", "}", "}" ]

[ "Finds", "any", "clients", "which", "are", "not", "currently", "in", "use", "and", "which", "have", "been", "idle", "for", "longer", "than", "the", "idle", "timeout", "and", "closes", "them", "." ]

[ "public", "synchronized", "void", "start", "(", ")", "throws", "SocketException", "{", "if", "(", "!", "isRunning", "(", ")", ")", "{", "DeviceFinder", ".", "getInstance", "(", ")", ".", "addLifecycleListener", "(", "lifecycleListener", ")", ";", "DeviceFinder", ".", "getInstance", "(", ")", ".", "addDeviceAnnouncementListener", "(", "announcementListener", ")", ";", "DeviceFinder", ".", "getInstance", "(", ")", ".", "start", "(", ")", ";", "for", "(", "DeviceAnnouncement", "device", ":", "DeviceFinder", ".", "getInstance", "(", ")", ".", "getCurrentDevices", "(", ")", ")", "{", "requestPlayerDBServerPort", "(", "device", ")", ";", "}", "new", "Thread", "(", "null", ",", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "while", "(", "isRunning", "(", ")", ")", "{", "try", "{", "Thread", ".", "sleep", "(", "500", ")", ";", "}", "catch", "(", "InterruptedException", "e", ")", "{", "logger", ".", "warn", "(", "\"Interrupted sleeping to close idle dbserver clients\"", ")", ";", "}", "closeIdleClients", "(", ")", ";", "}", "logger", ".", "info", "(", "\"Idle dbserver client closer shutting down.\"", ")", ";", "}", "}", ",", "\"Idle dbserver client closer\"", ")", ".", "start", "(", ")", ";", "running", ".", "set", "(", "true", ")", ";", "deliverLifecycleAnnouncement", "(", "logger", ",", "true", ")", ";", "}", "}" ]

[ "Start", "offering", "shared", "dbserver", "sessions", "." ]

[ "public", "synchronized", "void", "stop", "(", ")", "{", "if", "(", "isRunning", "(", ")", ")", "{", "running", ".", "set", "(", "false", ")", ";", "DeviceFinder", ".", "getInstance", "(", ")", ".", "removeDeviceAnnouncementListener", "(", "announcementListener", ")", ";", "dbServerPorts", ".", "clear", "(", ")", ";", "for", "(", "Client", "client", ":", "openClients", ".", "values", "(", ")", ")", "{", "try", "{", "client", ".", "close", "(", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "logger", ".", "warn", "(", "\"Problem closing \"", "+", "client", "+", "\" when stopping\"", ",", "e", ")", ";", "}", "}", "openClients", ".", "clear", "(", ")", ";", "useCounts", ".", "clear", "(", ")", ";", "deliverLifecycleAnnouncement", "(", "logger", ",", "false", ")", ";", "}", "}" ]

[ "Stop", "offering", "shared", "dbserver", "sessions", "." ]

[ "private", "SearchableItem", "buildSearchableItem", "(", "Message", "menuItem", ")", "{", "return", "new", "SearchableItem", "(", "(", "int", ")", "(", "(", "NumberField", ")", "menuItem", ".", "arguments", ".", "get", "(", "1", ")", ")", ".", "getValue", "(", ")", ",", "(", "(", "StringField", ")", "menuItem", ".", "arguments", ".", "get", "(", "3", ")", ")", ".", "getValue", "(", ")", ")", ";", "}" ]

[ "Creates", "a", "searchable", "item", "that", "represents", "a", "metadata", "field", "found", "for", "a", "track", "." ]

[ "private", "ColorItem", "buildColorItem", "(", "Message", "menuItem", ")", "{", "final", "int", "colorId", "=", "(", "int", ")", "(", "(", "NumberField", ")", "menuItem", ".", "arguments", ".", "get", "(", "1", ")", ")", ".", "getValue", "(", ")", ";", "final", "String", "label", "=", "(", "(", "StringField", ")", "menuItem", ".", "arguments", ".", "get", "(", "3", ")", ")", ".", "getValue", "(", ")", ";", "return", "buildColorItem", "(", "colorId", ",", "label", ")", ";", "}" ]

[ "Creates", "a", "color", "item", "that", "represents", "a", "color", "field", "found", "for", "a", "track", "based", "on", "a", "dbserver", "message", "." ]

[ "private", "ColorItem", "buildColorItem", "(", "int", "colorId", ",", "String", "label", ")", "{", "Color", "color", ";", "String", "colorName", ";", "switch", "(", "colorId", ")", "{", "case", "0", ":", "color", "=", "new", "Color", "(", "0", ",", "0", ",", "0", ",", "0", ")", ";", "colorName", "=", "\"No Color\"", ";", "break", ";", "case", "1", ":", "color", "=", "Color", ".", "PINK", ";", "colorName", "=", "\"Pink\"", ";", "break", ";", "case", "2", ":", "color", "=", "Color", ".", "RED", ";", "colorName", "=", "\"Red\"", ";", "break", ";", "case", "3", ":", "color", "=", "Color", ".", "ORANGE", ";", "colorName", "=", "\"Orange\"", ";", "break", ";", "case", "4", ":", "color", "=", "Color", ".", "YELLOW", ";", "colorName", "=", "\"Yellow\"", ";", "break", ";", "case", "5", ":", "color", "=", "Color", ".", "GREEN", ";", "colorName", "=", "\"Green\"", ";", "break", ";", "case", "6", ":", "color", "=", "Color", ".", "CYAN", ";", "colorName", "=", "\"Aqua\"", ";", "break", ";", "case", "7", ":", "color", "=", "Color", ".", "BLUE", ";", "colorName", "=", "\"Blue\"", ";", "break", ";", "case", "8", ":", "color", "=", "new", "Color", "(", "128", ",", "0", ",", "128", ")", ";", "colorName", "=", "\"Purple\"", ";", "break", ";", "default", ":", "color", "=", "new", "Color", "(", "0", ",", "0", ",", "0", ",", "0", ")", ";", "colorName", "=", "\"Unknown Color\"", ";", "}", "return", "new", "ColorItem", "(", "colorId", ",", "label", ",", "color", ",", "colorName", ")", ";", "}" ]

[ "Creates", "a", "color", "item", "that", "represents", "a", "color", "field", "fond", "for", "a", "track", "." ]

[ "private", "void", "parseMetadataItem", "(", "Message", "item", ")", "{", "switch", "(", "item", ".", "getMenuItemType", "(", ")", ")", "{", "case", "TRACK_TITLE", ":", "title", "=", "(", "(", "StringField", ")", "item", ".", "arguments", ".", "get", "(", "3", ")", ")", ".", "getValue", "(", ")", ";", "artworkId", "=", "(", "int", ")", "(", "(", "NumberField", ")", "item", ".", "arguments", ".", "get", "(", "8", ")", ")", ".", "getValue", "(", ")", ";", "break", ";", "case", "ARTIST", ":", "artist", "=", "buildSearchableItem", "(", "item", ")", ";", "break", ";", "case", "ORIGINAL_ARTIST", ":", "originalArtist", "=", "buildSearchableItem", "(", "item", ")", ";", "break", ";", "case", "REMIXER", ":", "remixer", "=", "buildSearchableItem", "(", "item", ")", ";", "case", "ALBUM_TITLE", ":", "album", "=", "buildSearchableItem", "(", "item", ")", ";", "break", ";", "case", "LABEL", ":", "label", "=", "buildSearchableItem", "(", "item", ")", ";", "break", ";", "case", "DURATION", ":", "duration", "=", "(", "int", ")", "(", "(", "NumberField", ")", "item", ".", "arguments", ".", "get", "(", "1", ")", ")", ".", "getValue", "(", ")", ";", "break", ";", "case", "TEMPO", ":", "tempo", "=", "(", "int", ")", "(", "(", "NumberField", ")", "item", ".", "arguments", ".", "get", "(", "1", ")", ")", ".", "getValue", "(", ")", ";", "break", ";", "case", "COMMENT", ":", "comment", "=", "(", "(", "StringField", ")", "item", ".", "arguments", ".", "get", "(", "3", ")", ")", ".", "getValue", "(", ")", ";", "break", ";", "case", "KEY", ":", "key", "=", "buildSearchableItem", "(", "item", ")", ";", "break", ";", "case", "RATING", ":", "rating", "=", "(", "int", ")", "(", "(", "NumberField", ")", "item", ".", "arguments", ".", "get", "(", "1", ")", ")", ".", "getValue", "(", ")", ";", "break", ";", "case", "COLOR_NONE", ":", "case", "COLOR_AQUA", ":", "case", "COLOR_BLUE", ":", "case", "COLOR_GREEN", ":", "case", "COLOR_ORANGE", ":", "case", "COLOR_PINK", ":", "case", "COLOR_PURPLE", ":", "case", "COLOR_RED", ":", "case", "COLOR_YELLOW", ":", "color", "=", "buildColorItem", "(", "item", ")", ";", "break", ";", "case", "GENRE", ":", "genre", "=", "buildSearchableItem", "(", "item", ")", ";", "break", ";", "case", "DATE_ADDED", ":", "dateAdded", "=", "(", "(", "StringField", ")", "item", ".", "arguments", ".", "get", "(", "3", ")", ")", ".", "getValue", "(", ")", ";", "break", ";", "case", "YEAR", ":", "year", "=", "(", "int", ")", "(", "(", "NumberField", ")", "item", ".", "arguments", ".", "get", "(", "1", ")", ")", ".", "getValue", "(", ")", ";", "break", ";", "case", "BIT_RATE", ":", "bitRate", "=", "(", "int", ")", "(", "(", "NumberField", ")", "item", ".", "arguments", ".", "get", "(", "1", ")", ")", ".", "getValue", "(", ")", ";", "break", ";", "default", ":", "logger", ".", "warn", "(", "\"Ignoring track metadata item with unknown type: {}\"", ",", "item", ")", ";", "}", "}" ]

[ "Processes", "one", "of", "the", "menu", "responses", "that", "jointly", "constitute", "the", "track", "metadata", "updating", "our", "fields", "accordingly", "." ]

[ "@", "SuppressWarnings", "(", "\"WeakerAccess\"", ")", "public", "ByteBuffer", "getRawData", "(", ")", "{", "if", "(", "rawData", "!=", "null", ")", "{", "rawData", ".", "rewind", "(", ")", ";", "return", "rawData", ".", "slice", "(", ")", ";", "}", "return", "null", ";", "}" ]

[ "Get", "the", "raw", "bytes", "of", "the", "beat", "grid", "as", "it", "was", "read", "over", "the", "network", ".", "This", "can", "be", "used", "to", "analyze", "fields", "that", "have", "not", "yet", "been", "reliably", "understood", "and", "is", "also", "used", "for", "storing", "the", "beat", "grid", "in", "a", "cache", "file", ".", "This", "is", "not", "available", "when", "the", "beat", "grid", "was", "loaded", "by", "Crate", "Digger", "." ]

[ "private", "RekordboxAnlz", ".", "BeatGridTag", "findTag", "(", "RekordboxAnlz", "anlzFile", ")", "{", "for", "(", "RekordboxAnlz", ".", "TaggedSection", "section", ":", "anlzFile", ".", "sections", "(", ")", ")", "{", "if", "(", "section", ".", "body", "(", ")", "instanceof", "RekordboxAnlz", ".", "BeatGridTag", ")", "{", "return", "(", "RekordboxAnlz", ".", "BeatGridTag", ")", "section", ".", "body", "(", ")", ";", "}", "}", "throw", "new", "IllegalArgumentException", "(", "\"No beat grid found inside analysis file \"", "+", "anlzFile", ")", ";", "}" ]

[ "Helper", "function", "to", "find", "the", "beat", "grid", "section", "in", "a", "rekordbox", "track", "analysis", "file", "." ]

[ "private", "int", "beatOffset", "(", "int", "beatNumber", ")", "{", "if", "(", "beatCount", "==", "0", ")", "{", "throw", "new", "IllegalStateException", "(", "\"There are no beats in this beat grid.\"", ")", ";", "}", "if", "(", "beatNumber", "<", "1", "||", "beatNumber", ">", "beatCount", ")", "{", "throw", "new", "IndexOutOfBoundsException", "(", "\"beatNumber (\"", "+", "beatNumber", "+", "\") must be between 1 and \"", "+", "beatCount", ")", ";", "}", "return", "beatNumber", "-", "1", ";", "}" ]

[ "Calculate", "where", "within", "the", "beat", "grid", "array", "the", "information", "for", "the", "specified", "beat", "can", "be", "found", ".", "Yes", "this", "is", "a", "super", "simple", "calculation", ";", "the", "main", "point", "of", "the", "method", "is", "to", "provide", "a", "nice", "exception", "when", "the", "beat", "is", "out", "of", "bounds", "." ]

[ "@", "SuppressWarnings", "(", "\"WeakerAccess\"", ")", "public", "int", "findBeatAtTime", "(", "long", "milliseconds", ")", "{", "int", "found", "=", "Arrays", ".", "binarySearch", "(", "timeWithinTrackValues", ",", "milliseconds", ")", ";", "if", "(", "found", ">=", "0", ")", "{", "// An exact match, just change 0-based array index to 1-based beat number", "return", "found", "+", "1", ";", "}", "else", "if", "(", "found", "==", "-", "1", ")", "{", "// We are before the first beat", "return", "found", ";", "}", "else", "{", "// We are after some beat, report its beat number", "return", "-", "(", "found", "+", "1", ")", ";", "}", "}" ]

[ "Finds", "the", "beat", "in", "which", "the", "specified", "track", "position", "falls", "." ]

[ "public", "List", "<", "Message", ">", "requestTrackMenuFrom", "(", "final", "SlotReference", "slotReference", ",", "final", "int", "sortOrder", ")", "throws", "Exception", "{", "ConnectionManager", ".", "ClientTask", "<", "List", "<", "Message", ">>", "task", "=", "new", "ConnectionManager", ".", "ClientTask", "<", "List", "<", "Message", ">", ">", "(", ")", "{", "@", "Override", "public", "List", "<", "Message", ">", "useClient", "(", "Client", "client", ")", "throws", "Exception", "{", "return", "MetadataFinder", ".", "getInstance", "(", ")", ".", "getFullTrackList", "(", "slotReference", ".", "slot", ",", "client", ",", "sortOrder", ")", ";", "}", "}", ";", "return", "ConnectionManager", ".", "getInstance", "(", ")", ".", "invokeWithClientSession", "(", "slotReference", ".", "player", ",", "task", ",", "\"requesting track menu\"", ")", ";", "}" ]

[ "Ask", "the", "specified", "player", "for", "a", "Track", "menu", "." ]

[ "public", "List", "<", "Message", ">", "requestArtistMenuFrom", "(", "final", "SlotReference", "slotReference", ",", "final", "int", "sortOrder", ")", "throws", "Exception", "{", "ConnectionManager", ".", "ClientTask", "<", "List", "<", "Message", ">>", "task", "=", "new", "ConnectionManager", ".", "ClientTask", "<", "List", "<", "Message", ">", ">", "(", ")", "{", "@", "Override", "public", "List", "<", "Message", ">", "useClient", "(", "Client", "client", ")", "throws", "Exception", "{", "if", "(", "client", ".", "tryLockingForMenuOperations", "(", "MetadataFinder", ".", "MENU_TIMEOUT", ",", "TimeUnit", ".", "SECONDS", ")", ")", "{", "try", "{", "logger", ".", "debug", "(", "\"Requesting Artist menu.\"", ")", ";", "Message", "response", "=", "client", ".", "menuRequest", "(", "Message", ".", "KnownType", ".", "ARTIST_MENU_REQ", ",", "Message", ".", "MenuIdentifier", ".", "MAIN_MENU", ",", "slotReference", ".", "slot", ",", "new", "NumberField", "(", "sortOrder", ")", ")", ";", "return", "client", ".", "renderMenuItems", "(", "Message", ".", "MenuIdentifier", ".", "MAIN_MENU", ",", "slotReference", ".", "slot", ",", "CdjStatus", ".", "TrackType", ".", "REKORDBOX", ",", "response", ")", ";", "}", "finally", "{", "client", ".", "unlockForMenuOperations", "(", ")", ";", "}", "}", "else", "{", "throw", "new", "TimeoutException", "(", "\"Unable to lock player for menu operations.\"", ")", ";", "}", "}", "}", ";", "return", "ConnectionManager", ".", "getInstance", "(", ")", ".", "invokeWithClientSession", "(", "slotReference", ".", "player", ",", "task", ",", "\"requesting artist menu\"", ")", ";", "}" ]

[ "Ask", "the", "specified", "player", "for", "an", "Artist", "menu", "." ]

[ "public", "List", "<", "Message", ">", "requestFolderMenuFrom", "(", "final", "SlotReference", "slotReference", ",", "final", "int", "sortOrder", ",", "final", "int", "folderId", ")", "throws", "Exception", "{", "ConnectionManager", ".", "ClientTask", "<", "List", "<", "Message", ">>", "task", "=", "new", "ConnectionManager", ".", "ClientTask", "<", "List", "<", "Message", ">", ">", "(", ")", "{", "@", "Override", "public", "List", "<", "Message", ">", "useClient", "(", "Client", "client", ")", "throws", "Exception", "{", "if", "(", "client", ".", "tryLockingForMenuOperations", "(", "MetadataFinder", ".", "MENU_TIMEOUT", ",", "TimeUnit", ".", "SECONDS", ")", ")", "{", "try", "{", "logger", ".", "debug", "(", "\"Requesting Key menu.\"", ")", ";", "Message", "response", "=", "client", ".", "menuRequestTyped", "(", "Message", ".", "KnownType", ".", "FOLDER_MENU_REQ", ",", "Message", ".", "MenuIdentifier", ".", "MAIN_MENU", ",", "slotReference", ".", "slot", ",", "CdjStatus", ".", "TrackType", ".", "UNANALYZED", ",", "new", "NumberField", "(", "sortOrder", ")", ",", "new", "NumberField", "(", "folderId", ")", ",", "new", "NumberField", "(", "0xffffff", ")", ")", ";", "return", "client", ".", "renderMenuItems", "(", "Message", ".", "MenuIdentifier", ".", "MAIN_MENU", ",", "slotReference", ".", "slot", ",", "CdjStatus", ".", "TrackType", ".", "UNANALYZED", ",", "response", ")", ";", "}", "finally", "{", "client", ".", "unlockForMenuOperations", "(", ")", ";", "}", "}", "else", "{", "throw", "new", "TimeoutException", "(", "\"Unable to lock player for menu operations.\"", ")", ";", "}", "}", "}", ";", "return", "ConnectionManager", ".", "getInstance", "(", ")", ".", "invokeWithClientSession", "(", "slotReference", ".", "player", ",", "task", ",", "\"requesting folder menu\"", ")", ";", "}" ]

[ "Ask", "the", "specified", "player", "for", "a", "Folder", "menu", "for", "exploring", "its", "raw", "filesystem", ".", "This", "is", "a", "request", "for", "unanalyzed", "items", "so", "we", "do", "a", "typed", "menu", "request", "." ]

[ "public", "static", "Field", "read", "(", "DataInputStream", "is", ")", "throws", "IOException", "{", "final", "byte", "tag", "=", "is", ".", "readByte", "(", ")", ";", "final", "Field", "result", ";", "switch", "(", "tag", ")", "{", "case", "0x0f", ":", "case", "0x10", ":", "case", "0x11", ":", "result", "=", "new", "NumberField", "(", "tag", ",", "is", ")", ";", "break", ";", "case", "0x14", ":", "result", "=", "new", "BinaryField", "(", "is", ")", ";", "break", ";", "case", "0x26", ":", "result", "=", "new", "StringField", "(", "is", ")", ";", "break", ";", "default", ":", "throw", "new", "IOException", "(", "\"Unable to read a field with type tag \"", "+", "tag", ")", ";", "}", "logger", ".", "debug", "(", "\"..received> {}\"", ",", "result", ")", ";", "return", "result", ";", "}" ]

[ "Read", "a", "field", "from", "the", "supplied", "stream", "starting", "with", "the", "tag", "that", "identifies", "the", "type", "and", "reading", "enough", "to", "collect", "the", "corresponding", "value", "." ]

[ "public", "void", "write", "(", "WritableByteChannel", "channel", ")", "throws", "IOException", "{", "logger", ".", "debug", "(", "\"..writing> {}\"", ",", "this", ")", ";", "Util", ".", "writeFully", "(", "getBytes", "(", ")", ",", "channel", ")", ";", "}" ]

[ "Write", "the", "field", "to", "the", "specified", "channel", "." ]

[ "@", "SuppressWarnings", "(", "\"WeakerAccess\"", ")", "public", "TrackMetadata", "requestMetadataFrom", "(", "final", "CdjStatus", "status", ")", "{", "if", "(", "status", ".", "getTrackSourceSlot", "(", ")", "==", "CdjStatus", ".", "TrackSourceSlot", ".", "NO_TRACK", "||", "status", ".", "getRekordboxId", "(", ")", "==", "0", ")", "{", "return", "null", ";", "}", "final", "DataReference", "track", "=", "new", "DataReference", "(", "status", ".", "getTrackSourcePlayer", "(", ")", ",", "status", ".", "getTrackSourceSlot", "(", ")", ",", "status", ".", "getRekordboxId", "(", ")", ")", ";", "return", "requestMetadataFrom", "(", "track", ",", "status", ".", "getTrackType", "(", ")", ")", ";", "}" ]

[ "Given", "a", "status", "update", "from", "a", "CDJ", "find", "the", "metadata", "for", "the", "track", "that", "it", "has", "loaded", "if", "any", ".", "If", "there", "is", "an", "appropriate", "metadata", "cache", "will", "use", "that", "otherwise", "makes", "a", "query", "to", "the", "players", "dbserver", "." ]

[ "@", "SuppressWarnings", "(", "\"WeakerAccess\"", ")", "public", "TrackMetadata", "requestMetadataFrom", "(", "final", "DataReference", "track", ",", "final", "CdjStatus", ".", "TrackType", "trackType", ")", "{", "return", "requestMetadataInternal", "(", "track", ",", "trackType", ",", "false", ")", ";", "}" ]

[ "Ask", "the", "specified", "player", "for", "metadata", "about", "the", "track", "in", "the", "specified", "slot", "with", "the", "specified", "rekordbox", "ID", "unless", "we", "have", "a", "metadata", "cache", "available", "for", "the", "specified", "media", "slot", "in", "which", "case", "that", "will", "be", "used", "instead", "." ]

[ "private", "TrackMetadata", "requestMetadataInternal", "(", "final", "DataReference", "track", ",", "final", "CdjStatus", ".", "TrackType", "trackType", ",", "final", "boolean", "failIfPassive", ")", "{", "// First check if we are using cached data for this request.", "MetadataCache", "cache", "=", "getMetadataCache", "(", "SlotReference", ".", "getSlotReference", "(", "track", ")", ")", ";", "if", "(", "cache", "!=", "null", "&&", "trackType", "==", "CdjStatus", ".", "TrackType", ".", "REKORDBOX", ")", "{", "return", "cache", ".", "getTrackMetadata", "(", "null", ",", "track", ")", ";", "}", "// Then see if any registered metadata providers can offer it for us.", "final", "MediaDetails", "sourceDetails", "=", "getMediaDetailsFor", "(", "track", ".", "getSlotReference", "(", ")", ")", ";", "if", "(", "sourceDetails", "!=", "null", ")", "{", "final", "TrackMetadata", "provided", "=", "allMetadataProviders", ".", "getTrackMetadata", "(", "sourceDetails", ",", "track", ")", ";", "if", "(", "provided", "!=", "null", ")", "{", "return", "provided", ";", "}", "}", "// At this point, unless we are allowed to actively request the data, we are done. We can always actively", "// request tracks from rekordbox.", "if", "(", "passive", ".", "get", "(", ")", "&&", "failIfPassive", "&&", "track", ".", "slot", "!=", "CdjStatus", ".", "TrackSourceSlot", ".", "COLLECTION", ")", "{", "return", "null", ";", "}", "// Use the dbserver protocol implementation to request the metadata.", "ConnectionManager", ".", "ClientTask", "<", "TrackMetadata", ">", "task", "=", "new", "ConnectionManager", ".", "ClientTask", "<", "TrackMetadata", ">", "(", ")", "{", "@", "Override", "public", "TrackMetadata", "useClient", "(", "Client", "client", ")", "throws", "Exception", "{", "return", "queryMetadata", "(", "track", ",", "trackType", ",", "client", ")", ";", "}", "}", ";", "try", "{", "return", "ConnectionManager", ".", "getInstance", "(", ")", ".", "invokeWithClientSession", "(", "track", ".", "player", ",", "task", ",", "\"requesting metadata\"", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "logger", ".", "error", "(", "\"Problem requesting metadata, returning null\"", ",", "e", ")", ";", "}", "return", "null", ";", "}" ]

[ "Ask", "the", "specified", "player", "for", "metadata", "about", "the", "track", "in", "the", "specified", "slot", "with", "the", "specified", "rekordbox", "ID", "using", "cached", "media", "instead", "if", "it", "is", "available", "and", "possibly", "giving", "up", "if", "we", "are", "in", "passive", "mode", "." ]

[ "TrackMetadata", "queryMetadata", "(", "final", "DataReference", "track", ",", "final", "CdjStatus", ".", "TrackType", "trackType", ",", "final", "Client", "client", ")", "throws", "IOException", ",", "InterruptedException", ",", "TimeoutException", "{", "// Send the metadata menu request", "if", "(", "client", ".", "tryLockingForMenuOperations", "(", "20", ",", "TimeUnit", ".", "SECONDS", ")", ")", "{", "try", "{", "final", "Message", ".", "KnownType", "requestType", "=", "(", "trackType", "==", "CdjStatus", ".", "TrackType", ".", "REKORDBOX", ")", "?", "Message", ".", "KnownType", ".", "REKORDBOX_METADATA_REQ", ":", "Message", ".", "KnownType", ".", "UNANALYZED_METADATA_REQ", ";", "final", "Message", "response", "=", "client", ".", "menuRequestTyped", "(", "requestType", ",", "Message", ".", "MenuIdentifier", ".", "MAIN_MENU", ",", "track", ".", "slot", ",", "trackType", ",", "new", "NumberField", "(", "track", ".", "rekordboxId", ")", ")", ";", "final", "long", "count", "=", "response", ".", "getMenuResultsCount", "(", ")", ";", "if", "(", "count", "==", "Message", ".", "NO_MENU_RESULTS_AVAILABLE", ")", "{", "return", "null", ";", "}", "// Gather the cue list and all the metadata menu items", "final", "List", "<", "Message", ">", "items", "=", "client", ".", "renderMenuItems", "(", "Message", ".", "MenuIdentifier", ".", "MAIN_MENU", ",", "track", ".", "slot", ",", "trackType", ",", "response", ")", ";", "final", "CueList", "cueList", "=", "getCueList", "(", "track", ".", "rekordboxId", ",", "track", ".", "slot", ",", "client", ")", ";", "return", "new", "TrackMetadata", "(", "track", ",", "trackType", ",", "items", ",", "cueList", ")", ";", "}", "finally", "{", "client", ".", "unlockForMenuOperations", "(", ")", ";", "}", "}", "else", "{", "throw", "new", "TimeoutException", "(", "\"Unable to lock the player for menu operations\"", ")", ";", "}", "}" ]

[ "Request", "metadata", "for", "a", "specific", "track", "ID", "given", "a", "dbserver", "connection", "to", "a", "player", "that", "has", "already", "been", "set", "up", ".", "Separated", "into", "its", "own", "method", "so", "it", "could", "be", "used", "multiple", "times", "with", "the", "same", "connection", "when", "gathering", "all", "track", "metadata", "." ]

[ "CueList", "getCueList", "(", "int", "rekordboxId", ",", "CdjStatus", ".", "TrackSourceSlot", "slot", ",", "Client", "client", ")", "throws", "IOException", "{", "Message", "response", "=", "client", ".", "simpleRequest", "(", "Message", ".", "KnownType", ".", "CUE_LIST_REQ", ",", "null", ",", "client", ".", "buildRMST", "(", "Message", ".", "MenuIdentifier", ".", "DATA", ",", "slot", ")", ",", "new", "NumberField", "(", "rekordboxId", ")", ")", ";", "if", "(", "response", ".", "knownType", "==", "Message", ".", "KnownType", ".", "CUE_LIST", ")", "{", "return", "new", "CueList", "(", "response", ")", ";", "}", "logger", ".", "error", "(", "\"Unexpected response type when requesting cue list: {}\"", ",", "response", ")", ";", "return", "null", ";", "}" ]

[ "Requests", "the", "cue", "list", "for", "a", "specific", "track", "ID", "given", "a", "dbserver", "connection", "to", "a", "player", "that", "has", "already", "been", "set", "up", "." ]

[ "List", "<", "Message", ">", "getFullTrackList", "(", "final", "CdjStatus", ".", "TrackSourceSlot", "slot", ",", "final", "Client", "client", ",", "final", "int", "sortOrder", ")", "throws", "IOException", ",", "InterruptedException", ",", "TimeoutException", "{", "// Send the metadata menu request", "if", "(", "client", ".", "tryLockingForMenuOperations", "(", "MENU_TIMEOUT", ",", "TimeUnit", ".", "SECONDS", ")", ")", "{", "try", "{", "Message", "response", "=", "client", ".", "menuRequest", "(", "Message", ".", "KnownType", ".", "TRACK_MENU_REQ", ",", "Message", ".", "MenuIdentifier", ".", "MAIN_MENU", ",", "slot", ",", "new", "NumberField", "(", "sortOrder", ")", ")", ";", "final", "long", "count", "=", "response", ".", "getMenuResultsCount", "(", ")", ";", "if", "(", "count", "==", "Message", ".", "NO_MENU_RESULTS_AVAILABLE", "||", "count", "==", "0", ")", "{", "return", "Collections", ".", "emptyList", "(", ")", ";", "}", "// Gather all the metadata menu items", "return", "client", ".", "renderMenuItems", "(", "Message", ".", "MenuIdentifier", ".", "MAIN_MENU", ",", "slot", ",", "CdjStatus", ".", "TrackType", ".", "REKORDBOX", ",", "response", ")", ";", "}", "finally", "{", "client", ".", "unlockForMenuOperations", "(", ")", ";", "}", "}", "else", "{", "throw", "new", "TimeoutException", "(", "\"Unable to lock the player for menu operations\"", ")", ";", "}", "}" ]

[ "Request", "the", "list", "of", "all", "tracks", "in", "the", "specified", "slot", "given", "a", "dbserver", "connection", "to", "a", "player", "that", "has", "already", "been", "set", "up", "." ]

[ "private", "void", "clearDeck", "(", "CdjStatus", "update", ")", "{", "if", "(", "hotCache", ".", "remove", "(", "DeckReference", ".", "getDeckReference", "(", "update", ".", "getDeviceNumber", "(", ")", ",", "0", ")", ")", "!=", "null", ")", "{", "deliverTrackMetadataUpdate", "(", "update", ".", "getDeviceNumber", "(", ")", ",", "null", ")", ";", "}", "}" ]

[ "We", "have", "received", "an", "update", "that", "invalidates", "any", "previous", "metadata", "for", "that", "player", "so", "clear", "it", "out", "and", "alert", "any", "listeners", "if", "this", "represents", "a", "change", ".", "This", "does", "not", "affect", "the", "hot", "cues", ";", "they", "will", "stick", "around", "until", "the", "player", "loads", "a", "new", "track", "that", "overwrites", "one", "or", "more", "of", "them", "." ]

[ "private", "void", "clearMetadata", "(", "DeviceAnnouncement", "announcement", ")", "{", "final", "int", "player", "=", "announcement", ".", "getNumber", "(", ")", ";", "// Iterate over a copy to avoid concurrent modification issues", "for", "(", "DeckReference", "deck", ":", "new", "HashSet", "<", "DeckReference", ">", "(", "hotCache", ".", "keySet", "(", ")", ")", ")", "{", "if", "(", "deck", ".", "player", "==", "player", ")", "{", "hotCache", ".", "remove", "(", "deck", ")", ";", "if", "(", "deck", ".", "hotCue", "==", "0", ")", "{", "deliverTrackMetadataUpdate", "(", "player", ",", "null", ")", ";", "// Inform listeners the metadata is gone.", "}", "}", "}", "}" ]

[ "We", "have", "received", "notification", "that", "a", "device", "is", "no", "longer", "on", "the", "network", "so", "clear", "out", "its", "metadata", "." ]

[ "private", "void", "updateMetadata", "(", "CdjStatus", "update", ",", "TrackMetadata", "data", ")", "{", "hotCache", ".", "put", "(", "DeckReference", ".", "getDeckReference", "(", "update", ".", "getDeviceNumber", "(", ")", ",", "0", ")", ",", "data", ")", ";", "// Main deck", "if", "(", "data", ".", "getCueList", "(", ")", "!=", "null", ")", "{", "// Update the cache with any hot cues in this track as well", "for", "(", "CueList", ".", "Entry", "entry", ":", "data", ".", "getCueList", "(", ")", ".", "entries", ")", "{", "if", "(", "entry", ".", "hotCueNumber", "!=", "0", ")", "{", "hotCache", ".", "put", "(", "DeckReference", ".", "getDeckReference", "(", "update", ".", "getDeviceNumber", "(", ")", ",", "entry", ".", "hotCueNumber", ")", ",", "data", ")", ";", "}", "}", "}", "deliverTrackMetadataUpdate", "(", "update", ".", "getDeviceNumber", "(", ")", ",", "data", ")", ";", "}" ]

[ "We", "have", "obtained", "metadata", "for", "a", "device", "so", "store", "it", "and", "alert", "any", "listeners", "." ]

[ "public", "Map", "<", "DeckReference", ",", "TrackMetadata", ">", "getLoadedTracks", "(", ")", "{", "ensureRunning", "(", ")", ";", "// Make a copy so callers get an immutable snapshot of the current state.", "return", "Collections", ".", "unmodifiableMap", "(", "new", "HashMap", "<", "DeckReference", ",", "TrackMetadata", ">", "(", "hotCache", ")", ")", ";", "}" ]

[ "Get", "the", "metadata", "of", "all", "tracks", "currently", "loaded", "in", "any", "player", "either", "on", "the", "play", "deck", "or", "in", "a", "hot", "cue", "." ]

[ "public", "void", "attachMetadataCache", "(", "SlotReference", "slot", ",", "File", "file", ")", "throws", "IOException", "{", "ensureRunning", "(", ")", ";", "if", "(", "slot", ".", "player", "<", "1", "||", "slot", ".", "player", ">", "4", "||", "DeviceFinder", ".", "getInstance", "(", ")", ".", "getLatestAnnouncementFrom", "(", "slot", ".", "player", ")", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"unable to attach metadata cache for player \"", "+", "slot", ".", "player", ")", ";", "}", "if", "(", "(", "slot", ".", "slot", "!=", "CdjStatus", ".", "TrackSourceSlot", ".", "USB_SLOT", ")", "&&", "(", "slot", ".", "slot", "!=", "CdjStatus", ".", "TrackSourceSlot", ".", "SD_SLOT", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"unable to attach metadata cache for slot \"", "+", "slot", ".", "slot", ")", ";", "}", "MetadataCache", "cache", "=", "new", "MetadataCache", "(", "file", ")", ";", "final", "MediaDetails", "slotDetails", "=", "getMediaDetailsFor", "(", "slot", ")", ";", "if", "(", "cache", ".", "sourceMedia", "!=", "null", "&&", "slotDetails", "!=", "null", ")", "{", "if", "(", "!", "slotDetails", ".", "hashKey", "(", ")", ".", "equals", "(", "cache", ".", "sourceMedia", ".", "hashKey", "(", ")", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Cache was created for different media (\"", "+", "cache", ".", "sourceMedia", ".", "hashKey", "(", ")", "+", "\") than is in the slot (\"", "+", "slotDetails", ".", "hashKey", "(", ")", "+", "\").\"", ")", ";", "}", "if", "(", "slotDetails", ".", "hasChanged", "(", "cache", ".", "sourceMedia", ")", ")", "{", "logger", ".", "warn", "(", "\"Media has changed (\"", "+", "slotDetails", "+", "\") since cache was created (\"", "+", "cache", ".", "sourceMedia", "+", "\"). Attaching anyway as instructed.\"", ")", ";", "}", "}", "attachMetadataCacheInternal", "(", "slot", ",", "cache", ")", ";", "}" ]

[ "Attach", "a", "metadata", "cache", "file", "to", "a", "particular", "player", "media", "slot", "so", "the", "cache", "will", "be", "used", "instead", "of", "querying", "the", "player", "for", "metadata", ".", "This", "supports", "operation", "with", "metadata", "during", "shows", "where", "DJs", "are", "using", "all", "four", "player", "numbers", "and", "heavily", "cross", "-", "linking", "between", "them", "." ]

[ "void", "attachMetadataCacheInternal", "(", "SlotReference", "slot", ",", "MetadataCache", "cache", ")", "{", "MetadataCache", "oldCache", "=", "metadataCacheFiles", ".", "put", "(", "slot", ",", "cache", ")", ";", "if", "(", "oldCache", "!=", "null", ")", "{", "try", "{", "oldCache", ".", "close", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "logger", ".", "error", "(", "\"Problem closing previous metadata cache\"", ",", "e", ")", ";", "}", "}", "deliverCacheUpdate", "(", "slot", ",", "cache", ")", ";", "}" ]

[ "Finishes", "the", "process", "of", "attaching", "a", "metadata", "cache", "file", "once", "it", "has", "been", "opened", "and", "validated", "." ]

[ "public", "void", "detachMetadataCache", "(", "SlotReference", "slot", ")", "{", "MetadataCache", "oldCache", "=", "metadataCacheFiles", ".", "remove", "(", "slot", ")", ";", "if", "(", "oldCache", "!=", "null", ")", "{", "try", "{", "oldCache", ".", "close", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "logger", ".", "error", "(", "\"Problem closing metadata cache\"", ",", "e", ")", ";", "}", "deliverCacheUpdate", "(", "slot", ",", "null", ")", ";", "}", "}" ]

[ "Removes", "any", "metadata", "cache", "file", "that", "might", "have", "been", "assigned", "to", "a", "particular", "player", "media", "slot", "so", "metadata", "will", "be", "looked", "up", "from", "the", "player", "itself", "." ]

[ "public", "List", "<", "File", ">", "getAutoAttachCacheFiles", "(", ")", "{", "ArrayList", "<", "File", ">", "currentFiles", "=", "new", "ArrayList", "<", "File", ">", "(", "autoAttachCacheFiles", ")", ";", "Collections", ".", "sort", "(", "currentFiles", ",", "new", "Comparator", "<", "File", ">", "(", ")", "{", "@", "Override", "public", "int", "compare", "(", "File", "o1", ",", "File", "o2", ")", "{", "return", "o1", ".", "getName", "(", ")", ".", "compareTo", "(", "o2", ".", "getName", "(", ")", ")", ";", "}", "}", ")", ";", "return", "Collections", ".", "unmodifiableList", "(", "currentFiles", ")", ";", "}" ]

[ "Get", "the", "metadata", "cache", "files", "that", "are", "currently", "configured", "to", "be", "automatically", "attached", "when", "matching", "media", "is", "mounted", "in", "a", "player", "on", "the", "network", "." ]

[ "private", "void", "flushHotCacheSlot", "(", "SlotReference", "slot", ")", "{", "// Iterate over a copy to avoid concurrent modification issues", "for", "(", "Map", ".", "Entry", "<", "DeckReference", ",", "TrackMetadata", ">", "entry", ":", "new", "HashMap", "<", "DeckReference", ",", "TrackMetadata", ">", "(", "hotCache", ")", ".", "entrySet", "(", ")", ")", "{", "if", "(", "slot", "==", "SlotReference", ".", "getSlotReference", "(", "entry", ".", "getValue", "(", ")", ".", "trackReference", ")", ")", "{", "logger", ".", "debug", "(", "\"Evicting cached metadata in response to unmount report {}\"", ",", "entry", ".", "getValue", "(", ")", ")", ";", "hotCache", ".", "remove", "(", "entry", ".", "getKey", "(", ")", ")", ";", "}", "}", "}" ]

[ "Discards", "any", "tracks", "from", "the", "hot", "cache", "that", "were", "loaded", "from", "a", "now", "-", "unmounted", "media", "slot", "because", "they", "are", "no", "longer", "valid", "." ]

[ "private", "void", "recordMount", "(", "SlotReference", "slot", ")", "{", "if", "(", "mediaMounts", ".", "add", "(", "slot", ")", ")", "{", "deliverMountUpdate", "(", "slot", ",", "true", ")", ";", "}", "if", "(", "!", "mediaDetails", ".", "containsKey", "(", "slot", ")", ")", "{", "try", "{", "VirtualCdj", ".", "getInstance", "(", ")", ".", "sendMediaQuery", "(", "slot", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "logger", ".", "warn", "(", "\"Problem trying to request media details for \"", "+", "slot", ",", "e", ")", ";", "}", "}", "}" ]

[ "Records", "that", "there", "is", "media", "mounted", "in", "a", "particular", "media", "player", "slot", "updating", "listeners", "if", "this", "is", "a", "change", ".", "Also", "send", "a", "query", "to", "the", "player", "requesting", "details", "about", "the", "media", "mounted", "in", "that", "slot", "if", "we", "don", "t", "already", "have", "that", "information", "." ]

[ "private", "void", "removeMount", "(", "SlotReference", "slot", ")", "{", "mediaDetails", ".", "remove", "(", "slot", ")", ";", "if", "(", "mediaMounts", ".", "remove", "(", "slot", ")", ")", "{", "deliverMountUpdate", "(", "slot", ",", "false", ")", ";", "}", "}" ]

[ "Records", "that", "there", "is", "no", "media", "mounted", "in", "a", "particular", "media", "player", "slot", "updating", "listeners", "if", "this", "is", "a", "change", "and", "clearing", "any", "affected", "items", "from", "our", "in", "-", "memory", "caches", "." ]

[ "private", "void", "deliverMountUpdate", "(", "SlotReference", "slot", ",", "boolean", "mounted", ")", "{", "if", "(", "mounted", ")", "{", "logger", ".", "info", "(", "\"Reporting media mounted in \"", "+", "slot", ")", ";", "}", "else", "{", "logger", ".", "info", "(", "\"Reporting media removed from \"", "+", "slot", ")", ";", "}", "for", "(", "final", "MountListener", "listener", ":", "getMountListeners", "(", ")", ")", "{", "try", "{", "if", "(", "mounted", ")", "{", "listener", ".", "mediaMounted", "(", "slot", ")", ";", "}", "else", "{", "listener", ".", "mediaUnmounted", "(", "slot", ")", ";", "}", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Problem delivering mount update to listener\"", ",", "t", ")", ";", "}", "}", "if", "(", "mounted", ")", "{", "MetadataCache", ".", "tryAutoAttaching", "(", "slot", ")", ";", "}", "}" ]

[ "Send", "a", "mount", "update", "announcement", "to", "all", "registered", "listeners", "and", "see", "if", "we", "can", "auto", "-", "attach", "a", "media", "cache", "file", "." ]

[ "private", "void", "deliverCacheUpdate", "(", "SlotReference", "slot", ",", "MetadataCache", "cache", ")", "{", "for", "(", "final", "MetadataCacheListener", "listener", ":", "getCacheListeners", "(", ")", ")", "{", "try", "{", "if", "(", "cache", "==", "null", ")", "{", "listener", ".", "cacheDetached", "(", "slot", ")", ";", "}", "else", "{", "listener", ".", "cacheAttached", "(", "slot", ",", "cache", ")", ";", "}", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Problem delivering metadata cache update to listener\"", ",", "t", ")", ";", "}", "}", "}" ]

[ "Send", "a", "metadata", "cache", "update", "announcement", "to", "all", "registered", "listeners", "." ]

[ "private", "void", "deliverTrackMetadataUpdate", "(", "int", "player", ",", "TrackMetadata", "metadata", ")", "{", "if", "(", "!", "getTrackMetadataListeners", "(", ")", ".", "isEmpty", "(", ")", ")", "{", "final", "TrackMetadataUpdate", "update", "=", "new", "TrackMetadataUpdate", "(", "player", ",", "metadata", ")", ";", "for", "(", "final", "TrackMetadataListener", "listener", ":", "getTrackMetadataListeners", "(", ")", ")", "{", "try", "{", "listener", ".", "metadataChanged", "(", "update", ")", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Problem delivering track metadata update to listener\"", ",", "t", ")", ";", "}", "}", "}", "}" ]

[ "Send", "a", "track", "metadata", "update", "announcement", "to", "all", "registered", "listeners", "." ]

[ "private", "void", "addMetadataProviderForMedia", "(", "String", "key", ",", "MetadataProvider", "provider", ")", "{", "if", "(", "!", "metadataProviders", ".", "containsKey", "(", "key", ")", ")", "{", "metadataProviders", ".", "put", "(", "key", ",", "Collections", ".", "newSetFromMap", "(", "new", "ConcurrentHashMap", "<", "MetadataProvider", ",", "Boolean", ">", "(", ")", ")", ")", ";", "}", "Set", "<", "MetadataProvider", ">", "providers", "=", "metadataProviders", ".", "get", "(", "key", ")", ";", "providers", ".", "add", "(", "provider", ")", ";", "}" ]

[ "Internal", "method", "that", "adds", "a", "metadata", "provider", "to", "the", "set", "associated", "with", "a", "particular", "hash", "key", "creating", "the", "set", "if", "needed", "." ]

[ "public", "void", "removeMetadataProvider", "(", "MetadataProvider", "provider", ")", "{", "for", "(", "Set", "<", "MetadataProvider", ">", "providers", ":", "metadataProviders", ".", "values", "(", ")", ")", "{", "providers", ".", "remove", "(", "provider", ")", ";", "}", "}" ]

[ "Removes", "a", "metadata", "provider", "so", "it", "will", "no", "longer", "be", "consulted", "to", "provide", "metadata", "for", "tracks", "loaded", "from", "any", "media", "." ]

[ "public", "Set", "<", "MetadataProvider", ">", "getMetadataProviders", "(", "MediaDetails", "sourceMedia", ")", "{", "String", "key", "=", "(", "sourceMedia", "==", "null", ")", "?", "\"\"", ":", "sourceMedia", ".", "hashKey", "(", ")", ";", "Set", "<", "MetadataProvider", ">", "result", "=", "metadataProviders", ".", "get", "(", "key", ")", ";", "if", "(", "result", "==", "null", ")", "{", "return", "Collections", ".", "emptySet", "(", ")", ";", "}", "return", "Collections", ".", "unmodifiableSet", "(", "new", "HashSet", "<", "MetadataProvider", ">", "(", "result", ")", ")", ";", "}" ]

[ "Get", "the", "set", "of", "metadata", "providers", "that", "can", "offer", "metadata", "for", "tracks", "loaded", "from", "the", "specified", "media", "." ]

[ "private", "void", "handleUpdate", "(", "final", "CdjStatus", "update", ")", "{", "// First see if any metadata caches need evicting or mount sets need updating.", "if", "(", "update", ".", "isLocalUsbEmpty", "(", ")", ")", "{", "final", "SlotReference", "slot", "=", "SlotReference", ".", "getSlotReference", "(", "update", ".", "getDeviceNumber", "(", ")", ",", "CdjStatus", ".", "TrackSourceSlot", ".", "USB_SLOT", ")", ";", "detachMetadataCache", "(", "slot", ")", ";", "flushHotCacheSlot", "(", "slot", ")", ";", "removeMount", "(", "slot", ")", ";", "}", "else", "if", "(", "update", ".", "isLocalUsbLoaded", "(", ")", ")", "{", "recordMount", "(", "SlotReference", ".", "getSlotReference", "(", "update", ".", "getDeviceNumber", "(", ")", ",", "CdjStatus", ".", "TrackSourceSlot", ".", "USB_SLOT", ")", ")", ";", "}", "if", "(", "update", ".", "isLocalSdEmpty", "(", ")", ")", "{", "final", "SlotReference", "slot", "=", "SlotReference", ".", "getSlotReference", "(", "update", ".", "getDeviceNumber", "(", ")", ",", "CdjStatus", ".", "TrackSourceSlot", ".", "SD_SLOT", ")", ";", "detachMetadataCache", "(", "slot", ")", ";", "flushHotCacheSlot", "(", "slot", ")", ";", "removeMount", "(", "slot", ")", ";", "}", "else", "if", "(", "update", ".", "isLocalSdLoaded", "(", ")", ")", "{", "recordMount", "(", "SlotReference", ".", "getSlotReference", "(", "update", ".", "getDeviceNumber", "(", ")", ",", "CdjStatus", ".", "TrackSourceSlot", ".", "SD_SLOT", ")", ")", ";", "}", "if", "(", "update", ".", "isDiscSlotEmpty", "(", ")", ")", "{", "removeMount", "(", "SlotReference", ".", "getSlotReference", "(", "update", ".", "getDeviceNumber", "(", ")", ",", "CdjStatus", ".", "TrackSourceSlot", ".", "CD_SLOT", ")", ")", ";", "}", "else", "{", "recordMount", "(", "SlotReference", ".", "getSlotReference", "(", "update", ".", "getDeviceNumber", "(", ")", ",", "CdjStatus", ".", "TrackSourceSlot", ".", "CD_SLOT", ")", ")", ";", "}", "// Now see if a track has changed that needs new metadata.", "if", "(", "update", ".", "getTrackType", "(", ")", "==", "CdjStatus", ".", "TrackType", ".", "UNKNOWN", "||", "update", ".", "getTrackType", "(", ")", "==", "CdjStatus", ".", "TrackType", ".", "NO_TRACK", "||", "update", ".", "getTrackSourceSlot", "(", ")", "==", "CdjStatus", ".", "TrackSourceSlot", ".", "NO_TRACK", "||", "update", ".", "getTrackSourceSlot", "(", ")", "==", "CdjStatus", ".", "TrackSourceSlot", ".", "UNKNOWN", "||", "update", ".", "getRekordboxId", "(", ")", "==", "0", ")", "{", "// We no longer have metadata for this device.", "clearDeck", "(", "update", ")", ";", "}", "else", "{", "// We can offer metadata for this device; check if we already looked up this track.", "final", "TrackMetadata", "lastMetadata", "=", "hotCache", ".", "get", "(", "DeckReference", ".", "getDeckReference", "(", "update", ".", "getDeviceNumber", "(", ")", ",", "0", ")", ")", ";", "final", "DataReference", "trackReference", "=", "new", "DataReference", "(", "update", ".", "getTrackSourcePlayer", "(", ")", ",", "update", ".", "getTrackSourceSlot", "(", ")", ",", "update", ".", "getRekordboxId", "(", ")", ")", ";", "if", "(", "lastMetadata", "==", "null", "||", "!", "lastMetadata", ".", "trackReference", ".", "equals", "(", "trackReference", ")", ")", "{", "// We have something new!", "// First see if we can find the new track in the hot cache as a hot cue", "for", "(", "TrackMetadata", "cached", ":", "hotCache", ".", "values", "(", ")", ")", "{", "if", "(", "cached", ".", "trackReference", ".", "equals", "(", "trackReference", ")", ")", "{", "// Found a hot cue hit, use it.", "updateMetadata", "(", "update", ",", "cached", ")", ";", "return", ";", "}", "}", "// Not in the hot cache so try actually retrieving it.", "if", "(", "activeRequests", ".", "add", "(", "update", ".", "getTrackSourcePlayer", "(", ")", ")", ")", "{", "// We had to make sure we were not already asking for this track.", "clearDeck", "(", "update", ")", ";", "// We won't know what it is until our request completes.", "new", "Thread", "(", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "try", "{", "TrackMetadata", "data", "=", "requestMetadataInternal", "(", "trackReference", ",", "update", ".", "getTrackType", "(", ")", ",", "true", ")", ";", "if", "(", "data", "!=", "null", ")", "{", "updateMetadata", "(", "update", ",", "data", ")", ";", "}", "}", "catch", "(", "Exception", "e", ")", "{", "logger", ".", "warn", "(", "\"Problem requesting track metadata from update\"", "+", "update", ",", "e", ")", ";", "}", "finally", "{", "activeRequests", ".", "remove", "(", "update", ".", "getTrackSourcePlayer", "(", ")", ")", ";", "}", "}", "}", ",", "\"MetadataFinder metadata request\"", ")", ".", "start", "(", ")", ";", "}", "}", "}", "}" ]

[ "Process", "an", "update", "packet", "from", "one", "of", "the", "CDJs", ".", "See", "if", "it", "has", "a", "valid", "track", "loaded", ";", "if", "not", "clear", "any", "metadata", "we", "had", "stored", "for", "that", "player", ".", "If", "so", "see", "if", "it", "is", "the", "same", "track", "we", "already", "know", "about", ";", "if", "not", "request", "the", "metadata", "associated", "with", "that", "track", "." ]

[ "private", "int", "getColorWaveformBits", "(", "final", "ByteBuffer", "waveBytes", ",", "final", "int", "segment", ")", "{", "final", "int", "base", "=", "(", "segment", "*", "2", ")", ";", "final", "int", "big", "=", "Util", ".", "unsign", "(", "waveBytes", ".", "get", "(", "base", ")", ")", ";", "final", "int", "small", "=", "Util", ".", "unsign", "(", "waveBytes", ".", "get", "(", "base", "+", "1", ")", ")", ";", "return", "big", "*", "256", "+", "small", ";", "}" ]

[ "Color", "waveforms", "are", "represented", "by", "a", "series", "of", "sixteen", "bit", "integers", "into", "which", "color", "and", "height", "information", "are", "packed", ".", "This", "function", "returns", "the", "integer", "corresponding", "to", "a", "particular", "half", "-", "frame", "in", "the", "waveform", "." ]

[ "private", "static", "void", "addCacheFormatEntry", "(", "List", "<", "Message", ">", "trackListEntries", ",", "int", "playlistId", ",", "ZipOutputStream", "zos", ")", "throws", "IOException", "{", "// Add a marker so we can recognize this as a metadata archive. I would use the ZipFile comment, but", "// that is not available until Java 7, and Beat Link is supposed to be backwards compatible with Java 6.", "// Since we are doing this anyway, we can also provide information about the nature of the cache, and", "// how many metadata entries it contains, which is useful for auto-attachment.", "zos", ".", "putNextEntry", "(", "new", "ZipEntry", "(", "CACHE_FORMAT_ENTRY", ")", ")", ";", "String", "formatEntry", "=", "CACHE_FORMAT_IDENTIFIER", "+", "\":\"", "+", "playlistId", "+", "\":\"", "+", "trackListEntries", ".", "size", "(", ")", ";", "zos", ".", "write", "(", "formatEntry", ".", "getBytes", "(", "\"UTF-8\"", ")", ")", ";", "}" ]

[ "Add", "a", "marker", "so", "we", "can", "recognize", "this", "as", "a", "metadata", "archive", ".", "I", "would", "use", "the", "ZipFile", "comment", "but", "that", "is", "not", "available", "until", "Java", "7", "and", "Beat", "Link", "is", "supposed", "to", "be", "backwards", "compatible", "with", "Java", "6", ".", "Since", "we", "are", "doing", "this", "anyway", "we", "can", "also", "provide", "information", "about", "the", "nature", "of", "the", "cache", "and", "how", "many", "metadata", "entries", "it", "contains", "which", "is", "useful", "for", "auto", "-", "attachment", "." ]

[ "private", "static", "void", "addCacheDetailsEntry", "(", "SlotReference", "slot", ",", "ZipOutputStream", "zos", ",", "WritableByteChannel", "channel", ")", "throws", "IOException", "{", "// Record the details of the media being cached, to make it easier to recognize now that we can.", "MediaDetails", "details", "=", "MetadataFinder", ".", "getInstance", "(", ")", ".", "getMediaDetailsFor", "(", "slot", ")", ";", "if", "(", "details", "!=", "null", ")", "{", "zos", ".", "putNextEntry", "(", "new", "ZipEntry", "(", "CACHE_DETAILS_ENTRY", ")", ")", ";", "Util", ".", "writeFully", "(", "details", ".", "getRawBytes", "(", ")", ",", "channel", ")", ";", "}", "}" ]

[ "Record", "the", "details", "of", "the", "media", "being", "cached", "to", "make", "it", "easier", "to", "recognize", "now", "that", "we", "have", "access", "to", "that", "information", "." ]

[ "private", "String", "getCacheFormatEntry", "(", ")", "throws", "IOException", "{", "ZipEntry", "zipEntry", "=", "zipFile", ".", "getEntry", "(", "CACHE_FORMAT_ENTRY", ")", ";", "InputStream", "is", "=", "zipFile", ".", "getInputStream", "(", "zipEntry", ")", ";", "try", "{", "Scanner", "s", "=", "new", "Scanner", "(", "is", ",", "\"UTF-8\"", ")", ".", "useDelimiter", "(", "\"\\\\A\"", ")", ";", "String", "tag", "=", "null", ";", "if", "(", "s", ".", "hasNext", "(", ")", ")", "tag", "=", "s", ".", "next", "(", ")", ";", "return", "tag", ";", "}", "finally", "{", "is", ".", "close", "(", ")", ";", "}", "}" ]

[ "Find", "and", "read", "the", "cache", "format", "entry", "in", "a", "metadata", "cache", "file", "." ]

[ "public", "List", "<", "Integer", ">", "getTrackIds", "(", ")", "{", "ArrayList", "<", "Integer", ">", "results", "=", "new", "ArrayList", "<", "Integer", ">", "(", "trackCount", ")", ";", "Enumeration", "<", "?", "extends", "ZipEntry", ">", "entries", "=", "zipFile", ".", "entries", "(", ")", ";", "while", "(", "entries", ".", "hasMoreElements", "(", ")", ")", "{", "ZipEntry", "entry", "=", "entries", ".", "nextElement", "(", ")", ";", "if", "(", "entry", ".", "getName", "(", ")", ".", "startsWith", "(", "CACHE_METADATA_ENTRY_PREFIX", ")", ")", "{", "String", "idPart", "=", "entry", ".", "getName", "(", ")", ".", "substring", "(", "CACHE_METADATA_ENTRY_PREFIX", ".", "length", "(", ")", ")", ";", "if", "(", "idPart", ".", "length", "(", ")", ">", "0", ")", "{", "results", ".", "add", "(", "Integer", ".", "valueOf", "(", "idPart", ")", ")", ";", "}", "}", "}", "return", "Collections", ".", "unmodifiableList", "(", "results", ")", ";", "}" ]

[ "Returns", "a", "list", "of", "the", "rekordbox", "IDs", "of", "the", "tracks", "contained", "in", "the", "cache", "." ]

[ "public", "static", "void", "createMetadataCache", "(", "SlotReference", "slot", ",", "int", "playlistId", ",", "File", "cache", ")", "throws", "Exception", "{", "createMetadataCache", "(", "slot", ",", "playlistId", ",", "cache", ",", "null", ")", ";", "}" ]

[ "Creates", "a", "metadata", "cache", "archive", "file", "of", "all", "tracks", "in", "the", "specified", "slot", "on", "the", "specified", "player", ".", "Any", "previous", "contents", "of", "the", "specified", "file", "will", "be", "replaced", "." ]

[ "static", "void", "tryAutoAttaching", "(", "final", "SlotReference", "slot", ")", "{", "if", "(", "!", "MetadataFinder", ".", "getInstance", "(", ")", ".", "getMountedMediaSlots", "(", ")", ".", "contains", "(", "slot", ")", ")", "{", "logger", ".", "error", "(", "\"Unable to auto-attach cache to empty slot {}\"", ",", "slot", ")", ";", "return", ";", "}", "if", "(", "MetadataFinder", ".", "getInstance", "(", ")", ".", "getMetadataCache", "(", "slot", ")", "!=", "null", ")", "{", "logger", ".", "info", "(", "\"Not auto-attaching to slot {}; already has a cache attached.\"", ",", "slot", ")", ";", "return", ";", "}", "if", "(", "MetadataFinder", ".", "getInstance", "(", ")", ".", "getAutoAttachCacheFiles", "(", ")", ".", "isEmpty", "(", ")", ")", "{", "logger", ".", "debug", "(", "\"No auto-attach files configured.\"", ")", ";", "return", ";", "}", "new", "Thread", "(", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "try", "{", "Thread", ".", "sleep", "(", "5", ")", ";", "// Give us a chance to find out what type of media is in the new mount.", "final", "MediaDetails", "details", "=", "MetadataFinder", ".", "getInstance", "(", ")", ".", "getMediaDetailsFor", "(", "slot", ")", ";", "if", "(", "details", "!=", "null", "&&", "details", ".", "mediaType", "==", "CdjStatus", ".", "TrackType", ".", "REKORDBOX", ")", "{", "// First stage attempt: See if we can match based on stored media details, which is both more reliable and", "// less disruptive than trying to sample the player database to compare entries.", "boolean", "attached", "=", "false", ";", "for", "(", "File", "file", ":", "MetadataFinder", ".", "getInstance", "(", ")", ".", "getAutoAttachCacheFiles", "(", ")", ")", "{", "final", "MetadataCache", "cache", "=", "new", "MetadataCache", "(", "file", ")", ";", "try", "{", "if", "(", "cache", ".", "sourceMedia", "!=", "null", "&&", "cache", ".", "sourceMedia", ".", "hashKey", "(", ")", ".", "equals", "(", "details", ".", "hashKey", "(", ")", ")", ")", "{", "// We found a solid match, no need to probe tracks.", "final", "boolean", "changed", "=", "cache", ".", "sourceMedia", ".", "hasChanged", "(", "details", ")", ";", "logger", ".", "info", "(", "\"Auto-attaching metadata cache \"", "+", "cache", ".", "getName", "(", ")", "+", "\" to slot \"", "+", "slot", "+", "\" based on media details \"", "+", "(", "changed", "?", "\"(changed since created)!\"", ":", "\"(unchanged).\"", ")", ")", ";", "MetadataFinder", ".", "getInstance", "(", ")", ".", "attachMetadataCacheInternal", "(", "slot", ",", "cache", ")", ";", "attached", "=", "true", ";", "return", ";", "}", "}", "finally", "{", "if", "(", "!", "attached", ")", "{", "cache", ".", "close", "(", ")", ";", "}", "}", "}", "// Could not match based on media details; fall back to older method based on probing track metadata.", "ConnectionManager", ".", "ClientTask", "<", "Object", ">", "task", "=", "new", "ConnectionManager", ".", "ClientTask", "<", "Object", ">", "(", ")", "{", "@", "Override", "public", "Object", "useClient", "(", "Client", "client", ")", "throws", "Exception", "{", "tryAutoAttachingWithConnection", "(", "slot", ",", "client", ")", ";", "return", "null", ";", "}", "}", ";", "ConnectionManager", ".", "getInstance", "(", ")", ".", "invokeWithClientSession", "(", "slot", ".", "player", ",", "task", ",", "\"trying to auto-attach metadata cache\"", ")", ";", "}", "}", "catch", "(", "Exception", "e", ")", "{", "logger", ".", "error", "(", "\"Problem trying to auto-attach metadata cache for slot \"", "+", "slot", ",", "e", ")", ";", "}", "}", "}", ",", "\"Metadata cache file auto-attachment attempt\"", ")", ".", "start", "(", ")", ";", "}" ]

[ "See", "if", "there", "is", "an", "auto", "-", "attach", "cache", "file", "that", "seems", "to", "match", "the", "media", "in", "the", "specified", "slot", "and", "if", "so", "attach", "it", "." ]

[ "private", "static", "Map", "<", "Integer", ",", "LinkedList", "<", "MetadataCache", ">", ">", "gatherCandidateAttachmentGroups", "(", ")", "{", "Map", "<", "Integer", ",", "LinkedList", "<", "MetadataCache", ">", ">", "candidateGroups", "=", "new", "TreeMap", "<", "Integer", ",", "LinkedList", "<", "MetadataCache", ">", ">", "(", ")", ";", "final", "Iterator", "<", "File", ">", "iterator", "=", "MetadataFinder", ".", "getInstance", "(", ")", ".", "getAutoAttachCacheFiles", "(", ")", ".", "iterator", "(", ")", ";", "while", "(", "iterator", ".", "hasNext", "(", ")", ")", "{", "final", "File", "file", "=", "iterator", ".", "next", "(", ")", ";", "try", "{", "final", "MetadataCache", "candidate", "=", "new", "MetadataCache", "(", "file", ")", ";", "if", "(", "candidateGroups", ".", "get", "(", "candidate", ".", "sourcePlaylist", ")", "==", "null", ")", "{", "candidateGroups", ".", "put", "(", "candidate", ".", "sourcePlaylist", ",", "new", "LinkedList", "<", "MetadataCache", ">", "(", ")", ")", ";", "}", "candidateGroups", ".", "get", "(", "candidate", ".", "sourcePlaylist", ")", ".", "add", "(", "candidate", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "logger", ".", "error", "(", "\"Unable to open metadata cache file \"", "+", "file", "+", "\", discarding\"", ",", "e", ")", ";", "iterator", ".", "remove", "(", ")", ";", "}", "}", "return", "candidateGroups", ";", "}" ]

[ "Groups", "all", "of", "the", "metadata", "cache", "files", "that", "are", "candidates", "for", "auto", "-", "attachment", "to", "player", "slots", "into", "lists", "that", "are", "keyed", "by", "the", "playlist", "ID", "used", "to", "create", "the", "cache", "file", ".", "Files", "that", "cache", "all", "tracks", "have", "a", "playlist", "ID", "of", "0", "." ]