Datasets:

---

CM

/

codexglue_code2text_java

like 4

[ "public", "boolean", "endsWith", "(", "Bytes", "suffix", ")", "{", "Objects", ".", "requireNonNull", "(", "suffix", ",", "\"endsWith(Bytes suffix) cannot have null parameter\"", ")", ";", "int", "startOffset", "=", "this", ".", "length", "-", "suffix", ".", "length", ";", "if", "(", "startOffset", "<", "0", ")", "{", "return", "false", ";", "}", "else", "{", "int", "end", "=", "startOffset", "+", "this", ".", "offset", "+", "suffix", ".", "length", ";", "for", "(", "int", "i", "=", "startOffset", "+", "this", ".", "offset", ",", "j", "=", "suffix", ".", "offset", ";", "i", "<", "end", ";", "i", "++", ",", "j", "++", ")", "{", "if", "(", "this", ".", "data", "[", "i", "]", "!=", "suffix", ".", "data", "[", "j", "]", ")", "{", "return", "false", ";", "}", "}", "}", "return", "true", ";", "}" ]

[ "Checks", "if", "this", "has", "the", "passed", "suffix" ]

[ "public", "void", "copyTo", "(", "int", "start", ",", "int", "end", ",", "byte", "[", "]", "dest", ",", "int", "destPos", ")", "{", "// this.subSequence(start, end).copyTo(dest, destPos) would allocate another Bytes object", "arraycopy", "(", "start", ",", "dest", ",", "destPos", ",", "end", "-", "start", ")", ";", "}" ]

[ "Copy", "a", "subsequence", "of", "Bytes", "to", "specific", "byte", "array", ".", "Uses", "the", "specified", "offset", "in", "the", "dest", "byte", "array", "to", "start", "the", "copy", "." ]

[ "public", "void", "copyTo", "(", "ColumnBuffer", "dest", ",", "LongPredicate", "timestampTest", ")", "{", "dest", ".", "clear", "(", ")", ";", "if", "(", "key", "!=", "null", ")", "{", "dest", ".", "key", "=", "new", "Key", "(", "key", ")", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "timeStamps", ".", "size", "(", ")", ";", "i", "++", ")", "{", "long", "time", "=", "timeStamps", ".", "get", "(", "i", ")", ";", "if", "(", "timestampTest", ".", "test", "(", "time", ")", ")", "{", "dest", ".", "add", "(", "time", ",", "values", ".", "get", "(", "i", ")", ")", ";", "}", "}", "}" ]

[ "Clears", "the", "dest", "ColumnBuffer", "and", "inserts", "all", "entries", "in", "dest", "where", "the", "timestamp", "passes", "the", "timestampTest", "." ]

[ "public", "static", "AccumuloClient", "getClient", "(", "FluoConfiguration", "config", ")", "{", "return", "Accumulo", ".", "newClient", "(", ")", ".", "to", "(", "config", ".", "getAccumuloInstance", "(", ")", ",", "config", ".", "getAccumuloZookeepers", "(", ")", ")", ".", "as", "(", "config", ".", "getAccumuloUser", "(", ")", ",", "config", ".", "getAccumuloPassword", "(", ")", ")", ".", "build", "(", ")", ";", "}" ]

[ "Creates", "Accumulo", "connector", "given", "FluoConfiguration" ]

[ "public", "static", "byte", "[", "]", "encode", "(", "byte", "[", "]", "ba", ",", "int", "offset", ",", "long", "v", ")", "{", "ba", "[", "offset", "+", "0", "]", "=", "(", "byte", ")", "(", "v", ">>>", "56", ")", ";", "ba", "[", "offset", "+", "1", "]", "=", "(", "byte", ")", "(", "v", ">>>", "48", ")", ";", "ba", "[", "offset", "+", "2", "]", "=", "(", "byte", ")", "(", "v", ">>>", "40", ")", ";", "ba", "[", "offset", "+", "3", "]", "=", "(", "byte", ")", "(", "v", ">>>", "32", ")", ";", "ba", "[", "offset", "+", "4", "]", "=", "(", "byte", ")", "(", "v", ">>>", "24", ")", ";", "ba", "[", "offset", "+", "5", "]", "=", "(", "byte", ")", "(", "v", ">>>", "16", ")", ";", "ba", "[", "offset", "+", "6", "]", "=", "(", "byte", ")", "(", "v", ">>>", "8", ")", ";", "ba", "[", "offset", "+", "7", "]", "=", "(", "byte", ")", "(", "v", ">>>", "0", ")", ";", "return", "ba", ";", "}" ]

[ "Encode", "a", "long", "into", "a", "byte", "array", "at", "an", "offset" ]

[ "public", "static", "long", "decodeLong", "(", "byte", "[", "]", "ba", ",", "int", "offset", ")", "{", "return", "(", "(", "(", "(", "long", ")", "ba", "[", "offset", "+", "0", "]", "<<", "56", ")", "+", "(", "(", "long", ")", "(", "ba", "[", "offset", "+", "1", "]", "&", "255", ")", "<<", "48", ")", "+", "(", "(", "long", ")", "(", "ba", "[", "offset", "+", "2", "]", "&", "255", ")", "<<", "40", ")", "+", "(", "(", "long", ")", "(", "ba", "[", "offset", "+", "3", "]", "&", "255", ")", "<<", "32", ")", "+", "(", "(", "long", ")", "(", "ba", "[", "offset", "+", "4", "]", "&", "255", ")", "<<", "24", ")", "+", "(", "(", "ba", "[", "offset", "+", "5", "]", "&", "255", ")", "<<", "16", ")", "+", "(", "(", "ba", "[", "offset", "+", "6", "]", "&", "255", ")", "<<", "8", ")", "+", "(", "(", "ba", "[", "offset", "+", "7", "]", "&", "255", ")", "<<", "0", ")", ")", ")", ";", "}" ]

[ "Decode", "long", "from", "byte", "array", "at", "offset" ]

[ "public", "static", "byte", "[", "]", "concat", "(", "Bytes", "...", "listOfBytes", ")", "{", "int", "offset", "=", "0", ";", "int", "size", "=", "0", ";", "for", "(", "Bytes", "b", ":", "listOfBytes", ")", "{", "size", "+=", "b", ".", "length", "(", ")", "+", "checkVlen", "(", "b", ".", "length", "(", ")", ")", ";", "}", "byte", "[", "]", "data", "=", "new", "byte", "[", "size", "]", ";", "for", "(", "Bytes", "b", ":", "listOfBytes", ")", "{", "offset", "=", "writeVint", "(", "data", ",", "offset", ",", "b", ".", "length", "(", ")", ")", ";", "b", ".", "copyTo", "(", "0", ",", "b", ".", "length", "(", ")", ",", "data", ",", "offset", ")", ";", "offset", "+=", "b", ".", "length", "(", ")", ";", "}", "return", "data", ";", "}" ]

[ "Concatenates", "of", "list", "of", "Bytes", "objects", "to", "create", "a", "byte", "array" ]

[ "public", "static", "int", "writeVint", "(", "byte", "[", "]", "dest", ",", "int", "offset", ",", "int", "i", ")", "{", "if", "(", "i", ">=", "-", "112", "&&", "i", "<=", "127", ")", "{", "dest", "[", "offset", "++", "]", "=", "(", "byte", ")", "i", ";", "}", "else", "{", "int", "len", "=", "-", "112", ";", "if", "(", "i", "<", "0", ")", "{", "i", "^=", "-", "1L", ";", "// take one's complement'", "len", "=", "-", "120", ";", "}", "long", "tmp", "=", "i", ";", "while", "(", "tmp", "!=", "0", ")", "{", "tmp", "=", "tmp", ">>", "8", ";", "len", "--", ";", "}", "dest", "[", "offset", "++", "]", "=", "(", "byte", ")", "len", ";", "len", "=", "(", "len", "<", "-", "120", ")", "?", "-", "(", "len", "+", "120", ")", ":", "-", "(", "len", "+", "112", ")", ";", "for", "(", "int", "idx", "=", "len", ";", "idx", "!=", "0", ";", "idx", "--", ")", "{", "int", "shiftbits", "=", "(", "idx", "-", "1", ")", "*", "8", ";", "long", "mask", "=", "0xFF", "L", "<<", "shiftbits", ";", "dest", "[", "offset", "++", "]", "=", "(", "byte", ")", "(", "(", "i", "&", "mask", ")", ">>", "shiftbits", ")", ";", "}", "}", "return", "offset", ";", "}" ]

[ "Writes", "a", "vInt", "directly", "to", "a", "byte", "array" ]

[ "public", "static", "int", "checkVlen", "(", "int", "i", ")", "{", "int", "count", "=", "0", ";", "if", "(", "i", ">=", "-", "112", "&&", "i", "<=", "127", ")", "{", "return", "1", ";", "}", "else", "{", "int", "len", "=", "-", "112", ";", "if", "(", "i", "<", "0", ")", "{", "i", "^=", "-", "1L", ";", "// take one's complement'", "len", "=", "-", "120", ";", "}", "long", "tmp", "=", "i", ";", "while", "(", "tmp", "!=", "0", ")", "{", "tmp", "=", "tmp", ">>", "8", ";", "len", "--", ";", "}", "count", "++", ";", "len", "=", "(", "len", "<", "-", "120", ")", "?", "-", "(", "len", "+", "120", ")", ":", "-", "(", "len", "+", "112", ")", ";", "while", "(", "len", "!=", "0", ")", "{", "count", "++", ";", "len", "--", ";", "}", "return", "count", ";", "}", "}" ]

[ "Determines", "the", "number", "bytes", "required", "to", "store", "a", "variable", "length" ]

[ "private", "ResourceReport", "getResourceReport", "(", "TwillController", "controller", ",", "int", "maxWaitMs", ")", "{", "ResourceReport", "report", "=", "controller", ".", "getResourceReport", "(", ")", ";", "int", "elapsed", "=", "0", ";", "while", "(", "report", "==", "null", ")", "{", "report", "=", "controller", ".", "getResourceReport", "(", ")", ";", "try", "{", "Thread", ".", "sleep", "(", "500", ")", ";", "}", "catch", "(", "InterruptedException", "e", ")", "{", "throw", "new", "IllegalStateException", "(", "e", ")", ";", "}", "elapsed", "+=", "500", ";", "if", "(", "(", "maxWaitMs", "!=", "-", "1", ")", "&&", "(", "elapsed", ">", "maxWaitMs", ")", ")", "{", "String", "msg", "=", "String", ".", "format", "(", "\"Exceeded max wait time to retrieve ResourceReport from Twill.\"", "+", "\" Elapsed time = %s ms\"", ",", "elapsed", ")", ";", "log", ".", "error", "(", "msg", ")", ";", "throw", "new", "IllegalStateException", "(", "msg", ")", ";", "}", "if", "(", "(", "elapsed", "%", "10000", ")", "==", "0", ")", "{", "log", ".", "info", "(", "\"Waiting for ResourceReport from Twill. Elapsed time = {} ms\"", ",", "elapsed", ")", ";", "}", "}", "return", "report", ";", "}" ]

[ "Attempts", "to", "retrieves", "ResourceReport", "until", "maxWaitMs", "time", "is", "reached", ".", "Set", "maxWaitMs", "to", "-", "1", "to", "retry", "forever", "." ]

[ "private", "void", "verifyApplicationName", "(", "String", "name", ")", "{", "if", "(", "name", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Application name cannot be null\"", ")", ";", "}", "if", "(", "name", ".", "isEmpty", "(", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Application name length must be > 0\"", ")", ";", "}", "String", "reason", "=", "null", ";", "char", "[", "]", "chars", "=", "name", ".", "toCharArray", "(", ")", ";", "char", "c", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "chars", ".", "length", ";", "i", "++", ")", "{", "c", "=", "chars", "[", "i", "]", ";", "if", "(", "c", "==", "0", ")", "{", "reason", "=", "\"null character not allowed @\"", "+", "i", ";", "break", ";", "}", "else", "if", "(", "c", "==", "'", "'", "||", "c", "==", "'", "'", "||", "c", "==", "'", "'", ")", "{", "reason", "=", "\"invalid character '\"", "+", "c", "+", "\"'\"", ";", "break", ";", "}", "else", "if", "(", "c", ">", "'", "'", "&&", "c", "<=", "'", "'", "||", "c", ">=", "'", "'", "&&", "c", "<=", "'", "'", "||", "c", ">=", "'", "'", "&&", "c", "<=", "'", "'", "||", "c", ">=", "'", "'", "&&", "c", "<=", "'", "'", ")", "{", "reason", "=", "\"invalid character @\"", "+", "i", ";", "break", ";", "}", "}", "if", "(", "reason", "!=", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Invalid application name \\\"\"", "+", "name", "+", "\"\\\" caused by \"", "+", "reason", ")", ";", "}", "}" ]

[ "Verifies", "application", "name", ".", "Avoids", "characters", "that", "Zookeeper", "does", "not", "like", "in", "nodes", "&", "Hadoop", "does", "not", "like", "in", "HDFS", "paths", "." ]

[ "@", "Deprecated", "public", "FluoConfiguration", "addObservers", "(", "Iterable", "<", "ObserverSpecification", ">", "observers", ")", "{", "int", "next", "=", "getNextObserverId", "(", ")", ";", "for", "(", "ObserverSpecification", "oconf", ":", "observers", ")", "{", "addObserver", "(", "oconf", ",", "next", "++", ")", ";", "}", "return", "this", ";", "}" ]

[ "Adds", "multiple", "observers", "using", "unique", "integer", "prefixes", "for", "each", "." ]

[ "@", "Deprecated", "public", "FluoConfiguration", "clearObservers", "(", ")", "{", "Iterator", "<", "String", ">", "iter1", "=", "getKeys", "(", "OBSERVER_PREFIX", ".", "substring", "(", "0", ",", "OBSERVER_PREFIX", ".", "length", "(", ")", "-", "1", ")", ")", ";", "while", "(", "iter1", ".", "hasNext", "(", ")", ")", "{", "String", "key", "=", "iter1", ".", "next", "(", ")", ";", "clearProperty", "(", "key", ")", ";", "}", "return", "this", ";", "}" ]

[ "Removes", "any", "configured", "observers", "." ]

[ "public", "void", "print", "(", ")", "{", "Iterator", "<", "String", ">", "iter", "=", "getKeys", "(", ")", ";", "while", "(", "iter", ".", "hasNext", "(", ")", ")", "{", "String", "key", "=", "iter", ".", "next", "(", ")", ";", "log", ".", "info", "(", "key", "+", "\" = \"", "+", "getRawString", "(", "key", ")", ")", ";", "}", "}" ]

[ "Logs", "all", "properties" ]

[ "public", "boolean", "hasRequiredClientProps", "(", ")", "{", "boolean", "valid", "=", "true", ";", "valid", "&=", "verifyStringPropSet", "(", "CONNECTION_APPLICATION_NAME_PROP", ",", "CLIENT_APPLICATION_NAME_PROP", ")", ";", "valid", "&=", "verifyStringPropSet", "(", "ACCUMULO_USER_PROP", ",", "CLIENT_ACCUMULO_USER_PROP", ")", ";", "valid", "&=", "verifyStringPropSet", "(", "ACCUMULO_PASSWORD_PROP", ",", "CLIENT_ACCUMULO_PASSWORD_PROP", ")", ";", "valid", "&=", "verifyStringPropSet", "(", "ACCUMULO_INSTANCE_PROP", ",", "CLIENT_ACCUMULO_INSTANCE_PROP", ")", ";", "return", "valid", ";", "}" ]

[ "Returns", "true", "if", "required", "properties", "for", "FluoClient", "are", "set" ]

[ "public", "boolean", "hasRequiredAdminProps", "(", ")", "{", "boolean", "valid", "=", "true", ";", "valid", "&=", "hasRequiredClientProps", "(", ")", ";", "valid", "&=", "verifyStringPropSet", "(", "ACCUMULO_TABLE_PROP", ",", "ADMIN_ACCUMULO_TABLE_PROP", ")", ";", "return", "valid", ";", "}" ]

[ "Returns", "true", "if", "required", "properties", "for", "FluoAdmin", "are", "set" ]

[ "public", "boolean", "hasRequiredMiniFluoProps", "(", ")", "{", "boolean", "valid", "=", "true", ";", "if", "(", "getMiniStartAccumulo", "(", ")", ")", "{", "// ensure that client properties are not set since we are using MiniAccumulo", "valid", "&=", "verifyStringPropNotSet", "(", "ACCUMULO_USER_PROP", ",", "CLIENT_ACCUMULO_USER_PROP", ")", ";", "valid", "&=", "verifyStringPropNotSet", "(", "ACCUMULO_PASSWORD_PROP", ",", "CLIENT_ACCUMULO_PASSWORD_PROP", ")", ";", "valid", "&=", "verifyStringPropNotSet", "(", "ACCUMULO_INSTANCE_PROP", ",", "CLIENT_ACCUMULO_INSTANCE_PROP", ")", ";", "valid", "&=", "verifyStringPropNotSet", "(", "ACCUMULO_ZOOKEEPERS_PROP", ",", "CLIENT_ACCUMULO_ZOOKEEPERS_PROP", ")", ";", "valid", "&=", "verifyStringPropNotSet", "(", "CONNECTION_ZOOKEEPERS_PROP", ",", "CLIENT_ZOOKEEPER_CONNECT_PROP", ")", ";", "if", "(", "valid", "==", "false", ")", "{", "log", ".", "error", "(", "\"Client properties should not be set in your configuration if MiniFluo is \"", "+", "\"configured to start its own accumulo (indicated by fluo.mini.start.accumulo being \"", "+", "\"set to true)\"", ")", ";", "}", "}", "else", "{", "valid", "&=", "hasRequiredClientProps", "(", ")", ";", "valid", "&=", "hasRequiredAdminProps", "(", ")", ";", "valid", "&=", "hasRequiredOracleProps", "(", ")", ";", "valid", "&=", "hasRequiredWorkerProps", "(", ")", ";", "}", "return", "valid", ";", "}" ]

[ "Returns", "true", "if", "required", "properties", "for", "MiniFluo", "are", "set" ]

[ "public", "SimpleConfiguration", "getClientConfiguration", "(", ")", "{", "SimpleConfiguration", "clientConfig", "=", "new", "SimpleConfiguration", "(", ")", ";", "Iterator", "<", "String", ">", "iter", "=", "getKeys", "(", ")", ";", "while", "(", "iter", ".", "hasNext", "(", ")", ")", "{", "String", "key", "=", "iter", ".", "next", "(", ")", ";", "if", "(", "key", ".", "startsWith", "(", "CONNECTION_PREFIX", ")", "||", "key", ".", "startsWith", "(", "ACCUMULO_PREFIX", ")", "||", "key", ".", "startsWith", "(", "CLIENT_PREFIX", ")", ")", "{", "clientConfig", ".", "setProperty", "(", "key", ",", "getRawString", "(", "key", ")", ")", ";", "}", "}", "return", "clientConfig", ";", "}" ]

[ "Returns", "a", "SimpleConfiguration", "clientConfig", "with", "properties", "set", "from", "this", "configuration" ]

[ "public", "static", "void", "setDefaultConfiguration", "(", "SimpleConfiguration", "config", ")", "{", "config", ".", "setProperty", "(", "CONNECTION_ZOOKEEPERS_PROP", ",", "CONNECTION_ZOOKEEPERS_DEFAULT", ")", ";", "config", ".", "setProperty", "(", "CONNECTION_ZOOKEEPER_TIMEOUT_PROP", ",", "CONNECTION_ZOOKEEPER_TIMEOUT_DEFAULT", ")", ";", "config", ".", "setProperty", "(", "DFS_ROOT_PROP", ",", "DFS_ROOT_DEFAULT", ")", ";", "config", ".", "setProperty", "(", "ACCUMULO_ZOOKEEPERS_PROP", ",", "ACCUMULO_ZOOKEEPERS_DEFAULT", ")", ";", "config", ".", "setProperty", "(", "WORKER_NUM_THREADS_PROP", ",", "WORKER_NUM_THREADS_DEFAULT", ")", ";", "config", ".", "setProperty", "(", "TRANSACTION_ROLLBACK_TIME_PROP", ",", "TRANSACTION_ROLLBACK_TIME_DEFAULT", ")", ";", "config", ".", "setProperty", "(", "LOADER_NUM_THREADS_PROP", ",", "LOADER_NUM_THREADS_DEFAULT", ")", ";", "config", ".", "setProperty", "(", "LOADER_QUEUE_SIZE_PROP", ",", "LOADER_QUEUE_SIZE_DEFAULT", ")", ";", "config", ".", "setProperty", "(", "MINI_START_ACCUMULO_PROP", ",", "MINI_START_ACCUMULO_DEFAULT", ")", ";", "config", ".", "setProperty", "(", "MINI_DATA_DIR_PROP", ",", "MINI_DATA_DIR_DEFAULT", ")", ";", "}" ]

[ "Sets", "all", "Fluo", "properties", "to", "their", "default", "in", "the", "given", "configuration", ".", "NOTE", "-", "some", "properties", "do", "not", "have", "defaults", "and", "will", "not", "be", "set", "." ]

[ "public", "static", "void", "configure", "(", "Job", "conf", ",", "SimpleConfiguration", "props", ")", "{", "try", "{", "ByteArrayOutputStream", "baos", "=", "new", "ByteArrayOutputStream", "(", ")", ";", "props", ".", "save", "(", "baos", ")", ";", "conf", ".", "getConfiguration", "(", ")", ".", "set", "(", "PROPS_CONF_KEY", ",", "new", "String", "(", "baos", ".", "toByteArray", "(", ")", ",", "StandardCharsets", ".", "UTF_8", ")", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "RuntimeException", "(", "e", ")", ";", "}", "}" ]

[ "Call", "this", "method", "to", "initialize", "the", "Fluo", "connection", "props" ]

[ "public", "Stamp", "allocateTimestamp", "(", ")", "{", "synchronized", "(", "this", ")", "{", "Preconditions", ".", "checkState", "(", "!", "closed", ",", "\"tracker closed \"", ")", ";", "if", "(", "node", "==", "null", ")", "{", "Preconditions", ".", "checkState", "(", "allocationsInProgress", "==", "0", ",", "\"expected allocationsInProgress == 0 when node == null\"", ")", ";", "Preconditions", ".", "checkState", "(", "!", "updatingZk", ",", "\"unexpected concurrent ZK update\"", ")", ";", "createZkNode", "(", "getTimestamp", "(", ")", ".", "getTxTimestamp", "(", ")", ")", ";", "}", "allocationsInProgress", "++", ";", "}", "try", "{", "Stamp", "ts", "=", "getTimestamp", "(", ")", ";", "synchronized", "(", "this", ")", "{", "timestamps", ".", "add", "(", "ts", ".", "getTxTimestamp", "(", ")", ")", ";", "}", "return", "ts", ";", "}", "catch", "(", "RuntimeException", "re", ")", "{", "synchronized", "(", "this", ")", "{", "allocationsInProgress", "--", ";", "}", "throw", "re", ";", "}", "}" ]

[ "Allocate", "a", "timestamp" ]

[ "private", "static", "boolean", "waitTillNoNotifications", "(", "Environment", "env", ",", "TableRange", "range", ")", "throws", "TableNotFoundException", "{", "boolean", "sawNotifications", "=", "false", ";", "long", "retryTime", "=", "MIN_SLEEP_MS", ";", "log", ".", "debug", "(", "\"Scanning tablet {} for notifications\"", ",", "range", ")", ";", "long", "start", "=", "System", ".", "currentTimeMillis", "(", ")", ";", "while", "(", "hasNotifications", "(", "env", ",", "range", ")", ")", "{", "sawNotifications", "=", "true", ";", "long", "sleepTime", "=", "Math", ".", "max", "(", "System", ".", "currentTimeMillis", "(", ")", "-", "start", ",", "retryTime", ")", ";", "log", ".", "debug", "(", "\"Tablet {} had notfications, will rescan in {}ms\"", ",", "range", ",", "sleepTime", ")", ";", "UtilWaitThread", ".", "sleep", "(", "sleepTime", ")", ";", "retryTime", "=", "Math", ".", "min", "(", "MAX_SLEEP_MS", ",", "(", "long", ")", "(", "retryTime", "*", "1.5", ")", ")", ";", "start", "=", "System", ".", "currentTimeMillis", "(", ")", ";", "}", "return", "sawNotifications", ";", "}" ]

[ "Wait", "until", "a", "range", "has", "no", "notifications", "." ]

[ "private", "static", "void", "waitUntilFinished", "(", "FluoConfiguration", "config", ")", "{", "try", "(", "Environment", "env", "=", "new", "Environment", "(", "config", ")", ")", "{", "List", "<", "TableRange", ">", "ranges", "=", "getRanges", "(", "env", ")", ";", "outer", ":", "while", "(", "true", ")", "{", "long", "ts1", "=", "env", ".", "getSharedResources", "(", ")", ".", "getOracleClient", "(", ")", ".", "getStamp", "(", ")", ".", "getTxTimestamp", "(", ")", ";", "for", "(", "TableRange", "range", ":", "ranges", ")", "{", "boolean", "sawNotifications", "=", "waitTillNoNotifications", "(", "env", ",", "range", ")", ";", "if", "(", "sawNotifications", ")", "{", "ranges", "=", "getRanges", "(", "env", ")", ";", "// This range had notifications. Processing those notifications may have created", "// notifications in previously scanned ranges, so start over.", "continue", "outer", ";", "}", "}", "long", "ts2", "=", "env", ".", "getSharedResources", "(", ")", ".", "getOracleClient", "(", ")", ".", "getStamp", "(", ")", ".", "getTxTimestamp", "(", ")", ";", "// Check to ensure the Oracle issued no timestamps during the scan for notifications.", "if", "(", "ts2", "-", "ts1", "==", "1", ")", "{", "break", ";", "}", "}", "}", "catch", "(", "Exception", "e", ")", "{", "log", ".", "error", "(", "\"An exception was thrown -\"", ",", "e", ")", ";", "System", ".", "exit", "(", "-", "1", ")", ";", "}", "}" ]

[ "Wait", "until", "a", "scan", "of", "the", "table", "completes", "without", "seeing", "notifications", "AND", "without", "the", "Oracle", "issuing", "any", "timestamps", "during", "the", "scan", "." ]

[ "public", "static", "Range", "toRange", "(", "Span", "span", ")", "{", "return", "new", "Range", "(", "toKey", "(", "span", ".", "getStart", "(", ")", ")", ",", "span", ".", "isStartInclusive", "(", ")", ",", "toKey", "(", "span", ".", "getEnd", "(", ")", ")", ",", "span", ".", "isEndInclusive", "(", ")", ")", ";", "}" ]

[ "Converts", "a", "Fluo", "Span", "to", "Accumulo", "Range" ]

[ "public", "static", "Key", "toKey", "(", "RowColumn", "rc", ")", "{", "if", "(", "(", "rc", "==", "null", ")", "||", "(", "rc", ".", "getRow", "(", ")", ".", "equals", "(", "Bytes", ".", "EMPTY", ")", ")", ")", "{", "return", "null", ";", "}", "Text", "row", "=", "ByteUtil", ".", "toText", "(", "rc", ".", "getRow", "(", ")", ")", ";", "if", "(", "(", "rc", ".", "getColumn", "(", ")", ".", "equals", "(", "Column", ".", "EMPTY", ")", ")", "||", "!", "rc", ".", "getColumn", "(", ")", ".", "isFamilySet", "(", ")", ")", "{", "return", "new", "Key", "(", "row", ")", ";", "}", "Text", "cf", "=", "ByteUtil", ".", "toText", "(", "rc", ".", "getColumn", "(", ")", ".", "getFamily", "(", ")", ")", ";", "if", "(", "!", "rc", ".", "getColumn", "(", ")", ".", "isQualifierSet", "(", ")", ")", "{", "return", "new", "Key", "(", "row", ",", "cf", ")", ";", "}", "Text", "cq", "=", "ByteUtil", ".", "toText", "(", "rc", ".", "getColumn", "(", ")", ".", "getQualifier", "(", ")", ")", ";", "if", "(", "!", "rc", ".", "getColumn", "(", ")", ".", "isVisibilitySet", "(", ")", ")", "{", "return", "new", "Key", "(", "row", ",", "cf", ",", "cq", ")", ";", "}", "Text", "cv", "=", "ByteUtil", ".", "toText", "(", "rc", ".", "getColumn", "(", ")", ".", "getVisibility", "(", ")", ")", ";", "return", "new", "Key", "(", "row", ",", "cf", ",", "cq", ",", "cv", ")", ";", "}" ]

[ "Converts", "from", "a", "Fluo", "RowColumn", "to", "a", "Accumulo", "Key" ]

[ "public", "static", "Span", "toSpan", "(", "Range", "range", ")", "{", "return", "new", "Span", "(", "toRowColumn", "(", "range", ".", "getStartKey", "(", ")", ")", ",", "range", ".", "isStartKeyInclusive", "(", ")", ",", "toRowColumn", "(", "range", ".", "getEndKey", "(", ")", ")", ",", "range", ".", "isEndKeyInclusive", "(", ")", ")", ";", "}" ]

[ "Converts", "an", "Accumulo", "Range", "to", "a", "Fluo", "Span" ]

[ "public", "static", "RowColumn", "toRowColumn", "(", "Key", "key", ")", "{", "if", "(", "key", "==", "null", ")", "{", "return", "RowColumn", ".", "EMPTY", ";", "}", "if", "(", "(", "key", ".", "getRow", "(", ")", "==", "null", ")", "||", "key", ".", "getRow", "(", ")", ".", "getLength", "(", ")", "==", "0", ")", "{", "return", "RowColumn", ".", "EMPTY", ";", "}", "Bytes", "row", "=", "ByteUtil", ".", "toBytes", "(", "key", ".", "getRow", "(", ")", ")", ";", "if", "(", "(", "key", ".", "getColumnFamily", "(", ")", "==", "null", ")", "||", "key", ".", "getColumnFamily", "(", ")", ".", "getLength", "(", ")", "==", "0", ")", "{", "return", "new", "RowColumn", "(", "row", ")", ";", "}", "Bytes", "cf", "=", "ByteUtil", ".", "toBytes", "(", "key", ".", "getColumnFamily", "(", ")", ")", ";", "if", "(", "(", "key", ".", "getColumnQualifier", "(", ")", "==", "null", ")", "||", "key", ".", "getColumnQualifier", "(", ")", ".", "getLength", "(", ")", "==", "0", ")", "{", "return", "new", "RowColumn", "(", "row", ",", "new", "Column", "(", "cf", ")", ")", ";", "}", "Bytes", "cq", "=", "ByteUtil", ".", "toBytes", "(", "key", ".", "getColumnQualifier", "(", ")", ")", ";", "if", "(", "(", "key", ".", "getColumnVisibility", "(", ")", "==", "null", ")", "||", "key", ".", "getColumnVisibility", "(", ")", ".", "getLength", "(", ")", "==", "0", ")", "{", "return", "new", "RowColumn", "(", "row", ",", "new", "Column", "(", "cf", ",", "cq", ")", ")", ";", "}", "Bytes", "cv", "=", "ByteUtil", ".", "toBytes", "(", "key", ".", "getColumnVisibility", "(", ")", ")", ";", "return", "new", "RowColumn", "(", "row", ",", "new", "Column", "(", "cf", ",", "cq", ",", "cv", ")", ")", ";", "}" ]

[ "Converts", "from", "an", "Accumulo", "Key", "to", "a", "Fluo", "RowColumn" ]

[ "public", "FluoKeyValueGenerator", "set", "(", "RowColumnValue", "rcv", ")", "{", "setRow", "(", "rcv", ".", "getRow", "(", ")", ")", ";", "setColumn", "(", "rcv", ".", "getColumn", "(", ")", ")", ";", "setValue", "(", "rcv", ".", "getValue", "(", ")", ")", ";", "return", "this", ";", "}" ]

[ "Set", "the", "row", "column", "and", "value" ]

[ "public", "FluoKeyValue", "[", "]", "getKeyValues", "(", ")", "{", "FluoKeyValue", "kv", "=", "keyVals", "[", "0", "]", ";", "kv", ".", "setKey", "(", "new", "Key", "(", "row", ",", "fam", ",", "qual", ",", "vis", ",", "ColumnType", ".", "WRITE", ".", "encode", "(", "1", ")", ")", ")", ";", "kv", ".", "getValue", "(", ")", ".", "set", "(", "WriteValue", ".", "encode", "(", "0", ",", "false", ",", "false", ")", ")", ";", "kv", "=", "keyVals", "[", "1", "]", ";", "kv", ".", "setKey", "(", "new", "Key", "(", "row", ",", "fam", ",", "qual", ",", "vis", ",", "ColumnType", ".", "DATA", ".", "encode", "(", "0", ")", ")", ")", ";", "kv", ".", "getValue", "(", ")", ".", "set", "(", "val", ")", ";", "return", "keyVals", ";", "}" ]

[ "Translates", "the", "Fluo", "row", "column", "and", "value", "set", "into", "the", "persistent", "format", "that", "is", "stored", "in", "Accumulo", "." ]

[ "public", "RowColumn", "following", "(", ")", "{", "if", "(", "row", ".", "equals", "(", "Bytes", ".", "EMPTY", ")", ")", "{", "return", "RowColumn", ".", "EMPTY", ";", "}", "else", "if", "(", "col", ".", "equals", "(", "Column", ".", "EMPTY", ")", ")", "{", "return", "new", "RowColumn", "(", "followingBytes", "(", "row", ")", ")", ";", "}", "else", "if", "(", "!", "col", ".", "isQualifierSet", "(", ")", ")", "{", "return", "new", "RowColumn", "(", "row", ",", "new", "Column", "(", "followingBytes", "(", "col", ".", "getFamily", "(", ")", ")", ")", ")", ";", "}", "else", "if", "(", "!", "col", ".", "isVisibilitySet", "(", ")", ")", "{", "return", "new", "RowColumn", "(", "row", ",", "new", "Column", "(", "col", ".", "getFamily", "(", ")", ",", "followingBytes", "(", "col", ".", "getQualifier", "(", ")", ")", ")", ")", ";", "}", "else", "{", "return", "new", "RowColumn", "(", "row", ",", "new", "Column", "(", "col", ".", "getFamily", "(", ")", ",", "col", ".", "getQualifier", "(", ")", ",", "followingBytes", "(", "col", ".", "getVisibility", "(", ")", ")", ")", ")", ";", "}", "}" ]

[ "Returns", "a", "RowColumn", "following", "the", "current", "one" ]

[ "public", "FluoMutationGenerator", "put", "(", "Column", "col", ",", "CharSequence", "value", ")", "{", "return", "put", "(", "col", ",", "value", ".", "toString", "(", ")", ".", "getBytes", "(", "StandardCharsets", ".", "UTF_8", ")", ")", ";", "}" ]

[ "Puts", "value", "at", "given", "column" ]

[ "public", "static", "CuratorFramework", "newAppCurator", "(", "FluoConfiguration", "config", ")", "{", "return", "newCurator", "(", "config", ".", "getAppZookeepers", "(", ")", ",", "config", ".", "getZookeeperTimeout", "(", ")", ",", "config", ".", "getZookeeperSecret", "(", ")", ")", ";", "}" ]

[ "Creates", "a", "curator", "built", "using", "Application", "s", "zookeeper", "connection", "string", ".", "Root", "path", "will", "start", "at", "Fluo", "application", "chroot", "." ]

[ "public", "static", "CuratorFramework", "newFluoCurator", "(", "FluoConfiguration", "config", ")", "{", "return", "newCurator", "(", "config", ".", "getInstanceZookeepers", "(", ")", ",", "config", ".", "getZookeeperTimeout", "(", ")", ",", "config", ".", "getZookeeperSecret", "(", ")", ")", ";", "}" ]

[ "Creates", "a", "curator", "built", "using", "Fluo", "s", "zookeeper", "connection", "string", ".", "Root", "path", "will", "start", "at", "Fluo", "chroot", "." ]

[ "public", "static", "CuratorFramework", "newCurator", "(", "String", "zookeepers", ",", "int", "timeout", ",", "String", "secret", ")", "{", "final", "ExponentialBackoffRetry", "retry", "=", "new", "ExponentialBackoffRetry", "(", "1000", ",", "10", ")", ";", "if", "(", "secret", ".", "isEmpty", "(", ")", ")", "{", "return", "CuratorFrameworkFactory", ".", "newClient", "(", "zookeepers", ",", "timeout", ",", "timeout", ",", "retry", ")", ";", "}", "else", "{", "return", "CuratorFrameworkFactory", ".", "builder", "(", ")", ".", "connectString", "(", "zookeepers", ")", ".", "connectionTimeoutMs", "(", "timeout", ")", ".", "sessionTimeoutMs", "(", "timeout", ")", ".", "retryPolicy", "(", "retry", ")", ".", "authorization", "(", "\"digest\"", ",", "(", "\"fluo:\"", "+", "secret", ")", ".", "getBytes", "(", "StandardCharsets", ".", "UTF_8", ")", ")", ".", "aclProvider", "(", "new", "ACLProvider", "(", ")", "{", "@", "Override", "public", "List", "<", "ACL", ">", "getDefaultAcl", "(", ")", "{", "return", "CREATOR_ALL_ACL", ";", "}", "@", "Override", "public", "List", "<", "ACL", ">", "getAclForPath", "(", "String", "path", ")", "{", "switch", "(", "path", ")", "{", "case", "ZookeeperPath", ".", "ORACLE_GC_TIMESTAMP", ":", "// The garbage collection iterator running in Accumulo tservers needs to read this", "// value w/o authenticating.", "return", "PUBLICLY_READABLE_ACL", ";", "default", ":", "return", "CREATOR_ALL_ACL", ";", "}", "}", "}", ")", ".", "build", "(", ")", ";", "}", "}" ]

[ "Creates", "a", "curator", "built", "using", "the", "given", "zookeeper", "connection", "string", "and", "timeout" ]

[ "public", "static", "void", "startAndWait", "(", "PersistentNode", "node", ",", "int", "maxWaitSec", ")", "{", "node", ".", "start", "(", ")", ";", "int", "waitTime", "=", "0", ";", "try", "{", "while", "(", "node", ".", "waitForInitialCreate", "(", "1", ",", "TimeUnit", ".", "SECONDS", ")", "==", "false", ")", "{", "waitTime", "+=", "1", ";", "log", ".", "info", "(", "\"Waited \"", "+", "waitTime", "+", "\" sec for ephemeral node to be created\"", ")", ";", "if", "(", "waitTime", ">", "maxWaitSec", ")", "{", "throw", "new", "IllegalStateException", "(", "\"Failed to create ephemeral node\"", ")", ";", "}", "}", "}", "catch", "(", "InterruptedException", "e", ")", "{", "throw", "new", "IllegalStateException", "(", "e", ")", ";", "}", "}" ]

[ "Starts", "the", "ephemeral", "node", "and", "waits", "for", "it", "to", "be", "created" ]

[ "public", "static", "NodeCache", "startAppIdWatcher", "(", "Environment", "env", ")", "{", "try", "{", "CuratorFramework", "curator", "=", "env", ".", "getSharedResources", "(", ")", ".", "getCurator", "(", ")", ";", "byte", "[", "]", "uuidBytes", "=", "curator", ".", "getData", "(", ")", ".", "forPath", "(", "ZookeeperPath", ".", "CONFIG_FLUO_APPLICATION_ID", ")", ";", "if", "(", "uuidBytes", "==", "null", ")", "{", "Halt", ".", "halt", "(", "\"Fluo Application UUID not found\"", ")", ";", "throw", "new", "RuntimeException", "(", ")", ";", "// make findbugs happy", "}", "final", "String", "uuid", "=", "new", "String", "(", "uuidBytes", ",", "StandardCharsets", ".", "UTF_8", ")", ";", "final", "NodeCache", "nodeCache", "=", "new", "NodeCache", "(", "curator", ",", "ZookeeperPath", ".", "CONFIG_FLUO_APPLICATION_ID", ")", ";", "nodeCache", ".", "getListenable", "(", ")", ".", "addListener", "(", "(", ")", "->", "{", "ChildData", "node", "=", "nodeCache", ".", "getCurrentData", "(", ")", ";", "if", "(", "node", "==", "null", "||", "!", "uuid", ".", "equals", "(", "new", "String", "(", "node", ".", "getData", "(", ")", ",", "StandardCharsets", ".", "UTF_8", ")", ")", ")", "{", "Halt", ".", "halt", "(", "\"Fluo Application UUID has changed or disappeared\"", ")", ";", "}", "}", ")", ";", "nodeCache", ".", "start", "(", ")", ";", "return", "nodeCache", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "RuntimeException", "(", "e", ")", ";", "}", "}" ]

[ "Start", "watching", "the", "fluo", "app", "uuid", ".", "If", "it", "changes", "or", "goes", "away", "then", "halt", "the", "process", "." ]

[ "private", "void", "readZookeeperConfig", "(", ")", "{", "try", "(", "CuratorFramework", "curator", "=", "CuratorUtil", ".", "newAppCurator", "(", "config", ")", ")", "{", "curator", ".", "start", "(", ")", ";", "accumuloInstance", "=", "new", "String", "(", "curator", ".", "getData", "(", ")", ".", "forPath", "(", "ZookeeperPath", ".", "CONFIG_ACCUMULO_INSTANCE_NAME", ")", ",", "StandardCharsets", ".", "UTF_8", ")", ";", "accumuloInstanceID", "=", "new", "String", "(", "curator", ".", "getData", "(", ")", ".", "forPath", "(", "ZookeeperPath", ".", "CONFIG_ACCUMULO_INSTANCE_ID", ")", ",", "StandardCharsets", ".", "UTF_8", ")", ";", "fluoApplicationID", "=", "new", "String", "(", "curator", ".", "getData", "(", ")", ".", "forPath", "(", "ZookeeperPath", ".", "CONFIG_FLUO_APPLICATION_ID", ")", ",", "StandardCharsets", ".", "UTF_8", ")", ";", "table", "=", "new", "String", "(", "curator", ".", "getData", "(", ")", ".", "forPath", "(", "ZookeeperPath", ".", "CONFIG_ACCUMULO_TABLE", ")", ",", "StandardCharsets", ".", "UTF_8", ")", ";", "observers", "=", "ObserverUtil", ".", "load", "(", "curator", ")", ";", "config", "=", "FluoAdminImpl", ".", "mergeZookeeperConfig", "(", "config", ")", ";", "// make sure not to include config passed to env, only want config from zookeeper", "appConfig", "=", "config", ".", "getAppConfiguration", "(", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "IllegalStateException", "(", "e", ")", ";", "}", "}" ]

[ "Read", "configuration", "from", "zookeeper" ]

[ "@", "Override", "public", "void", "close", "(", ")", "{", "status", "=", "TrStatus", ".", "CLOSED", ";", "try", "{", "node", ".", "close", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "log", ".", "error", "(", "\"Failed to close ephemeral node\"", ")", ";", "throw", "new", "IllegalStateException", "(", "e", ")", ";", "}", "}" ]

[ "Closes", "the", "transactor", "node", "by", "removing", "its", "node", "in", "Zookeeper" ]

[ "private", "static", "Map", "<", "String", ",", "Set", "<", "String", ">", ">", "expand", "(", "Map", "<", "String", ",", "Set", "<", "String", ">", ">", "viewToPropNames", ")", "{", "Set", "<", "String", ">", "baseProps", "=", "viewToPropNames", ".", "get", "(", "PropertyView", ".", "BASE_VIEW", ")", ";", "if", "(", "baseProps", "==", "null", ")", "{", "baseProps", "=", "ImmutableSet", ".", "of", "(", ")", ";", "}", "if", "(", "!", "SquigglyConfig", ".", "isFilterImplicitlyIncludeBaseFieldsInView", "(", ")", ")", "{", "// make an exception for full view", "Set", "<", "String", ">", "fullView", "=", "viewToPropNames", ".", "get", "(", "PropertyView", ".", "FULL_VIEW", ")", ";", "if", "(", "fullView", "!=", "null", ")", "{", "fullView", ".", "addAll", "(", "baseProps", ")", ";", "}", "return", "viewToPropNames", ";", "}", "for", "(", "Map", ".", "Entry", "<", "String", ",", "Set", "<", "String", ">", ">", "entry", ":", "viewToPropNames", ".", "entrySet", "(", ")", ")", "{", "String", "viewName", "=", "entry", ".", "getKey", "(", ")", ";", "Set", "<", "String", ">", "propNames", "=", "entry", ".", "getValue", "(", ")", ";", "if", "(", "!", "PropertyView", ".", "BASE_VIEW", ".", "equals", "(", "viewName", ")", ")", "{", "propNames", ".", "addAll", "(", "baseProps", ")", ";", "}", "}", "return", "viewToPropNames", ";", "}" ]

[ "apply", "the", "base", "fields", "to", "other", "views", "if", "configured", "to", "do", "so", "." ]

[ "public", "List", "<", "SquigglyNode", ">", "parse", "(", "String", "filter", ")", "{", "filter", "=", "StringUtils", ".", "trim", "(", "filter", ")", ";", "if", "(", "StringUtils", ".", "isEmpty", "(", "filter", ")", ")", "{", "return", "Collections", ".", "emptyList", "(", ")", ";", "}", "// get it from the cache if we can", "List", "<", "SquigglyNode", ">", "cachedNodes", "=", "CACHE", ".", "getIfPresent", "(", "filter", ")", ";", "if", "(", "cachedNodes", "!=", "null", ")", "{", "return", "cachedNodes", ";", "}", "SquigglyExpressionLexer", "lexer", "=", "ThrowingErrorListener", ".", "overwrite", "(", "new", "SquigglyExpressionLexer", "(", "new", "ANTLRInputStream", "(", "filter", ")", ")", ")", ";", "SquigglyExpressionParser", "parser", "=", "ThrowingErrorListener", ".", "overwrite", "(", "new", "SquigglyExpressionParser", "(", "new", "CommonTokenStream", "(", "lexer", ")", ")", ")", ";", "Visitor", "visitor", "=", "new", "Visitor", "(", ")", ";", "List", "<", "SquigglyNode", ">", "nodes", "=", "Collections", ".", "unmodifiableList", "(", "visitor", ".", "visit", "(", "parser", ".", "parse", "(", ")", ")", ")", ";", "CACHE", ".", "put", "(", "filter", ",", "nodes", ")", ";", "return", "nodes", ";", "}" ]

[ "Parse", "a", "filter", "expression", "." ]

[ "public", "static", "<", "E", ">", "Collection", "<", "E", ">", "collectify", "(", "ObjectMapper", "mapper", ",", "Object", "source", ",", "Class", "<", "?", "extends", "Collection", ">", "targetCollectionType", ",", "Class", "<", "E", ">", "targetElementType", ")", "{", "CollectionType", "collectionType", "=", "mapper", ".", "getTypeFactory", "(", ")", ".", "constructCollectionType", "(", "targetCollectionType", ",", "targetElementType", ")", ";", "return", "objectify", "(", "mapper", ",", "convertToCollection", "(", "source", ")", ",", "collectionType", ")", ";", "}" ]

[ "Convert", "an", "object", "to", "a", "collection", "." ]

[ "public", "static", "List", "<", "Map", "<", "String", ",", "Object", ">", ">", "listify", "(", "ObjectMapper", "mapper", ",", "Object", "source", ")", "{", "return", "(", "List", "<", "Map", "<", "String", ",", "Object", ">", ">", ")", "collectify", "(", "mapper", ",", "source", ",", "List", ".", "class", ")", ";", "}" ]

[ "Convert", "an", "object", "to", "a", "list", "of", "maps", "." ]

[ "public", "static", "<", "E", ">", "List", "<", "E", ">", "listify", "(", "ObjectMapper", "mapper", ",", "Object", "source", ",", "Class", "<", "E", ">", "targetElementType", ")", "{", "return", "(", "List", "<", "E", ">", ")", "collectify", "(", "mapper", ",", "source", ",", "List", ".", "class", ",", "targetElementType", ")", ";", "}" ]

[ "Convert", "an", "object", "to", "a", "list", "." ]

[ "public", "static", "Object", "objectify", "(", "ObjectMapper", "mapper", ",", "Object", "source", ")", "{", "return", "objectify", "(", "mapper", ",", "source", ",", "Object", ".", "class", ")", ";", "}" ]

[ "Converts", "an", "object", "to", "an", "object", "with", "squiggly", "filters", "applied", "." ]

[ "public", "static", "<", "T", ">", "T", "objectify", "(", "ObjectMapper", "mapper", ",", "Object", "source", ",", "JavaType", "targetType", ")", "{", "try", "{", "return", "mapper", ".", "readValue", "(", "mapper", ".", "writeValueAsBytes", "(", "source", ")", ",", "targetType", ")", ";", "}", "catch", "(", "RuntimeException", "e", ")", "{", "throw", "e", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "RuntimeException", "(", "e", ")", ";", "}", "}" ]

[ "Converts", "an", "object", "to", "an", "instance", "of", "the", "target", "type", "." ]

[ "public", "static", "Set", "<", "Map", "<", "String", ",", "Object", ">", ">", "setify", "(", "ObjectMapper", "mapper", ",", "Object", "source", ")", "{", "return", "(", "Set", "<", "Map", "<", "String", ",", "Object", ">", ">", ")", "collectify", "(", "mapper", ",", "source", ",", "Set", ".", "class", ")", ";", "}" ]

[ "Convert", "an", "object", "to", "a", "set", "of", "maps", "." ]

[ "public", "static", "<", "E", ">", "Set", "<", "E", ">", "setify", "(", "ObjectMapper", "mapper", ",", "Object", "source", ",", "Class", "<", "E", ">", "targetElementType", ")", "{", "return", "(", "Set", "<", "E", ">", ")", "collectify", "(", "mapper", ",", "source", ",", "Set", ".", "class", ",", "targetElementType", ")", ";", "}" ]

[ "Convert", "an", "object", "to", "a", "set", "." ]

[ "public", "static", "String", "stringify", "(", "ObjectMapper", "mapper", ",", "Object", "object", ")", "{", "try", "{", "return", "mapper", ".", "writeValueAsString", "(", "object", ")", ";", "}", "catch", "(", "JsonProcessingException", "e", ")", "{", "throw", "new", "IllegalArgumentException", "(", "e", ")", ";", "}", "}" ]

[ "Takes", "an", "object", "and", "converts", "it", "to", "a", "string", "." ]

[ "private", "Path", "getPath", "(", "PropertyWriter", "writer", ",", "JsonStreamContext", "sc", ")", "{", "LinkedList", "<", "PathElement", ">", "elements", "=", "new", "LinkedList", "<>", "(", ")", ";", "if", "(", "sc", "!=", "null", ")", "{", "elements", ".", "add", "(", "new", "PathElement", "(", "writer", ".", "getName", "(", ")", ",", "sc", ".", "getCurrentValue", "(", ")", ")", ")", ";", "sc", "=", "sc", ".", "getParent", "(", ")", ";", "}", "while", "(", "sc", "!=", "null", ")", "{", "if", "(", "sc", ".", "getCurrentName", "(", ")", "!=", "null", "&&", "sc", ".", "getCurrentValue", "(", ")", "!=", "null", ")", "{", "elements", ".", "addFirst", "(", "new", "PathElement", "(", "sc", ".", "getCurrentName", "(", ")", ",", "sc", ".", "getCurrentValue", "(", ")", ")", ")", ";", "}", "sc", "=", "sc", ".", "getParent", "(", ")", ";", "}", "return", "new", "Path", "(", "elements", ")", ";", "}" ]

[ "create", "a", "path", "structure", "representing", "the", "object", "graph" ]

[ "private", "boolean", "pathMatches", "(", "Path", "path", ",", "SquigglyContext", "context", ")", "{", "List", "<", "SquigglyNode", ">", "nodes", "=", "context", ".", "getNodes", "(", ")", ";", "Set", "<", "String", ">", "viewStack", "=", "null", ";", "SquigglyNode", "viewNode", "=", "null", ";", "int", "pathSize", "=", "path", ".", "getElements", "(", ")", ".", "size", "(", ")", ";", "int", "lastIdx", "=", "pathSize", "-", "1", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "pathSize", ";", "i", "++", ")", "{", "PathElement", "element", "=", "path", ".", "getElements", "(", ")", ".", "get", "(", "i", ")", ";", "if", "(", "viewNode", "!=", "null", "&&", "!", "viewNode", ".", "isSquiggly", "(", ")", ")", "{", "Class", "beanClass", "=", "element", ".", "getBeanClass", "(", ")", ";", "if", "(", "beanClass", "!=", "null", "&&", "!", "Map", ".", "class", ".", "isAssignableFrom", "(", "beanClass", ")", ")", "{", "Set", "<", "String", ">", "propertyNames", "=", "getPropertyNamesFromViewStack", "(", "element", ",", "viewStack", ")", ";", "if", "(", "!", "propertyNames", ".", "contains", "(", "element", ".", "getName", "(", ")", ")", ")", "{", "return", "false", ";", "}", "}", "}", "else", "if", "(", "nodes", ".", "isEmpty", "(", ")", ")", "{", "return", "false", ";", "}", "else", "{", "SquigglyNode", "match", "=", "findBestSimpleNode", "(", "element", ",", "nodes", ")", ";", "if", "(", "match", "==", "null", ")", "{", "match", "=", "findBestViewNode", "(", "element", ",", "nodes", ")", ";", "if", "(", "match", "!=", "null", ")", "{", "viewNode", "=", "match", ";", "viewStack", "=", "addToViewStack", "(", "viewStack", ",", "viewNode", ")", ";", "}", "}", "else", "if", "(", "match", ".", "isAnyShallow", "(", ")", ")", "{", "viewNode", "=", "match", ";", "}", "else", "if", "(", "match", ".", "isAnyDeep", "(", ")", ")", "{", "return", "true", ";", "}", "if", "(", "match", "==", "null", ")", "{", "if", "(", "isJsonUnwrapped", "(", "element", ")", ")", "{", "continue", ";", "}", "return", "false", ";", "}", "if", "(", "match", ".", "isNegated", "(", ")", ")", "{", "return", "false", ";", "}", "nodes", "=", "match", ".", "getChildren", "(", ")", ";", "if", "(", "i", "<", "lastIdx", "&&", "nodes", ".", "isEmpty", "(", ")", "&&", "!", "match", ".", "isEmptyNested", "(", ")", "&&", "SquigglyConfig", ".", "isFilterImplicitlyIncludeBaseFields", "(", ")", ")", "{", "nodes", "=", "BASE_VIEW_NODES", ";", "}", "}", "}", "return", "true", ";", "}" ]

[ "perform", "the", "actual", "matching" ]

[ "public", "static", "SortedMap", "<", "String", ",", "Object", ">", "asMap", "(", ")", "{", "SortedMap", "<", "String", ",", "Object", ">", "metrics", "=", "Maps", ".", "newTreeMap", "(", ")", ";", "METRICS_SOURCE", ".", "applyMetrics", "(", "metrics", ")", ";", "return", "metrics", ";", "}" ]

[ "Gets", "the", "metrics", "as", "a", "map", "whose", "keys", "are", "the", "metric", "name", "and", "whose", "values", "are", "the", "metric", "values", "." ]

[ "public", "static", "ByteBuffer", "newDirectByteBuffer", "(", "long", "addr", ",", "int", "size", ",", "Object", "att", ")", "{", "dbbCC", ".", "setAccessible", "(", "true", ")", ";", "Object", "b", "=", "null", ";", "try", "{", "b", "=", "dbbCC", ".", "newInstance", "(", "new", "Long", "(", "addr", ")", ",", "new", "Integer", "(", "size", ")", ",", "att", ")", ";", "return", "ByteBuffer", ".", "class", ".", "cast", "(", "b", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "IllegalStateException", "(", "String", ".", "format", "(", "\"Failed to create DirectByteBuffer: %s\"", ",", "e", ".", "getMessage", "(", ")", ")", ")", ";", "}", "}" ]

[ "Create", "a", "new", "DirectByteBuffer", "from", "a", "given", "address", "and", "size", ".", "The", "returned", "DirectByteBuffer", "does", "not", "release", "the", "memory", "by", "itself", "." ]

[ "public", "void", "releaseAll", "(", ")", "{", "synchronized", "(", "this", ")", "{", "Object", "[", "]", "refSet", "=", "allocatedMemoryReferences", ".", "values", "(", ")", ".", "toArray", "(", ")", ";", "if", "(", "refSet", ".", "length", "!=", "0", ")", "{", "logger", ".", "finer", "(", "\"Releasing allocated memory regions\"", ")", ";", "}", "for", "(", "Object", "ref", ":", "refSet", ")", "{", "release", "(", "(", "MemoryReference", ")", "ref", ")", ";", "}", "}", "}" ]

[ "Release", "all", "memory", "addresses", "taken", "by", "this", "allocator", ".", "Be", "careful", "in", "using", "this", "method", "since", "all", "of", "the", "memory", "addresses", "become", "invalid", "." ]

[ "public", "static", "String", "md5sum", "(", "InputStream", "input", ")", "throws", "IOException", "{", "InputStream", "in", "=", "new", "BufferedInputStream", "(", "input", ")", ";", "try", "{", "MessageDigest", "digest", "=", "java", ".", "security", ".", "MessageDigest", ".", "getInstance", "(", "\"MD5\"", ")", ";", "DigestInputStream", "digestInputStream", "=", "new", "DigestInputStream", "(", "in", ",", "digest", ")", ";", "while", "(", "digestInputStream", ".", "read", "(", ")", ">=", "0", ")", "{", "}", "OutputStream", "md5out", "=", "new", "ByteArrayOutputStream", "(", ")", ";", "md5out", ".", "write", "(", "digest", ".", "digest", "(", ")", ")", ";", "return", "md5out", ".", "toString", "(", ")", ";", "}", "catch", "(", "NoSuchAlgorithmException", "e", ")", "{", "throw", "new", "IllegalStateException", "(", "\"MD5 algorithm is not available: \"", "+", "e", ".", "getMessage", "(", ")", ")", ";", "}", "finally", "{", "in", ".", "close", "(", ")", ";", "}", "}" ]

[ "Computes", "the", "MD5", "value", "of", "the", "input", "stream" ]

[ "public", "void", "fill", "(", "long", "offset", ",", "long", "length", ",", "byte", "value", ")", "{", "unsafe", ".", "setMemory", "(", "address", "(", ")", "+", "offset", ",", "length", ",", "value", ")", ";", "}" ]

[ "Fill", "the", "buffer", "of", "the", "specified", "range", "with", "a", "given", "value" ]

[ "public", "void", "copyTo", "(", "int", "srcOffset", ",", "byte", "[", "]", "destArray", ",", "int", "destOffset", ",", "int", "size", ")", "{", "int", "cursor", "=", "destOffset", ";", "for", "(", "ByteBuffer", "bb", ":", "toDirectByteBuffers", "(", "srcOffset", ",", "size", ")", ")", "{", "int", "bbSize", "=", "bb", ".", "remaining", "(", ")", ";", "if", "(", "(", "cursor", "+", "bbSize", ")", ">", "destArray", ".", "length", ")", "throw", "new", "ArrayIndexOutOfBoundsException", "(", "String", ".", "format", "(", "\"cursor + bbSize = %,d\"", ",", "cursor", "+", "bbSize", ")", ")", ";", "bb", ".", "get", "(", "destArray", ",", "cursor", ",", "bbSize", ")", ";", "cursor", "+=", "bbSize", ";", "}", "}" ]

[ "Copy", "the", "contents", "of", "this", "buffer", "begginning", "from", "the", "srcOffset", "to", "a", "destination", "byte", "array" ]

[ "public", "void", "copyTo", "(", "long", "srcOffset", ",", "LBufferAPI", "dest", ",", "long", "destOffset", ",", "long", "size", ")", "{", "unsafe", ".", "copyMemory", "(", "address", "(", ")", "+", "srcOffset", ",", "dest", ".", "address", "(", ")", "+", "destOffset", ",", "size", ")", ";", "}" ]

[ "Copy", "the", "contents", "of", "this", "buffer", "to", "the", "destination", "LBuffer" ]

[ "public", "LBuffer", "slice", "(", "long", "from", ",", "long", "to", ")", "{", "if", "(", "from", ">", "to", ")", "throw", "new", "IllegalArgumentException", "(", "String", ".", "format", "(", "\"invalid range %,d to %,d\"", ",", "from", ",", "to", ")", ")", ";", "long", "size", "=", "to", "-", "from", ";", "LBuffer", "b", "=", "new", "LBuffer", "(", "size", ")", ";", "copyTo", "(", "from", ",", "b", ",", "0", ",", "size", ")", ";", "return", "b", ";", "}" ]

[ "Extract", "a", "slice", "[", "from", "to", ")", "of", "this", "buffer", ".", "This", "methods", "creates", "a", "copy", "of", "the", "specified", "region", "." ]

[ "public", "byte", "[", "]", "toArray", "(", ")", "{", "if", "(", "size", "(", ")", ">", "Integer", ".", "MAX_VALUE", ")", "throw", "new", "IllegalStateException", "(", "\"Cannot create byte array of more than 2GB\"", ")", ";", "int", "len", "=", "(", "int", ")", "size", "(", ")", ";", "ByteBuffer", "bb", "=", "toDirectByteBuffer", "(", "0L", ",", "len", ")", ";", "byte", "[", "]", "b", "=", "new", "byte", "[", "len", "]", ";", "// Copy data to the array", "bb", ".", "get", "(", "b", ",", "0", ",", "len", ")", ";", "return", "b", ";", "}" ]

[ "Convert", "this", "buffer", "to", "a", "java", "array", "." ]

[ "public", "void", "writeTo", "(", "WritableByteChannel", "channel", ")", "throws", "IOException", "{", "for", "(", "ByteBuffer", "buffer", ":", "toDirectByteBuffers", "(", ")", ")", "{", "channel", ".", "write", "(", "buffer", ")", ";", "}", "}" ]

[ "Writes", "the", "buffer", "contents", "to", "the", "given", "byte", "channel", "." ]

[ "public", "void", "writeTo", "(", "File", "file", ")", "throws", "IOException", "{", "FileChannel", "channel", "=", "new", "FileOutputStream", "(", "file", ")", ".", "getChannel", "(", ")", ";", "try", "{", "writeTo", "(", "channel", ")", ";", "}", "finally", "{", "channel", ".", "close", "(", ")", ";", "}", "}" ]

[ "Dump", "the", "buffer", "contents", "to", "a", "file" ]

[ "public", "int", "readFrom", "(", "byte", "[", "]", "src", ",", "int", "srcOffset", ",", "long", "destOffset", ",", "int", "length", ")", "{", "int", "readLen", "=", "(", "int", ")", "Math", ".", "min", "(", "src", ".", "length", "-", "srcOffset", ",", "Math", ".", "min", "(", "size", "(", ")", "-", "destOffset", ",", "length", ")", ")", ";", "ByteBuffer", "b", "=", "toDirectByteBuffer", "(", "destOffset", ",", "readLen", ")", ";", "b", ".", "position", "(", "0", ")", ";", "b", ".", "put", "(", "src", ",", "srcOffset", ",", "readLen", ")", ";", "return", "readLen", ";", "}" ]

[ "Read", "the", "given", "source", "byte", "array", "then", "overwrite", "this", "buffer", "s", "contents" ]

[ "public", "int", "readFrom", "(", "ByteBuffer", "src", ",", "long", "destOffset", ")", "{", "if", "(", "src", ".", "remaining", "(", ")", "+", "destOffset", ">=", "size", "(", ")", ")", "throw", "new", "BufferOverflowException", "(", ")", ";", "int", "readLen", "=", "src", ".", "remaining", "(", ")", ";", "ByteBuffer", "b", "=", "toDirectByteBuffer", "(", "destOffset", ",", "readLen", ")", ";", "b", ".", "position", "(", "0", ")", ";", "b", ".", "put", "(", "src", ")", ";", "return", "readLen", ";", "}" ]

[ "Reads", "the", "given", "source", "byte", "buffer", "into", "this", "buffer", "at", "the", "given", "offset" ]

[ "public", "static", "LBuffer", "loadFrom", "(", "File", "file", ")", "throws", "IOException", "{", "FileChannel", "fin", "=", "new", "FileInputStream", "(", "file", ")", ".", "getChannel", "(", ")", ";", "long", "fileSize", "=", "fin", ".", "size", "(", ")", ";", "if", "(", "fileSize", ">", "Integer", ".", "MAX_VALUE", ")", "throw", "new", "IllegalArgumentException", "(", "\"Cannot load from file more than 2GB: \"", "+", "file", ")", ";", "LBuffer", "b", "=", "new", "LBuffer", "(", "(", "int", ")", "fileSize", ")", ";", "long", "pos", "=", "0L", ";", "WritableChannelWrap", "ch", "=", "new", "WritableChannelWrap", "(", "b", ")", ";", "while", "(", "pos", "<", "fileSize", ")", "{", "pos", "+=", "fin", ".", "transferTo", "(", "0", ",", "fileSize", ",", "ch", ")", ";", "}", "return", "b", ";", "}" ]

[ "Create", "an", "LBuffer", "from", "a", "given", "file", "." ]

[ "public", "ByteBuffer", "[", "]", "toDirectByteBuffers", "(", "long", "offset", ",", "long", "size", ")", "{", "long", "pos", "=", "offset", ";", "long", "blockSize", "=", "Integer", ".", "MAX_VALUE", ";", "long", "limit", "=", "offset", "+", "size", ";", "int", "numBuffers", "=", "(", "int", ")", "(", "(", "size", "+", "(", "blockSize", "-", "1", ")", ")", "/", "blockSize", ")", ";", "ByteBuffer", "[", "]", "result", "=", "new", "ByteBuffer", "[", "numBuffers", "]", ";", "int", "index", "=", "0", ";", "while", "(", "pos", "<", "limit", ")", "{", "long", "blockLength", "=", "Math", ".", "min", "(", "limit", "-", "pos", ",", "blockSize", ")", ";", "result", "[", "index", "++", "]", "=", "UnsafeUtil", ".", "newDirectByteBuffer", "(", "address", "(", ")", "+", "pos", ",", "(", "int", ")", "blockLength", ",", "this", ")", ".", "order", "(", "ByteOrder", ".", "nativeOrder", "(", ")", ")", ";", "pos", "+=", "blockLength", ";", "}", "return", "result", ";", "}" ]

[ "Gives", "an", "sequence", "of", "ByteBuffers", "of", "a", "specified", "range", ".", "Writing", "to", "these", "ByteBuffers", "modifies", "the", "contents", "of", "this", "LBuffer", "." ]

[ "public", "String", "getWrappingHint", "(", "String", "fieldName", ")", "{", "if", "(", "isEmpty", "(", ")", ")", "{", "return", "\"\"", ";", "}", "return", "String", ".", "format", "(", "\" You can use this expression: %s(%s(%s))\"", ",", "formatMethod", "(", "wrappingMethodOwnerName", ",", "wrappingMethodName", ",", "\"\"", ")", ",", "formatMethod", "(", "copyMethodOwnerName", ",", "copyMethodName", ",", "copyTypeParameterName", ")", ",", "fieldName", ")", ";", "}" ]

[ "For", "given", "field", "name", "get", "the", "actual", "hint", "message" ]

[ "public", "static", "EffectiveAssignmentInsnFinder", "newInstance", "(", "final", "FieldNode", "targetVariable", ",", "final", "Collection", "<", "ControlFlowBlock", ">", "controlFlowBlocks", ")", "{", "return", "new", "EffectiveAssignmentInsnFinder", "(", "checkNotNull", "(", "targetVariable", ")", ",", "checkNotNull", "(", "controlFlowBlocks", ")", ")", ";", "}" ]

[ "Static", "factory", "method", "." ]

[ "public", "Collection", "<", "FieldNode", ">", "removeAndGetCandidatesWithoutInitialisingMethod", "(", ")", "{", "final", "List", "<", "FieldNode", ">", "result", "=", "new", "ArrayList", "<", "FieldNode", ">", "(", ")", ";", "for", "(", "final", "Map", ".", "Entry", "<", "FieldNode", ",", "Initialisers", ">", "entry", ":", "candidatesAndInitialisers", ".", "entrySet", "(", ")", ")", "{", "final", "Initialisers", "setters", "=", "entry", ".", "getValue", "(", ")", ";", "final", "List", "<", "MethodNode", ">", "initialisingMethods", "=", "setters", ".", "getMethods", "(", ")", ";", "if", "(", "initialisingMethods", ".", "isEmpty", "(", ")", ")", "{", "result", ".", "add", "(", "entry", ".", "getKey", "(", ")", ")", ";", "}", "}", "for", "(", "final", "FieldNode", "unassociatedVariable", ":", "result", ")", "{", "candidatesAndInitialisers", ".", "remove", "(", "unassociatedVariable", ")", ";", "}", "return", "result", ";", "}" ]

[ "Removes", "all", "candidates", "from", "this", "collection", "which", "are", "not", "associated", "with", "an", "initialising", "method", "." ]

[ "protected", "final", "void", "verify", "(", ")", "{", "collectInitialisers", "(", ")", ";", "verifyCandidates", "(", ")", ";", "verifyInitialisers", "(", ")", ";", "collectPossibleInitialValues", "(", ")", ";", "verifyPossibleInitialValues", "(", ")", ";", "collectEffectiveAssignmentInstructions", "(", ")", ";", "verifyEffectiveAssignmentInstructions", "(", ")", ";", "collectAssignmentGuards", "(", ")", ";", "verifyAssignmentGuards", "(", ")", ";", "end", "(", ")", ";", "}" ]

[ "Template", "method", "for", "verification", "of", "lazy", "initialisation", "." ]

[ "protected", "void", "mergeHardcodedResultsFrom", "(", "Configuration", "otherConfiguration", ")", "{", "Map", "<", "Dotted", ",", "AnalysisResult", ">", "resultsMap", "=", "hardcodedResults", ".", "build", "(", ")", ".", "stream", "(", ")", ".", "collect", "(", "Collectors", ".", "toMap", "(", "r", "->", "r", ".", "className", ",", "r", "->", "r", ")", ")", ";", "resultsMap", ".", "putAll", "(", "otherConfiguration", ".", "hardcodedResults", "(", ")", ")", ";", "hardcodedResults", "=", "ImmutableSet", ".", "<", "AnalysisResult", ">", "builder", "(", ")", ".", "addAll", "(", "resultsMap", ".", "values", "(", ")", ")", ";", "}" ]

[ "Merges", "the", "hardcoded", "results", "of", "this", "Configuration", "with", "the", "given", "Configuration", "." ]

[ "protected", "void", "mergeImmutableContainerTypesFrom", "(", "Configuration", "otherConfiguration", ")", "{", "Set", "<", "Dotted", ">", "union", "=", "Sets", ".", "union", "(", "hardcodedImmutableContainerClasses", ".", "build", "(", ")", ",", "otherConfiguration", ".", "immutableContainerClasses", "(", ")", ")", ";", "hardcodedImmutableContainerClasses", "=", "ImmutableSet", ".", "<", "Dotted", ">", "builder", "(", ")", ".", "addAll", "(", "union", ")", ";", "}" ]

[ "Merges", "the", "immutable", "container", "types", "of", "this", "Configuration", "with", "the", "given", "Configuration", "." ]

[ "protected", "final", "void", "hardcodeValidCopyMethod", "(", "Class", "<", "?", ">", "fieldType", ",", "String", "fullyQualifiedMethodName", ",", "Class", "<", "?", ">", "argType", ")", "{", "if", "(", "argType", "==", "null", "||", "fieldType", "==", "null", "||", "fullyQualifiedMethodName", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"All parameters must be supplied - no nulls\"", ")", ";", "}", "String", "className", "=", "fullyQualifiedMethodName", ".", "substring", "(", "0", ",", "fullyQualifiedMethodName", ".", "lastIndexOf", "(", "\".\"", ")", ")", ";", "String", "methodName", "=", "fullyQualifiedMethodName", ".", "substring", "(", "fullyQualifiedMethodName", ".", "lastIndexOf", "(", "\".\"", ")", "+", "1", ")", ";", "String", "desc", "=", "null", ";", "try", "{", "if", "(", "MethodIs", ".", "aConstructor", "(", "methodName", ")", ")", "{", "Constructor", "<", "?", ">", "ctor", "=", "Class", ".", "forName", "(", "className", ")", ".", "getDeclaredConstructor", "(", "argType", ")", ";", "desc", "=", "Type", ".", "getConstructorDescriptor", "(", "ctor", ")", ";", "}", "else", "{", "Method", "method", "=", "Class", ".", "forName", "(", "className", ")", ".", "getMethod", "(", "methodName", ",", "argType", ")", ";", "desc", "=", "Type", ".", "getMethodDescriptor", "(", "method", ")", ";", "}", "}", "catch", "(", "NoSuchMethodException", "e", ")", "{", "rethrow", "(", "\"No such method\"", ",", "e", ")", ";", "}", "catch", "(", "SecurityException", "e", ")", "{", "rethrow", "(", "\"Security error\"", ",", "e", ")", ";", "}", "catch", "(", "ClassNotFoundException", "e", ")", "{", "rethrow", "(", "\"Class not found\"", ",", "e", ")", ";", "}", "CopyMethod", "copyMethod", "=", "new", "CopyMethod", "(", "dotted", "(", "className", ")", ",", "methodName", ",", "desc", ")", ";", "hardcodeValidCopyMethod", "(", "fieldType", ",", "copyMethod", ")", ";", "}" ]

[ "Hardcode", "a", "copy", "method", "as", "being", "valid", ".", "This", "should", "be", "used", "to", "tell", "Mutability", "Detector", "about", "a", "method", "which", "copies", "a", "collection", "and", "when", "the", "copy", "can", "be", "wrapped", "in", "an", "immutable", "wrapper", "we", "can", "consider", "the", "assignment", "immutable", ".", "Useful", "for", "allowing", "Mutability", "Detector", "to", "correctly", "work", "with", "other", "collections", "frameworks", "such", "as", "Google", "Guava", ".", "Reflection", "is", "used", "to", "obtain", "the", "method", "s", "descriptor", "and", "to", "verify", "the", "method", "s", "existence", "." ]

[ "public", "static", "AliasFinder", "newInstance", "(", "final", "String", "variableName", ",", "final", "ControlFlowBlock", "controlFlowBlockToExamine", ")", "{", "checkArgument", "(", "!", "variableName", ".", "isEmpty", "(", ")", ")", ";", "return", "new", "AliasFinder", "(", "variableName", ",", "checkNotNull", "(", "controlFlowBlockToExamine", ")", ")", ";", "}" ]

[ "Creates", "a", "new", "instance", "of", "this", "class", "." ]

[ "private", "void", "generateCopyingPart", "(", "WrappingHint", ".", "Builder", "builder", ")", "{", "ImmutableCollection", "<", "CopyMethod", ">", "copyMethods", "=", "ImmutableMultimap", ".", "<", "String", ",", "CopyMethod", ">", "builder", "(", ")", ".", "putAll", "(", "configuration", ".", "FIELD_TYPE_TO_COPY_METHODS", ")", ".", "putAll", "(", "userDefinedCopyMethods", ")", ".", "build", "(", ")", ".", "get", "(", "typeAssignedToField", ")", ";", "if", "(", "copyMethods", ".", "isEmpty", "(", ")", ")", "{", "throw", "new", "WrappingHintGenerationException", "(", ")", ";", "}", "CopyMethod", "firstSuitable", "=", "copyMethods", ".", "iterator", "(", ")", ".", "next", "(", ")", ";", "builder", ".", "setCopyMethodOwnerName", "(", "firstSuitable", ".", "owner", ".", "toString", "(", ")", ")", ".", "setCopyMethodName", "(", "firstSuitable", ".", "name", ")", ";", "if", "(", "firstSuitable", ".", "isGeneric", "&&", "typeSignature", "!=", "null", ")", "{", "CollectionField", "withRemovedWildcards", "=", "CollectionField", ".", "from", "(", "typeAssignedToField", ",", "typeSignature", ")", ".", "transformGenericTree", "(", "GenericType", "::", "withoutWildcard", ")", ";", "builder", ".", "setCopyTypeParameterName", "(", "formatTypeParameter", "(", "withRemovedWildcards", ".", "asSimpleString", "(", ")", ")", ")", ";", "}", "}" ]

[ "Pick", "arbitrary", "copying", "method", "from", "available", "configuration", "and", "don", "t", "forget", "to", "set", "generic", "method", "type", "if", "required", "." ]

[ "private", "void", "generateWrappingPart", "(", "WrappingHint", ".", "Builder", "builder", ")", "{", "builder", ".", "setWrappingMethodOwnerName", "(", "configuration", ".", "UNMODIFIABLE_METHOD_OWNER", ")", ".", "setWrappingMethodName", "(", "configuration", ".", "FIELD_TYPE_TO_UNMODIFIABLE_METHOD", ".", "get", "(", "typeAssignedToField", ")", ")", ";", "}" ]

[ "Pick", "arbitrary", "wrapping", "method", ".", "No", "generics", "should", "be", "set", "." ]

[ "public", "void", "setBorderWidth", "(", "int", "borderWidth", ")", "{", "this", ".", "borderWidth", "=", "borderWidth", ";", "if", "(", "paintBorder", "!=", "null", ")", "paintBorder", ".", "setStrokeWidth", "(", "borderWidth", ")", ";", "requestLayout", "(", ")", ";", "invalidate", "(", ")", ";", "}" ]

[ "Sets", "the", "CircularImageView", "s", "border", "width", "in", "pixels", "." ]

[ "public", "void", "setShadow", "(", "float", "radius", ",", "float", "dx", ",", "float", "dy", ",", "int", "color", ")", "{", "shadowRadius", "=", "radius", ";", "shadowDx", "=", "dx", ";", "shadowDy", "=", "dy", ";", "shadowColor", "=", "color", ";", "updateShadow", "(", ")", ";", "}" ]

[ "Enables", "a", "dark", "shadow", "for", "this", "CircularImageView", ".", "If", "the", "radius", "is", "set", "to", "0", "the", "shadow", "is", "removed", "." ]

[ "public", "Bitmap", "drawableToBitmap", "(", "Drawable", "drawable", ")", "{", "if", "(", "drawable", "==", "null", ")", "// Don't do anything without a proper drawable", "return", "null", ";", "else", "if", "(", "drawable", "instanceof", "BitmapDrawable", ")", "{", "// Use the getBitmap() method instead if BitmapDrawable", "Log", ".", "i", "(", "TAG", ",", "\"Bitmap drawable!\"", ")", ";", "return", "(", "(", "BitmapDrawable", ")", "drawable", ")", ".", "getBitmap", "(", ")", ";", "}", "int", "intrinsicWidth", "=", "drawable", ".", "getIntrinsicWidth", "(", ")", ";", "int", "intrinsicHeight", "=", "drawable", ".", "getIntrinsicHeight", "(", ")", ";", "if", "(", "!", "(", "intrinsicWidth", ">", "0", "&&", "intrinsicHeight", ">", "0", ")", ")", "return", "null", ";", "try", "{", "// Create Bitmap object out of the drawable", "Bitmap", "bitmap", "=", "Bitmap", ".", "createBitmap", "(", "intrinsicWidth", ",", "intrinsicHeight", ",", "Bitmap", ".", "Config", ".", "ARGB_8888", ")", ";", "Canvas", "canvas", "=", "new", "Canvas", "(", "bitmap", ")", ";", "drawable", ".", "setBounds", "(", "0", ",", "0", ",", "canvas", ".", "getWidth", "(", ")", ",", "canvas", ".", "getHeight", "(", ")", ")", ";", "drawable", ".", "draw", "(", "canvas", ")", ";", "return", "bitmap", ";", "}", "catch", "(", "OutOfMemoryError", "e", ")", "{", "// Simply return null of failed bitmap creations", "Log", ".", "e", "(", "TAG", ",", "\"Encountered OutOfMemoryError while generating bitmap!\"", ")", ";", "return", "null", ";", "}", "}" ]

[ "Convert", "a", "drawable", "object", "into", "a", "Bitmap", "." ]

[ "public", "void", "updateBitmapShader", "(", ")", "{", "if", "(", "image", "==", "null", ")", "return", ";", "shader", "=", "new", "BitmapShader", "(", "image", ",", "Shader", ".", "TileMode", ".", "CLAMP", ",", "Shader", ".", "TileMode", ".", "CLAMP", ")", ";", "if", "(", "canvasSize", "!=", "image", ".", "getWidth", "(", ")", "||", "canvasSize", "!=", "image", ".", "getHeight", "(", ")", ")", "{", "Matrix", "matrix", "=", "new", "Matrix", "(", ")", ";", "float", "scale", "=", "(", "float", ")", "canvasSize", "/", "(", "float", ")", "image", ".", "getWidth", "(", ")", ";", "matrix", ".", "setScale", "(", "scale", ",", "scale", ")", ";", "shader", ".", "setLocalMatrix", "(", "matrix", ")", ";", "}", "}" ]

[ "Re", "-", "initializes", "the", "shader", "texture", "used", "to", "fill", "in", "the", "Circle", "upon", "drawing", "." ]

[ "public", "void", "refreshBitmapShader", "(", ")", "{", "shader", "=", "new", "BitmapShader", "(", "Bitmap", ".", "createScaledBitmap", "(", "image", ",", "canvasSize", ",", "canvasSize", ",", "false", ")", ",", "Shader", ".", "TileMode", ".", "CLAMP", ",", "Shader", ".", "TileMode", ".", "CLAMP", ")", ";", "}" ]

[ "Reinitializes", "the", "shader", "texture", "used", "to", "fill", "in", "the", "Circle", "upon", "drawing", "." ]

[ "private", "int", "calcItemWidth", "(", "RecyclerView", "rvCategories", ")", "{", "if", "(", "itemWidth", "==", "null", "||", "itemWidth", "==", "0", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "rvCategories", ".", "getChildCount", "(", ")", ";", "i", "++", ")", "{", "itemWidth", "=", "rvCategories", ".", "getChildAt", "(", "i", ")", ".", "getWidth", "(", ")", ";", "if", "(", "itemWidth", "!=", "0", ")", "{", "break", ";", "}", "}", "}", "// in case of call before view was created", "if", "(", "itemWidth", "==", "null", ")", "{", "itemWidth", "=", "0", ";", "}", "return", "itemWidth", ";", "}" ]

[ "very", "big", "duct", "tape" ]

[ "public", "final", "void", "setOrientation", "(", "int", "orientation", ")", "{", "mOrientation", "=", "orientation", ";", "mOrientationState", "=", "getOrientationStateFromParam", "(", "mOrientation", ")", ";", "invalidate", "(", ")", ";", "if", "(", "mOuterAdapter", "!=", "null", ")", "{", "mOuterAdapter", ".", "setOrientation", "(", "mOrientation", ")", ";", "}", "}" ]

[ "Sets", "orientation", "of", "loopbar" ]

[ "@", "SuppressWarnings", "(", "\"unused\"", ")", "public", "void", "selectItem", "(", "int", "position", ",", "boolean", "invokeListeners", ")", "{", "IOperationItem", "item", "=", "mOuterAdapter", ".", "getItem", "(", "position", ")", ";", "IOperationItem", "oldHidedItem", "=", "mOuterAdapter", ".", "getItem", "(", "mRealHidedPosition", ")", ";", "int", "realPosition", "=", "mOuterAdapter", ".", "normalizePosition", "(", "position", ")", ";", "//do nothing if position not changed", "if", "(", "realPosition", "==", "mCurrentItemPosition", ")", "{", "return", ";", "}", "int", "itemToShowAdapterPosition", "=", "position", "-", "realPosition", "+", "mRealHidedPosition", ";", "item", ".", "setVisible", "(", "false", ")", ";", "startSelectedViewOutAnimation", "(", "position", ")", ";", "mOuterAdapter", ".", "notifyRealItemChanged", "(", "position", ")", ";", "mRealHidedPosition", "=", "realPosition", ";", "oldHidedItem", ".", "setVisible", "(", "true", ")", ";", "mFlContainerSelected", ".", "requestLayout", "(", ")", ";", "mOuterAdapter", ".", "notifyRealItemChanged", "(", "itemToShowAdapterPosition", ")", ";", "mCurrentItemPosition", "=", "realPosition", ";", "if", "(", "invokeListeners", ")", "{", "notifyItemClickListeners", "(", "realPosition", ")", ";", "}", "if", "(", "BuildConfig", ".", "DEBUG", ")", "{", "Log", ".", "i", "(", "TAG", ",", "\"clicked on position =\"", "+", "position", ")", ";", "}", "}" ]

[ "Select", "item", "by", "it", "s", "position" ]

[ "public", "IOrientationState", "getOrientationStateFromParam", "(", "int", "orientation", ")", "{", "switch", "(", "orientation", ")", "{", "case", "Orientation", ".", "ORIENTATION_HORIZONTAL_BOTTOM", ":", "return", "new", "OrientationStateHorizontalBottom", "(", ")", ";", "case", "Orientation", ".", "ORIENTATION_HORIZONTAL_TOP", ":", "return", "new", "OrientationStateHorizontalTop", "(", ")", ";", "case", "Orientation", ".", "ORIENTATION_VERTICAL_LEFT", ":", "return", "new", "OrientationStateVerticalLeft", "(", ")", ";", "case", "Orientation", ".", "ORIENTATION_VERTICAL_RIGHT", ":", "return", "new", "OrientationStateVerticalRight", "(", ")", ";", "default", ":", "return", "new", "OrientationStateHorizontalBottom", "(", ")", ";", "}", "}" ]

[ "orientation", "state", "factory", "method" ]

[ "@", "Override", "public", "<", "T", "extends", "ViewGroup", ".", "MarginLayoutParams", ">", "T", "setSelectionMargin", "(", "int", "marginPx", ",", "T", "layoutParams", ")", "{", "return", "mSelectionGravityState", ".", "setSelectionMargin", "(", "marginPx", ",", "layoutParams", ")", ";", "}" ]

[ "dispatch", "to", "gravity", "state" ]

[ "public", "int", "consume", "(", "Map", "<", "String", ",", "String", ">", "initialVars", ")", "{", "int", "result", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "repeatNumber", ";", "i", "++", ")", "{", "result", "+=", "super", ".", "consume", "(", "initialVars", ")", ";", "}", "return", "result", ";", "}" ]

[ "Overridden", "consume", "method", ".", "Corresponding", "parent", "method", "will", "be", "called", "necessary", "number", "of", "times" ]

[ "public", "static", "void", "main", "(", "String", "[", "]", "args", ")", "{", "String", "modelFile", "=", "\"\"", ";", "String", "outputFile", "=", "\"\"", ";", "int", "numberOfRows", "=", "0", ";", "try", "{", "modelFile", "=", "args", "[", "0", "]", ";", "outputFile", "=", "args", "[", "1", "]", ";", "numberOfRows", "=", "Integer", ".", "valueOf", "(", "args", "[", "2", "]", ")", ";", "}", "catch", "(", "IndexOutOfBoundsException", "|", "NumberFormatException", "e", ")", "{", "System", ".", "out", ".", "println", "(", "\"ERROR! Invalid command line arguments, expecting: <scxml model file> \"", "+", "\"<desired csv output file> <desired number of output rows>\"", ")", ";", "return", ";", "}", "FileInputStream", "model", "=", "null", ";", "try", "{", "model", "=", "new", "FileInputStream", "(", "modelFile", ")", ";", "}", "catch", "(", "FileNotFoundException", "e", ")", "{", "System", ".", "out", ".", "println", "(", "\"ERROR! Model file not found\"", ")", ";", "return", ";", "}", "SCXMLEngine", "engine", "=", "new", "SCXMLEngine", "(", ")", ";", "engine", ".", "setModelByInputFileStream", "(", "model", ")", ";", "engine", ".", "setBootstrapMin", "(", "5", ")", ";", "DataConsumer", "consumer", "=", "new", "DataConsumer", "(", ")", ";", "CSVFileWriter", "writer", ";", "try", "{", "writer", "=", "new", "CSVFileWriter", "(", "outputFile", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "System", ".", "out", ".", "println", "(", "\"ERROR! Can not write to output csv file\"", ")", ";", "return", ";", "}", "consumer", ".", "addDataWriter", "(", "writer", ")", ";", "DefaultDistributor", "dist", "=", "new", "DefaultDistributor", "(", ")", ";", "dist", ".", "setThreadCount", "(", "5", ")", ";", "dist", ".", "setMaxNumberOfLines", "(", "numberOfRows", ")", ";", "dist", ".", "setDataConsumer", "(", "consumer", ")", ";", "engine", ".", "process", "(", "dist", ")", ";", "writer", ".", "closeCSVFile", "(", ")", ";", "System", ".", "out", ".", "println", "(", "\"COMPLETE!\"", ")", ";", "}" ]

[ "Main", "method", "handles", "all", "the", "setup", "tasks", "for", "DataGenerator", "a", "user", "would", "normally", "do", "themselves" ]

[ "public", "static", "Tuple2", "<", "Double", ",", "Double", ">", "getRandomGeographicalLocation", "(", ")", "{", "return", "new", "Tuple2", "<>", "(", "(", "double", ")", "(", "RandomHelper", ".", "randWithConfiguredSeed", "(", ")", ".", "nextInt", "(", "999", ")", "+", "1", ")", "/", "100", ",", "(", "double", ")", "(", "RandomHelper", ".", "randWithConfiguredSeed", "(", ")", ".", "nextInt", "(", "999", ")", "+", "1", ")", "/", "100", ")", ";", "}" ]

[ "Get", "random", "geographical", "location" ]

[ "public", "static", "Double", "getDistanceBetweenCoordinates", "(", "Tuple2", "<", "Double", ",", "Double", ">", "point1", ",", "Tuple2", "<", "Double", ",", "Double", ">", "point2", ")", "{", "// sqrt( (x2-x1)^2 + (y2-y2)^2 )\r", "Double", "xDiff", "=", "point1", ".", "_1", "(", ")", "-", "point2", ".", "_1", "(", ")", ";", "Double", "yDiff", "=", "point1", ".", "_2", "(", ")", "-", "point2", ".", "_2", "(", ")", ";", "return", "Math", ".", "sqrt", "(", "xDiff", "*", "xDiff", "+", "yDiff", "*", "yDiff", ")", ";", "}" ]

[ "Get", "distance", "between", "geographical", "coordinates" ]

[ "public", "static", "Double", "getDistanceWithinThresholdOfCoordinates", "(", "Tuple2", "<", "Double", ",", "Double", ">", "point1", ",", "Tuple2", "<", "Double", ",", "Double", ">", "point2", ")", "{", "throw", "new", "NotImplementedError", "(", ")", ";", "}" ]

[ "Not", "implemented", "." ]

[ "public", "static", "Boolean", "areCoordinatesWithinThreshold", "(", "Tuple2", "<", "Double", ",", "Double", ">", "point1", ",", "Tuple2", "<", "Double", ",", "Double", ">", "point2", ")", "{", "return", "getDistanceBetweenCoordinates", "(", "point1", ",", "point2", ")", "<", "COORDINATE_THRESHOLD", ";", "}" ]

[ "Whether", "or", "not", "points", "are", "within", "some", "threshold", "." ]

[ "public", "static", "void", "main", "(", "String", "[", "]", "args", ")", "{", "//Adding custom equivalence class generation transformer - NOTE this will get applied during graph traversal-->\r", "//MODEL USAGE EXAMPLE: <assign name=\"var_out_V1_2\" expr=\"%ssn\"/> <dg:transform name=\"EQ\"/>\r", "Map", "<", "String", ",", "DataTransformer", ">", "transformers", "=", "new", "HashMap", "<", "String", ",", "DataTransformer", ">", "(", ")", ";", "transformers", ".", "put", "(", "\"EQ\"", ",", "new", "EquivalenceClassTransformer", "(", ")", ")", ";", "Vector", "<", "CustomTagExtension", ">", "cte", "=", "new", "Vector", "<", "CustomTagExtension", ">", "(", ")", ";", "cte", ".", "add", "(", "new", "InLineTransformerExtension", "(", "transformers", ")", ")", ";", "Engine", "engine", "=", "new", "SCXMLEngine", "(", "cte", ")", ";", "//will default to samplemachine, but you could specify a different file if you choose to\r", "InputStream", "is", "=", "CmdLine", ".", "class", ".", "getResourceAsStream", "(", "\"/\"", "+", "(", "args", ".", "length", "==", "0", "?", "\"samplemachine\"", ":", "args", "[", "0", "]", ")", "+", "\".xml\"", ")", ";", "engine", ".", "setModelByInputFileStream", "(", "is", ")", ";", "// Usually, this should be more than the number of threads you intend to run\r", "engine", ".", "setBootstrapMin", "(", "1", ")", ";", "//Prepare the consumer with the proper writer and transformer\r", "DataConsumer", "consumer", "=", "new", "DataConsumer", "(", ")", ";", "consumer", ".", "addDataTransformer", "(", "new", "SampleMachineTransformer", "(", ")", ")", ";", "//Adding custom equivalence class generation transformer - NOTE this will get applied post data generation.\r", "//MODEL USAGE EXAMPLE: <dg:assign name=\"var_out_V2\" set=\"%regex([0-9]{3}[A-Z0-9]{5})\"/>\r", "consumer", ".", "addDataTransformer", "(", "new", "EquivalenceClassTransformer", "(", ")", ")", ";", "consumer", ".", "addDataWriter", "(", "new", "DefaultWriter", "(", "System", ".", "out", ",", "new", "String", "[", "]", "{", "\"var_1_1\"", ",", "\"var_1_2\"", ",", "\"var_1_3\"", ",", "\"var_1_4\"", ",", "\"var_1_5\"", ",", "\"var_1_6\"", ",", "\"var_1_7\"", ",", "\"var_2_1\"", ",", "\"var_2_2\"", ",", "\"var_2_3\"", ",", "\"var_2_4\"", ",", "\"var_2_5\"", ",", "\"var_2_6\"", ",", "\"var_2_7\"", ",", "\"var_2_8\"", "}", ")", ")", ";", "//Prepare the distributor\r", "DefaultDistributor", "defaultDistributor", "=", "new", "DefaultDistributor", "(", ")", ";", "defaultDistributor", ".", "setThreadCount", "(", "1", ")", ";", "defaultDistributor", ".", "setDataConsumer", "(", "consumer", ")", ";", "Logger", ".", "getLogger", "(", "\"org.apache\"", ")", ".", "setLevel", "(", "Level", ".", "WARN", ")", ";", "engine", ".", "process", "(", "defaultDistributor", ")", ";", "}" ]

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

[ "public", "static", "UserStub", "getStubWithRandomParams", "(", "UserTypeVal", "userType", ")", "{", "// Java coerces the return type as a Tuple2 of Objects -- but it's declared as a Tuple2 of Doubles!\r", "// Oh the joys of type erasure.\r", "Tuple2", "<", "Double", ",", "Double", ">", "tuple", "=", "SocialNetworkUtilities", ".", "getRandomGeographicalLocation", "(", ")", ";", "return", "new", "UserStub", "(", "userType", ",", "new", "Tuple2", "<>", "(", "(", "Double", ")", "tuple", ".", "_1", "(", ")", ",", "(", "Double", ")", "tuple", ".", "_2", "(", ")", ")", ",", "SocialNetworkUtilities", ".", "getRandomIsSecret", "(", ")", ")", ";", "}" ]

[ "Get", "random", "stub", "matching", "this", "user", "type" ]

[ "public", "void", "writeOutput", "(", "DataPipe", "cr", ")", "{", "String", "[", "]", "nextLine", "=", "new", "String", "[", "cr", ".", "getDataMap", "(", ")", ".", "entrySet", "(", ")", ".", "size", "(", ")", "]", ";", "int", "count", "=", "0", ";", "for", "(", "Map", ".", "Entry", "<", "String", ",", "String", ">", "entry", ":", "cr", ".", "getDataMap", "(", ")", ".", "entrySet", "(", ")", ")", "{", "nextLine", "[", "count", "]", "=", "entry", ".", "getValue", "(", ")", ";", "count", "++", ";", "}", "csvFile", ".", "writeNext", "(", "nextLine", ")", ";", "}" ]

[ "Prints", "one", "line", "to", "the", "csv", "file" ]

[ "public", "boolean", "isHoliday", "(", "String", "dateString", ")", "{", "boolean", "isHoliday", "=", "false", ";", "for", "(", "Holiday", "date", ":", "EquivalenceClassTransformer", ".", "HOLIDAYS", ")", "{", "if", "(", "convertToReadableDate", "(", "date", ".", "forYear", "(", "Integer", ".", "parseInt", "(", "dateString", ".", "substring", "(", "0", ",", "4", ")", ")", ")", ")", ".", "equals", "(", "dateString", ")", ")", "{", "isHoliday", "=", "true", ";", "}", "}", "return", "isHoliday", ";", "}" ]

[ "Checks", "if", "the", "date", "is", "a", "holiday" ]

[ "public", "String", "getNextDay", "(", "String", "dateString", ",", "boolean", "onlyBusinessDays", ")", "{", "DateTimeFormatter", "parser", "=", "ISODateTimeFormat", ".", "date", "(", ")", ";", "DateTime", "date", "=", "parser", ".", "parseDateTime", "(", "dateString", ")", ".", "plusDays", "(", "1", ")", ";", "Calendar", "cal", "=", "Calendar", ".", "getInstance", "(", ")", ";", "cal", ".", "setTime", "(", "date", ".", "toDate", "(", ")", ")", ";", "if", "(", "onlyBusinessDays", ")", "{", "if", "(", "cal", ".", "get", "(", "Calendar", ".", "DAY_OF_WEEK", ")", "==", "1", "||", "cal", ".", "get", "(", "Calendar", ".", "DAY_OF_WEEK", ")", "==", "7", "||", "isHoliday", "(", "date", ".", "toString", "(", ")", ".", "substring", "(", "0", ",", "10", ")", ")", ")", "{", "return", "getNextDay", "(", "date", ".", "toString", "(", ")", ".", "substring", "(", "0", ",", "10", ")", ",", "true", ")", ";", "}", "else", "{", "return", "parser", ".", "print", "(", "date", ")", ";", "}", "}", "else", "{", "return", "parser", ".", "print", "(", "date", ")", ";", "}", "}" ]

[ "Takes", "a", "date", "and", "retrieves", "the", "next", "business", "day" ]

[ "public", "Date", "toDate", "(", "String", "dateString", ")", "{", "Date", "date", "=", "null", ";", "DateFormat", "df", "=", "new", "SimpleDateFormat", "(", "\"yyyy-MM-dd\"", ")", ";", "try", "{", "date", "=", "df", ".", "parse", "(", "dateString", ")", ";", "}", "catch", "(", "ParseException", "ex", ")", "{", "System", ".", "out", ".", "println", "(", "ex", ".", "fillInStackTrace", "(", ")", ")", ";", "}", "return", "date", ";", "}" ]

[ "Takes", "a", "String", "and", "converts", "it", "to", "a", "Date" ]

[ "public", "String", "getRandomHoliday", "(", "String", "earliest", ",", "String", "latest", ")", "{", "String", "dateString", "=", "\"\"", ";", "DateTimeFormatter", "parser", "=", "ISODateTimeFormat", ".", "date", "(", ")", ";", "DateTime", "earlyDate", "=", "parser", ".", "parseDateTime", "(", "earliest", ")", ";", "DateTime", "lateDate", "=", "parser", ".", "parseDateTime", "(", "latest", ")", ";", "List", "<", "Holiday", ">", "holidays", "=", "new", "LinkedList", "<>", "(", ")", ";", "int", "min", "=", "Integer", ".", "parseInt", "(", "earlyDate", ".", "toString", "(", ")", ".", "substring", "(", "0", ",", "4", ")", ")", ";", "int", "max", "=", "Integer", ".", "parseInt", "(", "lateDate", ".", "toString", "(", ")", ".", "substring", "(", "0", ",", "4", ")", ")", ";", "int", "range", "=", "max", "-", "min", "+", "1", ";", "int", "randomYear", "=", "(", "int", ")", "(", "Math", ".", "random", "(", ")", "*", "range", ")", "+", "min", ";", "for", "(", "Holiday", "s", ":", "EquivalenceClassTransformer", ".", "HOLIDAYS", ")", "{", "holidays", ".", "add", "(", "s", ")", ";", "}", "Collections", ".", "shuffle", "(", "holidays", ")", ";", "for", "(", "Holiday", "holiday", ":", "holidays", ")", "{", "dateString", "=", "convertToReadableDate", "(", "holiday", ".", "forYear", "(", "randomYear", ")", ")", ";", "if", "(", "toDate", "(", "dateString", ")", ".", "after", "(", "toDate", "(", "earliest", ")", ")", "&&", "toDate", "(", "dateString", ")", ".", "before", "(", "toDate", "(", "latest", ")", ")", ")", "{", "break", ";", "}", "}", "return", "dateString", ";", "}" ]

[ "Grab", "random", "holiday", "from", "the", "equivalence", "class", "that", "falls", "between", "the", "two", "dates" ]

[ "public", "int", "numOccurrences", "(", "int", "year", ",", "int", "month", ",", "int", "day", ")", "{", "DateTimeFormatter", "parser", "=", "ISODateTimeFormat", ".", "date", "(", ")", ";", "DateTime", "date", "=", "parser", ".", "parseDateTime", "(", "year", "+", "\"-\"", "+", "month", "+", "\"-\"", "+", "\"01\"", ")", ";", "Calendar", "cal", "=", "Calendar", ".", "getInstance", "(", ")", ";", "cal", ".", "setTime", "(", "date", ".", "toDate", "(", ")", ")", ";", "GregorianChronology", "calendar", "=", "GregorianChronology", ".", "getInstance", "(", ")", ";", "DateTimeField", "field", "=", "calendar", ".", "dayOfMonth", "(", ")", ";", "int", "days", "=", "0", ";", "int", "count", "=", "0", ";", "int", "num", "=", "field", ".", "getMaximumValue", "(", "new", "LocalDate", "(", "year", ",", "month", ",", "day", ",", "calendar", ")", ")", ";", "while", "(", "days", "<", "num", ")", "{", "if", "(", "cal", ".", "get", "(", "Calendar", ".", "DAY_OF_WEEK", ")", "==", "day", ")", "{", "count", "++", ";", "}", "date", "=", "date", ".", "plusDays", "(", "1", ")", ";", "cal", ".", "setTime", "(", "date", ".", "toDate", "(", ")", ")", ";", "days", "++", ";", "}", "return", "count", ";", "}" ]

[ "Given", "a", "year", "month", "and", "day", "find", "the", "number", "of", "occurrences", "of", "that", "day", "in", "the", "month" ]

[ "public", "String", "convertToReadableDate", "(", "Holiday", "holiday", ")", "{", "DateTimeFormatter", "parser", "=", "ISODateTimeFormat", ".", "date", "(", ")", ";", "if", "(", "holiday", ".", "isInDateForm", "(", ")", ")", "{", "String", "month", "=", "Integer", ".", "toString", "(", "holiday", ".", "getMonth", "(", ")", ")", ".", "length", "(", ")", "<", "2", "?", "\"0\"", "+", "holiday", ".", "getMonth", "(", ")", ":", "Integer", ".", "toString", "(", "holiday", ".", "getMonth", "(", ")", ")", ";", "String", "day", "=", "Integer", ".", "toString", "(", "holiday", ".", "getDayOfMonth", "(", ")", ")", ".", "length", "(", ")", "<", "2", "?", "\"0\"", "+", "holiday", ".", "getDayOfMonth", "(", ")", ":", "Integer", ".", "toString", "(", "holiday", ".", "getDayOfMonth", "(", ")", ")", ";", "return", "holiday", ".", "getYear", "(", ")", "+", "\"-\"", "+", "month", "+", "\"-\"", "+", "day", ";", "}", "else", "{", "/*\n * 5 denotes the final occurrence of the day in the month. Need to find actual\n * number of occurrences\n */", "if", "(", "holiday", ".", "getOccurrence", "(", ")", "==", "5", ")", "{", "holiday", ".", "setOccurrence", "(", "numOccurrences", "(", "holiday", ".", "getYear", "(", ")", ",", "holiday", ".", "getMonth", "(", ")", ",", "holiday", ".", "getDayOfWeek", "(", ")", ")", ")", ";", "}", "DateTime", "date", "=", "parser", ".", "parseDateTime", "(", "holiday", ".", "getYear", "(", ")", "+", "\"-\"", "+", "holiday", ".", "getMonth", "(", ")", "+", "\"-\"", "+", "\"01\"", ")", ";", "Calendar", "calendar", "=", "Calendar", ".", "getInstance", "(", ")", ";", "calendar", ".", "setTime", "(", "date", ".", "toDate", "(", ")", ")", ";", "int", "count", "=", "0", ";", "while", "(", "count", "<", "holiday", ".", "getOccurrence", "(", ")", ")", "{", "if", "(", "calendar", ".", "get", "(", "Calendar", ".", "DAY_OF_WEEK", ")", "==", "holiday", ".", "getDayOfWeek", "(", ")", ")", "{", "count", "++", ";", "if", "(", "count", "==", "holiday", ".", "getOccurrence", "(", ")", ")", "{", "break", ";", "}", "}", "date", "=", "date", ".", "plusDays", "(", "1", ")", ";", "calendar", ".", "setTime", "(", "date", ".", "toDate", "(", ")", ")", ";", "}", "return", "date", ".", "toString", "(", ")", ".", "substring", "(", "0", ",", "10", ")", ";", "}", "}" ]

[ "Convert", "the", "holiday", "format", "from", "EquivalenceClassTransformer", "into", "a", "date", "format" ]