Datasets:

CM

/

codexglue_code2text_java

like 4

[ "private", "void", "startMetricsThread", "(", ")", "{", "LOG", ".", "info", "(", "\"Starting periodic Metrics Emitter thread, frequency = \"", "+", "METRICS_POLL_INTERVAL", ")", ";", "this", ".", "metricsThread", "=", "new", "DaemonThreadExecutor", "(", "\"tx-metrics\"", ")", "{", "@", "Override", "public", "void", "doRun", "(", ")", "{", "txMetricsCollector", ".", "gauge", "(", "\"committing.size\"", ",", "committingChangeSets", ".", "size", "(", ")", ")", ";", "txMetricsCollector", ".", "gauge", "(", "\"committed.size\"", ",", "committedChangeSets", ".", "size", "(", ")", ")", ";", "txMetricsCollector", ".", "gauge", "(", "\"inprogress.size\"", ",", "inProgress", ".", "size", "(", ")", ")", ";", "txMetricsCollector", ".", "gauge", "(", "\"invalid.size\"", ",", "invalidArray", ".", "length", ")", ";", "}", "@", "Override", "protected", "void", "onShutdown", "(", ")", "{", "// perform a final metrics emit", "txMetricsCollector", ".", "gauge", "(", "\"committing.size\"", ",", "committingChangeSets", ".", "size", "(", ")", ")", ";", "txMetricsCollector", ".", "gauge", "(", "\"committed.size\"", ",", "committedChangeSets", ".", "size", "(", ")", ")", ";", "txMetricsCollector", ".", "gauge", "(", "\"inprogress.size\"", ",", "inProgress", ".", "size", "(", ")", ")", ";", "txMetricsCollector", ".", "gauge", "(", "\"invalid.size\"", ",", "invalidArray", ".", "length", ")", ";", "}", "@", "Override", "public", "long", "getSleepMillis", "(", ")", "{", "return", "METRICS_POLL_INTERVAL", ";", "}", "}", ";", "metricsThread", ".", "start", "(", ")", ";", "}" ]

[ "Emits", "Transaction", "Data", "structures", "size", "as", "metrics" ]

[ "public", "boolean", "takeSnapshot", "(", "OutputStream", "out", ")", "throws", "IOException", "{", "TransactionSnapshot", "snapshot", "=", "getSnapshot", "(", ")", ";", "if", "(", "snapshot", "!=", "null", ")", "{", "persistor", ".", "writeSnapshot", "(", "out", ",", "snapshot", ")", ";", "return", "true", ";", "}", "else", "{", "return", "false", ";", "}", "}" ]

[ "Take", "a", "snapshot", "of", "the", "transaction", "state", "and", "serialize", "it", "into", "the", "given", "output", "stream", "." ]

[ "private", "void", "restoreSnapshot", "(", "TransactionSnapshot", "snapshot", ")", "{", "LOG", ".", "info", "(", "\"Restoring transaction state from snapshot at \"", "+", "snapshot", ".", "getTimestamp", "(", ")", ")", ";", "Preconditions", ".", "checkState", "(", "lastSnapshotTime", "==", "0", ",", "\"lastSnapshotTime has been set!\"", ")", ";", "Preconditions", ".", "checkState", "(", "readPointer", "==", "0", ",", "\"readPointer has been set!\"", ")", ";", "Preconditions", ".", "checkState", "(", "lastWritePointer", "==", "0", ",", "\"lastWritePointer has been set!\"", ")", ";", "Preconditions", ".", "checkState", "(", "invalid", ".", "isEmpty", "(", ")", ",", "\"invalid list should be empty!\"", ")", ";", "Preconditions", ".", "checkState", "(", "inProgress", ".", "isEmpty", "(", ")", ",", "\"inProgress map should be empty!\"", ")", ";", "Preconditions", ".", "checkState", "(", "committingChangeSets", ".", "isEmpty", "(", ")", ",", "\"committingChangeSets should be empty!\"", ")", ";", "Preconditions", ".", "checkState", "(", "committedChangeSets", ".", "isEmpty", "(", ")", ",", "\"committedChangeSets should be empty!\"", ")", ";", "LOG", ".", "info", "(", "\"Restoring snapshot of state: \"", "+", "snapshot", ")", ";", "lastSnapshotTime", "=", "snapshot", ".", "getTimestamp", "(", ")", ";", "readPointer", "=", "snapshot", ".", "getReadPointer", "(", ")", ";", "lastWritePointer", "=", "snapshot", ".", "getWritePointer", "(", ")", ";", "invalid", ".", "addAll", "(", "snapshot", ".", "getInvalid", "(", ")", ")", ";", "inProgress", ".", "putAll", "(", "txnBackwardsCompatCheck", "(", "defaultLongTimeout", ",", "longTimeoutTolerance", ",", "snapshot", ".", "getInProgress", "(", ")", ")", ")", ";", "committingChangeSets", ".", "putAll", "(", "snapshot", ".", "getCommittingChangeSets", "(", ")", ")", ";", "committedChangeSets", ".", "putAll", "(", "snapshot", ".", "getCommittedChangeSets", "(", ")", ")", ";", "}" ]

[ "Restore", "the", "initial", "in", "-", "memory", "transaction", "state", "from", "a", "snapshot", "." ]

[ "public", "static", "Map", "<", "Long", ",", "InProgressTx", ">", "txnBackwardsCompatCheck", "(", "int", "defaultLongTimeout", ",", "long", "longTimeoutTolerance", ",", "Map", "<", "Long", ",", "InProgressTx", ">", "inProgress", ")", "{", "for", "(", "Map", ".", "Entry", "<", "Long", ",", "InProgressTx", ">", "entry", ":", "inProgress", ".", "entrySet", "(", ")", ")", "{", "long", "writePointer", "=", "entry", ".", "getKey", "(", ")", ";", "long", "expiration", "=", "entry", ".", "getValue", "(", ")", ".", "getExpiration", "(", ")", ";", "// LONG transactions will either have a negative expiration or expiration set to the long timeout", "// use a fudge factor on the expiration check, since expiraton is set based on system time, not the write pointer", "if", "(", "entry", ".", "getValue", "(", ")", ".", "getType", "(", ")", "==", "null", "&&", "(", "expiration", "<", "0", "||", "(", "getTxExpirationFromWritePointer", "(", "writePointer", ",", "defaultLongTimeout", ")", "-", "expiration", "<", "longTimeoutTolerance", ")", ")", ")", "{", "// handle null expiration", "long", "newExpiration", "=", "getTxExpirationFromWritePointer", "(", "writePointer", ",", "defaultLongTimeout", ")", ";", "InProgressTx", "compatTx", "=", "new", "InProgressTx", "(", "entry", ".", "getValue", "(", ")", ".", "getVisibilityUpperBound", "(", ")", ",", "newExpiration", ",", "TransactionType", ".", "LONG", ",", "entry", ".", "getValue", "(", ")", ".", "getCheckpointWritePointers", "(", ")", ")", ";", "entry", ".", "setValue", "(", "compatTx", ")", ";", "}", "else", "if", "(", "entry", ".", "getValue", "(", ")", ".", "getType", "(", ")", "==", "null", ")", "{", "InProgressTx", "compatTx", "=", "new", "InProgressTx", "(", "entry", ".", "getValue", "(", ")", ".", "getVisibilityUpperBound", "(", ")", ",", "entry", ".", "getValue", "(", ")", ".", "getExpiration", "(", ")", ",", "TransactionType", ".", "SHORT", ",", "entry", ".", "getValue", "(", ")", ".", "getCheckpointWritePointers", "(", ")", ")", ";", "entry", ".", "setValue", "(", "compatTx", ")", ";", "}", "}", "return", "inProgress", ";", "}" ]

[ "Check", "if", "in", "-", "progress", "transactions", "need", "to", "be", "migrated", "to", "have", "expiration", "time", "and", "type", "if", "so", "do", "the", "migration", ".", "This", "is", "required", "for", "backwards", "compatibility", "when", "long", "running", "transactions", "were", "represented", "with", "expiration", "time", "-", "1", ".", "This", "can", "be", "removed", "when", "we", "stop", "supporting", "SnapshotCodec", "version", "1", "." ]

[ "public", "void", "resetState", "(", ")", "{", "this", ".", "logWriteLock", ".", "lock", "(", ")", ";", "try", "{", "// Take a snapshot before resetting the state, for debugging purposes", "doSnapshot", "(", "false", ")", ";", "// Clear the state", "clear", "(", ")", ";", "// Take another snapshot: if no snapshot is taken after clearing the state", "// and the manager is restarted, we will recover from the snapshot taken", "// before resetting the state, which would be really bad", "// This call will also init a new WAL", "doSnapshot", "(", "false", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "LOG", ".", "error", "(", "\"Snapshot failed when resetting state!\"", ",", "e", ")", ";", "e", ".", "printStackTrace", "(", ")", ";", "}", "finally", "{", "this", ".", "logWriteLock", ".", "unlock", "(", ")", ";", "}", "}" ]

[ "Resets", "the", "state", "of", "the", "transaction", "manager", "." ]

[ "private", "void", "abortService", "(", "String", "message", ",", "Throwable", "error", ")", "{", "if", "(", "isRunning", "(", ")", ")", "{", "LOG", ".", "error", "(", "\"Aborting transaction manager due to: \"", "+", "message", ",", "error", ")", ";", "notifyFailed", "(", "error", ")", ";", "}", "}" ]

[ "Immediately", "shuts", "down", "the", "service", "without", "going", "through", "the", "normal", "close", "process", "." ]

[ "public", "Transaction", "startShort", "(", "int", "timeoutInSeconds", ")", "{", "Preconditions", ".", "checkArgument", "(", "timeoutInSeconds", ">", "0", ",", "\"timeout must be positive but is %s\"", ",", "timeoutInSeconds", ")", ";", "txMetricsCollector", ".", "rate", "(", "\"start.short\"", ")", ";", "Stopwatch", "timer", "=", "new", "Stopwatch", "(", ")", ".", "start", "(", ")", ";", "long", "expiration", "=", "getTxExpiration", "(", "timeoutInSeconds", ")", ";", "Transaction", "tx", "=", "startTx", "(", "expiration", ",", "TransactionType", ".", "SHORT", ")", ";", "txMetricsCollector", ".", "histogram", "(", "\"start.short.latency\"", ",", "(", "int", ")", "timer", ".", "elapsedMillis", "(", ")", ")", ";", "return", "tx", ";", "}" ]

[ "Start", "a", "short", "transaction", "with", "a", "given", "timeout", "." ]

[ "public", "Transaction", "startLong", "(", ")", "{", "txMetricsCollector", ".", "rate", "(", "\"start.long\"", ")", ";", "Stopwatch", "timer", "=", "new", "Stopwatch", "(", ")", ".", "start", "(", ")", ";", "long", "expiration", "=", "getTxExpiration", "(", "defaultLongTimeout", ")", ";", "Transaction", "tx", "=", "startTx", "(", "expiration", ",", "TransactionType", ".", "LONG", ")", ";", "txMetricsCollector", ".", "histogram", "(", "\"start.long.latency\"", ",", "(", "int", ")", "timer", ".", "elapsedMillis", "(", ")", ")", ";", "return", "tx", ";", "}" ]

[ "Start", "a", "long", "transaction", ".", "Long", "transactions", "and", "do", "not", "participate", "in", "conflict", "detection", ".", "Also", "aborting", "a", "long", "transaction", "moves", "it", "to", "the", "invalid", "list", "because", "we", "assume", "that", "its", "writes", "cannot", "be", "rolled", "back", "." ]

[ "public", "boolean", "truncateInvalidTx", "(", "Set", "<", "Long", ">", "invalidTxIds", ")", "{", "// guard against changes to the transaction log while processing", "txMetricsCollector", ".", "rate", "(", "\"truncateInvalidTx\"", ")", ";", "Stopwatch", "timer", "=", "new", "Stopwatch", "(", ")", ".", "start", "(", ")", ";", "this", ".", "logReadLock", ".", "lock", "(", ")", ";", "try", "{", "boolean", "success", ";", "synchronized", "(", "this", ")", "{", "ensureAvailable", "(", ")", ";", "success", "=", "doTruncateInvalidTx", "(", "invalidTxIds", ")", ";", "}", "appendToLog", "(", "TransactionEdit", ".", "createTruncateInvalidTx", "(", "invalidTxIds", ")", ")", ";", "txMetricsCollector", ".", "histogram", "(", "\"truncateInvalidTx.latency\"", ",", "(", "int", ")", "timer", ".", "elapsedMillis", "(", ")", ")", ";", "return", "success", ";", "}", "finally", "{", "this", ".", "logReadLock", ".", "unlock", "(", ")", ";", "}", "}" ]

[ "Removes", "the", "given", "transaction", "ids", "from", "the", "invalid", "list", "." ]

[ "public", "boolean", "truncateInvalidTxBefore", "(", "long", "time", ")", "throws", "InvalidTruncateTimeException", "{", "// guard against changes to the transaction log while processing", "txMetricsCollector", ".", "rate", "(", "\"truncateInvalidTxBefore\"", ")", ";", "Stopwatch", "timer", "=", "new", "Stopwatch", "(", ")", ".", "start", "(", ")", ";", "this", ".", "logReadLock", ".", "lock", "(", ")", ";", "try", "{", "boolean", "success", ";", "synchronized", "(", "this", ")", "{", "ensureAvailable", "(", ")", ";", "success", "=", "doTruncateInvalidTxBefore", "(", "time", ")", ";", "}", "appendToLog", "(", "TransactionEdit", ".", "createTruncateInvalidTxBefore", "(", "time", ")", ")", ";", "txMetricsCollector", ".", "histogram", "(", "\"truncateInvalidTxBefore.latency\"", ",", "(", "int", ")", "timer", ".", "elapsedMillis", "(", ")", ")", ";", "return", "success", ";", "}", "finally", "{", "this", ".", "logReadLock", ".", "unlock", "(", ")", ";", "}", "}" ]

[ "Removes", "all", "transaction", "ids", "started", "before", "the", "given", "time", "from", "invalid", "list", "." ]

[ "private", "Transaction", "createTransaction", "(", "long", "writePointer", ",", "TransactionType", "type", ")", "{", "// For holding the first in progress short transaction Id (with timeout >= 0).", "long", "firstShortTx", "=", "Transaction", ".", "NO_TX_IN_PROGRESS", ";", "LongArrayList", "inProgressIds", "=", "new", "LongArrayList", "(", "inProgress", ".", "size", "(", ")", ")", ";", "for", "(", "Map", ".", "Entry", "<", "Long", ",", "InProgressTx", ">", "entry", ":", "inProgress", ".", "entrySet", "(", ")", ")", "{", "long", "txId", "=", "entry", ".", "getKey", "(", ")", ";", "inProgressIds", ".", "add", "(", "txId", ")", ";", "// add any checkpointed write pointers to the in-progress list", "LongArrayList", "childIds", "=", "entry", ".", "getValue", "(", ")", ".", "getCheckpointWritePointers", "(", ")", ";", "if", "(", "childIds", "!=", "null", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "childIds", ".", "size", "(", ")", ";", "i", "++", ")", "{", "inProgressIds", ".", "add", "(", "childIds", ".", "get", "(", "i", ")", ")", ";", "}", "}", "if", "(", "firstShortTx", "==", "Transaction", ".", "NO_TX_IN_PROGRESS", "&&", "!", "entry", ".", "getValue", "(", ")", ".", "isLongRunning", "(", ")", ")", "{", "firstShortTx", "=", "txId", ";", "}", "}", "return", "new", "Transaction", "(", "readPointer", ",", "writePointer", ",", "invalidArray", ",", "inProgressIds", ".", "toLongArray", "(", ")", ",", "firstShortTx", ",", "type", ")", ";", "}" ]

[ "Creates", "a", "new", "Transaction", ".", "This", "method", "only", "get", "called", "from", "start", "transaction", "which", "is", "already", "synchronized", "." ]

[ "public", "void", "logStatistics", "(", ")", "{", "LOG", ".", "info", "(", "\"Transaction Statistics: write pointer = \"", "+", "lastWritePointer", "+", "\", invalid = \"", "+", "invalid", ".", "size", "(", ")", "+", "\", in progress = \"", "+", "inProgress", ".", "size", "(", ")", "+", "\", committing = \"", "+", "committingChangeSets", ".", "size", "(", ")", "+", "\", committed = \"", "+", "committedChangeSets", ".", "size", "(", ")", ")", ";", "}" ]

[ "Called", "from", "the", "tx", "service", "every", "10", "seconds", ".", "This", "hack", "is", "needed", "because", "current", "metrics", "system", "is", "not", "flexible", "when", "it", "comes", "to", "adding", "new", "metrics", "." ]

[ "public", "void", "init", "(", ")", "throws", "IOException", "{", "Injector", "injector", "=", "Guice", ".", "createInjector", "(", "new", "ConfigModule", "(", "conf", ")", ",", "new", "ZKModule", "(", ")", ",", "new", "DiscoveryModules", "(", ")", ".", "getDistributedModules", "(", ")", ",", "new", "TransactionModules", "(", ")", ".", "getDistributedModules", "(", ")", ",", "new", "TransactionClientModule", "(", ")", ")", ";", "zkClient", "=", "injector", ".", "getInstance", "(", "ZKClientService", ".", "class", ")", ";", "zkClient", ".", "startAndWait", "(", ")", ";", "txClient", "=", "injector", ".", "getInstance", "(", "TransactionServiceClient", ".", "class", ")", ";", "createTableIfNotExists", "(", "conf", ",", "TABLE", ",", "new", "byte", "[", "]", "[", "]", "{", "FAMILY", "}", ")", ";", "conn", "=", "HConnectionManager", ".", "createConnection", "(", "conf", ")", ";", "}" ]

[ "Sets", "up", "common", "resources", "required", "by", "all", "clients", "." ]

[ "public", "void", "run", "(", ")", "throws", "IOException", ",", "InterruptedException", "{", "List", "<", "Client", ">", "clients", "=", "new", "ArrayList", "<>", "(", "totalClients", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "totalClients", ";", "i", "++", ")", "{", "Client", "c", "=", "new", "Client", "(", "i", ",", "totalClients", ",", "iterations", ")", ";", "c", ".", "init", "(", "txClient", ",", "conn", ".", "getTable", "(", "TABLE", ")", ")", ";", "c", ".", "start", "(", ")", ";", "clients", ".", "add", "(", "c", ")", ";", "}", "for", "(", "Client", "c", ":", "clients", ")", "{", "c", ".", "join", "(", ")", ";", "Closeables", ".", "closeQuietly", "(", "c", ")", ";", "}", "}" ]

[ "Runs", "all", "clients", "and", "waits", "for", "them", "to", "complete", "." ]

[ "public", "void", "close", "(", ")", "{", "try", "{", "if", "(", "conn", "!=", "null", ")", "{", "conn", ".", "close", "(", ")", ";", "}", "}", "catch", "(", "IOException", "ignored", ")", "{", "}", "if", "(", "zkClient", "!=", "null", ")", "{", "zkClient", ".", "stopAndWait", "(", ")", ";", "}", "}" ]

[ "Frees", "up", "the", "underlying", "resources", "common", "to", "all", "clients", "." ]

[ "public", "byte", "[", "]", "readBytes", "(", ")", "throws", "IOException", "{", "int", "toRead", "=", "readInt", "(", ")", ";", "byte", "[", "]", "bytes", "=", "new", "byte", "[", "toRead", "]", ";", "while", "(", "toRead", ">", "0", ")", "{", "int", "byteRead", "=", "input", ".", "read", "(", "bytes", ",", "bytes", ".", "length", "-", "toRead", ",", "toRead", ")", ";", "if", "(", "byteRead", "==", "-", "1", ")", "{", "throw", "new", "EOFException", "(", ")", ";", "}", "toRead", "-=", "byteRead", ";", "}", "return", "bytes", ";", "}" ]

[ "Read", "a", "byte", "sequence", ".", "First", "read", "an", "int", "to", "indicate", "how", "many", "bytes", "to", "read", "then", "that", "many", "bytes", "." ]

[ "@", "Override", "protected", "boolean", "startThreads", "(", ")", "{", "LOGGER", ".", "info", "(", "\"Starting {}\"", ",", "TThreadedSelectorServerWithFix", ".", "class", ".", "getSimpleName", "(", ")", ")", ";", "try", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "args", ".", "selectorThreads", ";", "++", "i", ")", "{", "selectorThreads", ".", "add", "(", "new", "SelectorThread", "(", "args", ".", "acceptQueueSizePerThread", ")", ")", ";", "}", "acceptThread", "=", "new", "AcceptThread", "(", "(", "TNonblockingServerTransport", ")", "serverTransport_", ",", "createSelectorThreadLoadBalancer", "(", "selectorThreads", ")", ")", ";", "stopped_", "=", "false", ";", "for", "(", "SelectorThread", "thread", ":", "selectorThreads", ")", "{", "thread", ".", "start", "(", ")", ";", "}", "acceptThread", ".", "start", "(", ")", ";", "return", "true", ";", "}", "catch", "(", "IOException", "e", ")", "{", "LOGGER", ".", "error", "(", "\"Failed to start threads!\"", ",", "e", ")", ";", "return", "false", ";", "}", "}" ]

[ "Start", "the", "accept", "and", "selector", "threads", "running", "to", "deal", "with", "clients", "." ]

[ "@", "Override", "public", "void", "stop", "(", ")", "{", "stopped_", "=", "true", ";", "// Stop queuing connect attempts asap", "stopListening", "(", ")", ";", "if", "(", "acceptThread", "!=", "null", ")", "{", "acceptThread", ".", "wakeupSelector", "(", ")", ";", "}", "if", "(", "selectorThreads", "!=", "null", ")", "{", "for", "(", "SelectorThread", "thread", ":", "selectorThreads", ")", "{", "if", "(", "thread", "!=", "null", ")", "thread", ".", "wakeupSelector", "(", ")", ";", "}", "}", "}" ]

[ "Stop", "serving", "and", "shut", "everything", "down", "." ]

[ "@", "Override", "protected", "boolean", "requestInvoke", "(", "FrameBuffer", "frameBuffer", ")", "{", "Runnable", "invocation", "=", "getRunnable", "(", "frameBuffer", ")", ";", "if", "(", "invoker", "!=", "null", ")", "{", "try", "{", "invoker", ".", "execute", "(", "invocation", ")", ";", "return", "true", ";", "}", "catch", "(", "RejectedExecutionException", "rx", ")", "{", "LOGGER", ".", "warn", "(", "\"ExecutorService rejected execution!\"", ",", "rx", ")", ";", "return", "false", ";", "}", "}", "else", "{", "// Invoke on the caller's thread", "invocation", ".", "run", "(", ")", ";", "return", "true", ";", "}", "}" ]

[ "We", "override", "the", "standard", "invoke", "method", "here", "to", "queue", "the", "invocation", "for", "invoker", "service", "instead", "of", "immediately", "invoking", ".", "If", "there", "is", "no", "thread", "pool", "handle", "the", "invocation", "inline", "on", "this", "thread" ]

[ "protected", "static", "ExecutorService", "createDefaultExecutor", "(", "Args", "options", ")", "{", "return", "(", "options", ".", "workerThreads", ">", "0", ")", "?", "Executors", ".", "newFixedThreadPool", "(", "options", ".", "workerThreads", ")", ":", "null", ";", "}" ]

[ "Helper", "to", "create", "the", "invoker", "if", "one", "is", "not", "specified" ]

[ "public", "BinaryEncoder", "writeInt", "(", "int", "i", ")", "throws", "IOException", "{", "// Compute the zig-zag value. First double the value and flip the bit if the input is negative.", "int", "val", "=", "(", "i", "<<", "1", ")", "^", "(", "i", ">>", "31", ")", ";", "if", "(", "(", "val", "&", "~", "0x7f", ")", "!=", "0", ")", "{", "output", ".", "write", "(", "0x80", "|", "val", "&", "0x7f", ")", ";", "val", ">>>=", "7", ";", "while", "(", "val", ">", "0x7f", ")", "{", "output", ".", "write", "(", "0x80", "|", "val", "&", "0x7f", ")", ";", "val", ">>>=", "7", ";", "}", "}", "output", ".", "write", "(", "val", ")", ";", "return", "this", ";", "}" ]

[ "write", "a", "single", "int", "value", "." ]

[ "public", "BinaryEncoder", "writeLong", "(", "long", "l", ")", "throws", "IOException", "{", "// Compute the zig-zag value. First double the value and flip the bit if the input is negative.", "long", "val", "=", "(", "l", "<<", "1", ")", "^", "(", "l", ">>", "63", ")", ";", "if", "(", "(", "val", "&", "~", "0x7f", ")", "!=", "0", ")", "{", "output", ".", "write", "(", "(", "int", ")", "(", "0x80", "|", "val", "&", "0x7f", ")", ")", ";", "val", ">>>=", "7", ";", "while", "(", "val", ">", "0x7f", ")", "{", "output", ".", "write", "(", "(", "int", ")", "(", "0x80", "|", "val", "&", "0x7f", ")", ")", ";", "val", ">>>=", "7", ";", "}", "}", "output", ".", "write", "(", "(", "int", ")", "val", ")", ";", "return", "this", ";", "}" ]

[ "write", "a", "single", "long", "int", "value", "." ]

[ "public", "BinaryEncoder", "writeBytes", "(", "byte", "[", "]", "bytes", ")", "throws", "IOException", "{", "writeLong", "(", "bytes", ".", "length", ")", ";", "output", ".", "write", "(", "bytes", ",", "0", ",", "bytes", ".", "length", ")", ";", "return", "this", ";", "}" ]

[ "write", "a", "sequence", "of", "bytes", ".", "First", "writes", "the", "number", "of", "bytes", "as", "an", "int", "then", "the", "bytes", "themselves", "." ]

[ "public", "int", "readMarker", "(", "SequenceFile", ".", "Reader", "reader", ")", "throws", "IOException", "{", "if", "(", "valueBytes", "==", "null", ")", "{", "valueBytes", "=", "reader", ".", "createValueBytes", "(", ")", ";", "}", "rawKey", ".", "reset", "(", ")", ";", "rawValue", ".", "reset", "(", ")", ";", "// valueBytes need not be reset since nextRaw call does it (and it is a private method)", "int", "status", "=", "reader", ".", "nextRaw", "(", "rawKey", ",", "valueBytes", ")", ";", "// if we reach EOF, return -1", "if", "(", "status", "==", "-", "1", ")", "{", "return", "-", "1", ";", "}", "// Check if the marker key is valid and return the count", "if", "(", "isMarkerValid", "(", ")", ")", "{", "valueBytes", ".", "writeUncompressedBytes", "(", "rawValue", ")", ";", "rawValue", ".", "flush", "(", ")", ";", "// rawValue.getData() may return a larger byte array but Ints.fromByteArray will only read the first four bytes", "return", "Ints", ".", "fromByteArray", "(", "rawValue", ".", "getData", "(", ")", ")", ";", "}", "// EOF not reached and marker is not valid, then thrown an IOException since we can't make progress", "throw", "new", "IOException", "(", "String", ".", "format", "(", "\"Invalid key for num entries appended found %s, expected : %s\"", ",", "new", "String", "(", "rawKey", ".", "getData", "(", ")", ")", ",", "TxConstants", ".", "TransactionLog", ".", "NUM_ENTRIES_APPENDED", ")", ")", ";", "}" ]

[ "since", "we", "can", "recover", "without", "any", "consequence" ]

[ "private", "void", "tryInit", "(", ")", "{", "try", "{", "Configuration", "conf", "=", "getSnapshotConfiguration", "(", ")", ";", "if", "(", "conf", "!=", "null", ")", "{", "// Since this is only used for background loading of transaction snapshots, we use the no-op metrics collector,", "// as there are no relevant metrics to report", "this", ".", "storage", "=", "new", "HDFSTransactionStateStorage", "(", "conf", ",", "new", "SnapshotCodecProvider", "(", "conf", ")", ",", "new", "TxMetricsCollector", "(", ")", ")", ";", "this", ".", "storage", ".", "startAndWait", "(", ")", ";", "this", ".", "snapshotRefreshFrequency", "=", "conf", ".", "getLong", "(", "TxConstants", ".", "Manager", ".", "CFG_TX_SNAPSHOT_INTERVAL", ",", "TxConstants", ".", "Manager", ".", "DEFAULT_TX_SNAPSHOT_INTERVAL", ")", "*", "1000", ";", "this", ".", "initialized", "=", "true", ";", "}", "else", "{", "LOG", ".", "info", "(", "\"Could not load configuration\"", ")", ";", "}", "}", "catch", "(", "Exception", "e", ")", "{", "LOG", ".", "info", "(", "\"Failed to initialize TransactionStateCache due to: \"", "+", "e", ".", "getMessage", "(", ")", ")", ";", "}", "}" ]

[ "Try", "to", "initialize", "the", "Configuration", "and", "TransactionStateStorage", "instances", ".", "Obtaining", "the", "Configuration", "may", "fail", "until", "ReactorServiceMain", "has", "been", "started", "." ]

[ "public", "void", "doMain", "(", "final", "String", "[", "]", "args", ")", "throws", "Exception", "{", "final", "CountDownLatch", "shutdownLatch", "=", "new", "CountDownLatch", "(", "1", ")", ";", "Runtime", ".", "getRuntime", "(", ")", ".", "addShutdownHook", "(", "new", "Thread", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "try", "{", "try", "{", "TransactionServiceMain", ".", "this", ".", "stop", "(", ")", ";", "}", "finally", "{", "try", "{", "TransactionServiceMain", ".", "this", ".", "destroy", "(", ")", ";", "}", "finally", "{", "shutdownLatch", ".", "countDown", "(", ")", ";", "}", "}", "}", "catch", "(", "Throwable", "t", ")", "{", "LOG", ".", "error", "(", "\"Exception when shutting down: \"", "+", "t", ".", "getMessage", "(", ")", ",", "t", ")", ";", "}", "}", "}", ")", ";", "init", "(", "args", ")", ";", "start", "(", ")", ";", "shutdownLatch", ".", "await", "(", ")", ";", "}" ]

[ "The", "main", "method", ".", "It", "simply", "call", "methods", "in", "the", "same", "sequence", "as", "if", "the", "program", "is", "started", "by", "jsvc", "." ]

[ "public", "void", "start", "(", ")", "throws", "Exception", "{", "Injector", "injector", "=", "Guice", ".", "createInjector", "(", "new", "ConfigModule", "(", "conf", ")", ",", "new", "ZKModule", "(", ")", ",", "new", "DiscoveryModules", "(", ")", ".", "getDistributedModules", "(", ")", ",", "new", "TransactionModules", "(", ")", ".", "getDistributedModules", "(", ")", ",", "new", "TransactionClientModule", "(", ")", ")", ";", "ZKClientService", "zkClientService", "=", "injector", ".", "getInstance", "(", "ZKClientService", ".", "class", ")", ";", "zkClientService", ".", "startAndWait", "(", ")", ";", "// start a tx server", "txService", "=", "injector", ".", "getInstance", "(", "TransactionService", ".", "class", ")", ";", "try", "{", "LOG", ".", "info", "(", "\"Starting {}\"", ",", "getClass", "(", ")", ".", "getSimpleName", "(", ")", ")", ";", "txService", ".", "startAndWait", "(", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "System", ".", "err", ".", "println", "(", "\"Failed to start service: \"", "+", "e", ".", "getMessage", "(", ")", ")", ";", "}", "}" ]

[ "Invoked", "by", "jsvc", "to", "start", "the", "program", "." ]

[ "public", "void", "stop", "(", ")", "{", "LOG", ".", "info", "(", "\"Stopping {}\"", ",", "getClass", "(", ")", ".", "getSimpleName", "(", ")", ")", ";", "if", "(", "txService", "==", "null", ")", "{", "return", ";", "}", "try", "{", "if", "(", "txService", ".", "isRunning", "(", ")", ")", "{", "txService", ".", "stopAndWait", "(", ")", ";", "}", "}", "catch", "(", "Throwable", "e", ")", "{", "LOG", ".", "error", "(", "\"Failed to shutdown transaction service.\"", ",", "e", ")", ";", "// because shutdown hooks execute concurrently, the logger may be closed already: thus also print it.", "System", ".", "err", ".", "println", "(", "\"Failed to shutdown transaction service: \"", "+", "e", ".", "getMessage", "(", ")", ")", ";", "e", ".", "printStackTrace", "(", "System", ".", "err", ")", ";", "}", "}" ]

[ "Invoked", "by", "jsvc", "to", "stop", "the", "program", "." ]

[ "private", "T", "getOrCreate", "(", ")", "throws", "E", "{", "try", "{", "T", "client", "=", "elements", ".", "poll", "(", ")", ";", "// a client was available, all good. otherwise, create one", "if", "(", "client", "!=", "null", ")", "{", "return", "client", ";", "}", "return", "create", "(", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "// if an exception is thrown after acquiring the semaphore, release the", "// semaphore before propagating the exception", "semaphore", ".", "release", "(", ")", ";", "throw", "e", ";", "}", "}" ]

[ "this", "method", "if", "it", "throws", "any", "exception" ]

[ "private", "static", "boolean", "leq", "(", "int", "a1", ",", "int", "a2", ",", "int", "b1", ",", "int", "b2", ")", "{", "return", "(", "a1", "<", "b1", "||", "(", "a1", "==", "b1", "&&", "a2", "<=", "b2", ")", ")", ";", "}" ]

[ "Lexicographic", "order", "for", "pairs", "." ]

[ "private", "static", "boolean", "leq", "(", "int", "a1", ",", "int", "a2", ",", "int", "a3", ",", "int", "b1", ",", "int", "b2", ",", "int", "b3", ")", "{", "return", "(", "a1", "<", "b1", "||", "(", "a1", "==", "b1", "&&", "leq", "(", "a2", ",", "a3", ",", "b2", ",", "b3", ")", ")", ")", ";", "}" ]

[ "Lexicographic", "order", "for", "triples", "." ]

[ "private", "void", "insSortUpdateRecurse_SaBucket", "(", "int", "leftPtr", ",", "int", "rightPtr", ",", "int", "offset", ",", "int", "q", ")", "{", "int", "rightTmpPtr", "=", "leftPtr", "+", "1", ";", "while", "(", "rightTmpPtr", "<=", "rightPtr", ")", "{", "int", "tempValue", "=", "suffixArray", "[", "rightTmpPtr", "]", ";", "int", "tempHashValue", "=", "sufPtrMap", "[", "suffixArray", "[", "rightTmpPtr", "]", "+", "offset", "]", ";", "int", "leftTmpPtr", "=", "rightTmpPtr", ";", "while", "(", "leftTmpPtr", ">", "leftPtr", "&&", "sufPtrMap", "[", "suffixArray", "[", "leftTmpPtr", "-", "1", "]", "+", "offset", "]", ">", "tempHashValue", ")", "{", "suffixArray", "[", "leftTmpPtr", "]", "=", "suffixArray", "[", "leftTmpPtr", "-", "1", "]", ";", "leftTmpPtr", "--", ";", "}", "suffixArray", "[", "leftTmpPtr", "]", "=", "tempValue", ";", "rightTmpPtr", "++", ";", "}", "updatePtrAndRefineBuckets_SaBucket", "(", "leftPtr", ",", "rightPtr", ",", "offset", ",", "q", ")", ";", "}" ]

[ "Stably", "sorts", "a", "bucket", "at", "a", "refinement", "level", "regarding", "sort", "keys", "that", "are", "bucket", "pointers", "in", "sufPtrMap", "with", "offset", "." ]

[ "private", "void", "computeBucketSize2_SaBucket", "(", "int", "leftPtr", ",", "int", "rightPtr", ",", "int", "offset", ",", "int", "q", ")", "{", "int", "suffix1", "=", "suffixArray", "[", "leftPtr", "]", "+", "offset", ";", "int", "suffix2", "=", "suffixArray", "[", "rightPtr", "]", "+", "offset", ";", "while", "(", "sufPtrMap", "[", "suffix1", "]", "==", "sufPtrMap", "[", "suffix2", "]", ")", "{", "suffix1", "+=", "q", ";", "suffix2", "+=", "q", ";", "}", "if", "(", "sufPtrMap", "[", "suffix1", "]", ">", "sufPtrMap", "[", "suffix2", "]", ")", "{", "int", "tmpSwap", "=", "suffixArray", "[", "leftPtr", "]", ";", "suffixArray", "[", "leftPtr", "]", "=", "suffixArray", "[", "rightPtr", "]", ";", "suffixArray", "[", "rightPtr", "]", "=", "tmpSwap", ";", "}", "sufPtrMap", "[", "suffixArray", "[", "leftPtr", "]", "]", "=", "leftPtr", ";", "sufPtrMap", "[", "suffixArray", "[", "rightPtr", "]", "]", "=", "rightPtr", ";", "}" ]

[ "Completely", "sorts", "buckets", "of", "size", "2", "." ]

[ "private", "int", "computeDiffDepthBucket_SaBucket", "(", "int", "leftPtr", ",", "int", "rightPtr", ",", "int", "offset", ",", "int", "q", ")", "{", "int", "lcp", "=", "offset", ";", "while", "(", "true", ")", "{", "int", "runPtr", "=", "leftPtr", ";", "int", "a", "=", "suffixArray", "[", "rightPtr", "]", ";", "int", "tmpPtr", "=", "sufPtrMap", "[", "a", "+", "lcp", "]", ";", "while", "(", "runPtr", "<", "rightPtr", ")", "{", "if", "(", "sufPtrMap", "[", "suffixArray", "[", "runPtr", "]", "+", "lcp", "]", "!=", "tmpPtr", ")", "{", "return", "lcp", ";", "}", "runPtr", "++", ";", "}", "lcp", "+=", "q", ";", "}", "}" ]

[ "Computes", "about", "the", "LCP", "of", "all", "suffixes", "in", "this", "bucket", ".", "It", "will", "be", "the", "newoffset", "." ]

[ "private", "int", "[", "]", "determineAll_Buckets_Sarray_Sptrmap", "(", "int", "q", ")", "{", "int", "[", "]", "buckets", "=", "determineAll_Buckets_Sarray", "(", "q", ")", ";", "int", "strLen", "=", "length", ";", "sufPtrMap", "=", "new", "int", "[", "strLen", "+", "2", "*", "q", "+", "1", "]", ";", "/* computation of first hashvalue */", "int", "alphabetSize", "=", "alphabet", ".", "size", ";", "int", "mappedUcharArray", "=", "0", ";", "int", "tempPower", "=", "1", ";", "int", "hashCode", "=", "0", ";", "int", "i", ";", "for", "(", "i", "=", "q", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "hashCode", "+=", "seq", "[", "start", "+", "mappedUcharArray", "+", "i", "]", "*", "tempPower", ";", "tempPower", "*=", "alphabetSize", ";", "}", "int", "tempModulo", "=", "kbs_power_Ulong", "(", "alphabetSize", ",", "q", "-", "1", ")", ";", "mappedUcharArray", "+=", "q", ";", "int", "j", ";", "for", "(", "j", "=", "0", ";", "j", "<", "strLen", "-", "1", ";", "j", "++", ")", "{", "sufPtrMap", "[", "j", "]", "=", "(", "buckets", "[", "hashCode", "+", "1", "]", ")", "-", "1", ";", "hashCode", "-=", "(", "seq", "[", "start", "+", "mappedUcharArray", "-", "q", "]", ")", "*", "tempModulo", ";", "hashCode", "*=", "alphabetSize", ";", "hashCode", "+=", "seq", "[", "start", "+", "mappedUcharArray", "]", ";", "mappedUcharArray", "++", ";", "}", "sufPtrMap", "[", "j", "]", "=", "buckets", "[", "hashCode", "]", ";", "/* set the values in sufPtrMap[strLen..strLen+2*d] to [-1, -2, ..., -2*d] */", "int", "beginPtr", "=", "-", "1", ";", "for", "(", "j", "=", "strLen", ";", "j", "<=", "strLen", "+", "2", "*", "q", ";", "j", "++", ")", "{", "sufPtrMap", "[", "j", "]", "=", "beginPtr", "--", ";", "}", "return", "buckets", ";", "}" ]

[ "Constructs", "all", "buckets", "w", ".", "r", ".", "t", ".", "q", "-", "gram", "size", "q", "the", "up", "to", "prefix", "q", "sorted", "suffix", "array", "and", "the", "bucket", "-", "pointer", "table", "." ]

[ "private", "int", "[", "]", "determinePower2Alpha_Buckets_Sarray_Sptrmap", "(", "int", "q", ")", "{", "int", "strLen", "=", "length", ";", "int", "exp2", "=", "kbs_getExp_Ulong", "(", "2", ",", "alphabet", ".", "size", ")", ";", "if", "(", "exp2", "<", "0", ")", "{", "throw", "new", "RuntimeException", "(", "\"value out of bounds\"", ")", ";", "}", "int", "[", "]", "buckets", "=", "determinePower2Alpha_Buckets_Sarray", "(", "q", ")", ";", "this", ".", "sufPtrMap", "=", "new", "int", "[", "strLen", "+", "2", "*", "q", "+", "1", "]", ";", "int", "mappedUcharArray", "=", "0", ";", "int", "hashCode", "=", "0", ";", "int", "j", ";", "for", "(", "j", "=", "0", ";", "j", "<", "q", ";", "j", "++", ")", "{", "hashCode", "=", "hashCode", "<<", "exp2", ";", "hashCode", "+=", "seq", "[", "start", "+", "mappedUcharArray", "+", "j", "]", ";", "}", "int", "tempModulo", "=", "0", ";", "tempModulo", "=", "~", "tempModulo", ";", "tempModulo", "=", "tempModulo", "<<", "(", "exp2", "*", "(", "q", "-", "1", ")", ")", ";", "tempModulo", "=", "~", "tempModulo", ";", "mappedUcharArray", "+=", "q", ";", "for", "(", "j", "=", "0", ";", "j", "<", "strLen", "-", "1", ";", "j", "++", ")", "{", "sufPtrMap", "[", "j", "]", "=", "(", "buckets", "[", "hashCode", "+", "1", "]", ")", "-", "1", ";", "hashCode", "=", "hashCode", "&", "tempModulo", ";", "hashCode", "=", "hashCode", "<<", "exp2", ";", "hashCode", "=", "hashCode", "|", "seq", "[", "start", "+", "mappedUcharArray", "]", ";", "mappedUcharArray", "++", ";", "}", "sufPtrMap", "[", "j", "]", "=", "buckets", "[", "hashCode", "]", ";", "int", "beginPtr", "=", "-", "1", ";", "for", "(", "j", "=", "strLen", ";", "j", "<=", "strLen", "+", "2", "*", "q", ";", "j", "++", ")", "{", "sufPtrMap", "[", "j", "]", "=", "beginPtr", "--", ";", "}", "return", "buckets", ";", "}" ]

[ "Constructs", "all", "buckets", "w", ".", "r", ".", "t", ".", "q", "-", "gram", "size", "q", "the", "up", "to", "prefix", "length", "q", "sorted", "suffix", "array", "and", "the", "bucket", "-", "pointer", "table", "." ]

[ "private", "void", "ssMergeForward", "(", "int", "PA", ",", "int", "first", ",", "int", "middle", ",", "int", "last", ",", "int", "buf", ",", "int", "depth", ")", "{", "// PA, first, middle, last, buf are pointers to SA", "int", "a", ",", "b", ",", "c", ",", "bufend", ";", "// pointers to SA", "int", "t", ",", "r", ";", "bufend", "=", "buf", "+", "(", "middle", "-", "first", ")", "-", "1", ";", "ssBlockSwap", "(", "buf", ",", "first", ",", "middle", "-", "first", ")", ";", "for", "(", "t", "=", "SA", "[", "a", "=", "first", "]", ",", "b", "=", "buf", ",", "c", "=", "middle", ";", ";", ")", "{", "r", "=", "ssCompare", "(", "PA", "+", "SA", "[", "b", "]", ",", "PA", "+", "SA", "[", "c", "]", ",", "depth", ")", ";", "if", "(", "r", "<", "0", ")", "{", "do", "{", "SA", "[", "a", "++", "]", "=", "SA", "[", "b", "]", ";", "if", "(", "bufend", "<=", "b", ")", "{", "SA", "[", "bufend", "]", "=", "t", ";", "return", ";", "}", "SA", "[", "b", "++", "]", "=", "SA", "[", "a", "]", ";", "}", "while", "(", "SA", "[", "b", "]", "<", "0", ")", ";", "}", "else", "if", "(", "r", ">", "0", ")", "{", "do", "{", "SA", "[", "a", "++", "]", "=", "SA", "[", "c", "]", ";", "SA", "[", "c", "++", "]", "=", "SA", "[", "a", "]", ";", "if", "(", "last", "<=", "c", ")", "{", "while", "(", "b", "<", "bufend", ")", "{", "SA", "[", "a", "++", "]", "=", "SA", "[", "b", "]", ";", "SA", "[", "b", "++", "]", "=", "SA", "[", "a", "]", ";", "}", "SA", "[", "a", "]", "=", "SA", "[", "b", "]", ";", "SA", "[", "b", "]", "=", "t", ";", "return", ";", "}", "}", "while", "(", "SA", "[", "c", "]", "<", "0", ")", ";", "}", "else", "{", "SA", "[", "c", "]", "=", "~", "SA", "[", "c", "]", ";", "do", "{", "SA", "[", "a", "++", "]", "=", "SA", "[", "b", "]", ";", "if", "(", "bufend", "<=", "b", ")", "{", "SA", "[", "bufend", "]", "=", "t", ";", "return", ";", "}", "SA", "[", "b", "++", "]", "=", "SA", "[", "a", "]", ";", "}", "while", "(", "SA", "[", "b", "]", "<", "0", ")", ";", "do", "{", "SA", "[", "a", "++", "]", "=", "SA", "[", "c", "]", ";", "SA", "[", "c", "++", "]", "=", "SA", "[", "a", "]", ";", "if", "(", "last", "<=", "c", ")", "{", "while", "(", "b", "<", "bufend", ")", "{", "SA", "[", "a", "++", "]", "=", "SA", "[", "b", "]", ";", "SA", "[", "b", "++", "]", "=", "SA", "[", "a", "]", ";", "}", "SA", "[", "a", "]", "=", "SA", "[", "b", "]", ";", "SA", "[", "b", "]", "=", "t", ";", "return", ";", "}", "}", "while", "(", "SA", "[", "c", "]", "<", "0", ")", ";", "}", "}", "}" ]

[ "Merge", "-", "forward", "with", "internal", "buffer", "." ]

[ "private", "void", "ssInsertionSort", "(", "int", "PA", ",", "int", "first", ",", "int", "last", ",", "int", "depth", ")", "{", "// PA, first, last are pointers in SA", "int", "i", ",", "j", ";", "// pointers in SA", "int", "t", ",", "r", ";", "for", "(", "i", "=", "last", "-", "2", ";", "first", "<=", "i", ";", "--", "i", ")", "{", "for", "(", "t", "=", "SA", "[", "i", "]", ",", "j", "=", "i", "+", "1", ";", "0", "<", "(", "r", "=", "ssCompare", "(", "PA", "+", "t", ",", "PA", "+", "SA", "[", "j", "]", ",", "depth", ")", ")", ";", ")", "{", "do", "{", "SA", "[", "j", "-", "1", "]", "=", "SA", "[", "j", "]", ";", "}", "while", "(", "(", "++", "j", "<", "last", ")", "&&", "(", "SA", "[", "j", "]", "<", "0", ")", ")", ";", "if", "(", "last", "<=", "j", ")", "{", "break", ";", "}", "}", "if", "(", "r", "==", "0", ")", "{", "SA", "[", "j", "]", "=", "~", "SA", "[", "j", "]", ";", "}", "SA", "[", "j", "-", "1", "]", "=", "t", ";", "}", "}" ]

[ "Insertionsort", "for", "small", "size", "groups" ]

[ "private", "int", "ssMedian5", "(", "int", "Td", ",", "int", "PA", ",", "int", "v1", ",", "int", "v2", ",", "int", "v3", ",", "int", "v4", ",", "int", "v5", ")", "{", "int", "t", ";", "if", "(", "T", "[", "start", "+", "Td", "+", "SA", "[", "PA", "+", "SA", "[", "v2", "]", "]", "]", ">", "T", "[", "start", "+", "Td", "+", "SA", "[", "PA", "+", "SA", "[", "v3", "]", "]", "]", ")", "{", "t", "=", "v2", ";", "v2", "=", "v3", ";", "v3", "=", "t", ";", "}", "if", "(", "T", "[", "start", "+", "Td", "+", "SA", "[", "PA", "+", "SA", "[", "v4", "]", "]", "]", ">", "T", "[", "start", "+", "Td", "+", "SA", "[", "PA", "+", "SA", "[", "v5", "]", "]", "]", ")", "{", "t", "=", "v4", ";", "v4", "=", "v5", ";", "v5", "=", "t", ";", "}", "if", "(", "T", "[", "start", "+", "Td", "+", "SA", "[", "PA", "+", "SA", "[", "v2", "]", "]", "]", ">", "T", "[", "start", "+", "Td", "+", "SA", "[", "PA", "+", "SA", "[", "v4", "]", "]", "]", ")", "{", "t", "=", "v2", ";", "v2", "=", "v4", ";", "v4", "=", "t", ";", "t", "=", "v3", ";", "v3", "=", "v5", ";", "v5", "=", "t", ";", "}", "if", "(", "T", "[", "start", "+", "Td", "+", "SA", "[", "PA", "+", "SA", "[", "v1", "]", "]", "]", ">", "T", "[", "start", "+", "Td", "+", "SA", "[", "PA", "+", "SA", "[", "v3", "]", "]", "]", ")", "{", "t", "=", "v1", ";", "v1", "=", "v3", ";", "v3", "=", "t", ";", "}", "if", "(", "T", "[", "start", "+", "Td", "+", "SA", "[", "PA", "+", "SA", "[", "v1", "]", "]", "]", ">", "T", "[", "start", "+", "Td", "+", "SA", "[", "PA", "+", "SA", "[", "v4", "]", "]", "]", ")", "{", "t", "=", "v1", ";", "v1", "=", "v4", ";", "v4", "=", "t", ";", "t", "=", "v3", ";", "v3", "=", "v5", ";", "v5", "=", "t", ";", "}", "if", "(", "T", "[", "start", "+", "Td", "+", "SA", "[", "PA", "+", "SA", "[", "v3", "]", "]", "]", ">", "T", "[", "start", "+", "Td", "+", "SA", "[", "PA", "+", "SA", "[", "v4", "]", "]", "]", ")", "{", "return", "v4", ";", "}", "return", "v3", ";", "}" ]

[ "Returns", "the", "median", "of", "five", "elements" ]

[ "private", "int", "ssPartition", "(", "int", "PA", ",", "int", "first", ",", "int", "last", ",", "int", "depth", ")", "{", "int", "a", ",", "b", ";", "// SA pointer", "int", "t", ";", "for", "(", "a", "=", "first", "-", "1", ",", "b", "=", "last", ";", ";", ")", "{", "for", "(", ";", "(", "++", "a", "<", "b", ")", "&&", "(", "(", "SA", "[", "PA", "+", "SA", "[", "a", "]", "]", "+", "depth", ")", ">=", "(", "SA", "[", "PA", "+", "SA", "[", "a", "]", "+", "1", "]", "+", "1", ")", ")", ";", ")", "{", "SA", "[", "a", "]", "=", "~", "SA", "[", "a", "]", ";", "}", "for", "(", ";", "(", "a", "<", "--", "b", ")", "&&", "(", "(", "SA", "[", "PA", "+", "SA", "[", "b", "]", "]", "+", "depth", ")", "<", "(", "SA", "[", "PA", "+", "SA", "[", "b", "]", "+", "1", "]", "+", "1", ")", ")", ";", ")", "{", "}", "if", "(", "b", "<=", "a", ")", "{", "break", ";", "}", "t", "=", "~", "SA", "[", "b", "]", ";", "SA", "[", "b", "]", "=", "SA", "[", "a", "]", ";", "SA", "[", "a", "]", "=", "t", ";", "}", "if", "(", "first", "<", "a", ")", "{", "SA", "[", "first", "]", "=", "~", "SA", "[", "first", "]", ";", "}", "return", "a", ";", "}" ]

[ "Binary", "partition", "for", "substrings", "." ]

[ "private", "void", "ssHeapSort", "(", "int", "Td", ",", "int", "PA", ",", "int", "sa", ",", "int", "size", ")", "{", "int", "i", ",", "m", ",", "t", ";", "m", "=", "size", ";", "if", "(", "(", "size", "%", "2", ")", "==", "0", ")", "{", "m", "--", ";", "if", "(", "T", "[", "start", "+", "Td", "+", "SA", "[", "PA", "+", "SA", "[", "sa", "+", "(", "m", "/", "2", ")", "]", "]", "]", "<", "T", "[", "start", "+", "Td", "+", "SA", "[", "PA", "+", "SA", "[", "sa", "+", "m", "]", "]", "]", ")", "{", "swapInSA", "(", "sa", "+", "m", ",", "sa", "+", "(", "m", "/", "2", ")", ")", ";", "}", "}", "for", "(", "i", "=", "m", "/", "2", "-", "1", ";", "0", "<=", "i", ";", "--", "i", ")", "{", "ssFixDown", "(", "Td", ",", "PA", ",", "sa", ",", "i", ",", "m", ")", ";", "}", "if", "(", "(", "size", "%", "2", ")", "==", "0", ")", "{", "swapInSA", "(", "sa", ",", "sa", "+", "m", ")", ";", "ssFixDown", "(", "Td", ",", "PA", ",", "sa", ",", "0", ",", "m", ")", ";", "}", "for", "(", "i", "=", "m", "-", "1", ";", "0", "<", "i", ";", "--", "i", ")", "{", "t", "=", "SA", "[", "sa", "]", ";", "SA", "[", "sa", "]", "=", "SA", "[", "sa", "+", "i", "]", ";", "ssFixDown", "(", "Td", ",", "PA", ",", "sa", ",", "0", ",", "i", ")", ";", "SA", "[", "sa", "+", "i", "]", "=", "t", ";", "}", "}" ]

[ "Simple", "top", "-", "down", "heapsort", "." ]

[ "private", "void", "trSort", "(", "int", "ISA", ",", "int", "n", ",", "int", "depth", ")", "{", "TRBudget", "budget", "=", "new", "TRBudget", "(", "trIlg", "(", "n", ")", "*", "2", "/", "3", ",", "n", ")", ";", "int", "ISAd", ";", "int", "first", ",", "last", ";", "// SA pointers", "int", "t", ",", "skip", ",", "unsorted", ";", "for", "(", "ISAd", "=", "ISA", "+", "depth", ";", "-", "n", "<", "SA", "[", "0", "]", ";", "ISAd", "+=", "ISAd", "-", "ISA", ")", "{", "first", "=", "0", ";", "skip", "=", "0", ";", "unsorted", "=", "0", ";", "do", "{", "if", "(", "(", "t", "=", "SA", "[", "first", "]", ")", "<", "0", ")", "{", "first", "-=", "t", ";", "skip", "+=", "t", ";", "}", "else", "{", "if", "(", "skip", "!=", "0", ")", "{", "SA", "[", "first", "+", "skip", "]", "=", "skip", ";", "skip", "=", "0", ";", "}", "last", "=", "SA", "[", "ISA", "+", "t", "]", "+", "1", ";", "if", "(", "1", "<", "(", "last", "-", "first", ")", ")", "{", "budget", ".", "count", "=", "0", ";", "trIntroSort", "(", "ISA", ",", "ISAd", ",", "first", ",", "last", ",", "budget", ")", ";", "if", "(", "budget", ".", "count", "!=", "0", ")", "{", "unsorted", "+=", "budget", ".", "count", ";", "}", "else", "{", "skip", "=", "first", "-", "last", ";", "}", "}", "else", "if", "(", "(", "last", "-", "first", ")", "==", "1", ")", "{", "skip", "=", "-", "1", ";", "}", "first", "=", "last", ";", "}", "}", "while", "(", "first", "<", "n", ")", ";", "if", "(", "skip", "!=", "0", ")", "{", "SA", "[", "first", "+", "skip", "]", "=", "skip", ";", "}", "if", "(", "unsorted", "==", "0", ")", "{", "break", ";", "}", "}", "}" ]

[ "Tandem", "repeat", "sort" ]

[ "private", "int", "trMedian5", "(", "int", "ISAd", ",", "int", "v1", ",", "int", "v2", ",", "int", "v3", ",", "int", "v4", ",", "int", "v5", ")", "{", "int", "t", ";", "if", "(", "SA", "[", "ISAd", "+", "SA", "[", "v2", "]", "]", ">", "SA", "[", "ISAd", "+", "SA", "[", "v3", "]", "]", ")", "{", "t", "=", "v2", ";", "v2", "=", "v3", ";", "v3", "=", "t", ";", "}", "if", "(", "SA", "[", "ISAd", "+", "SA", "[", "v4", "]", "]", ">", "SA", "[", "ISAd", "+", "SA", "[", "v5", "]", "]", ")", "{", "t", "=", "v4", ";", "v4", "=", "v5", ";", "v5", "=", "t", ";", "}", "if", "(", "SA", "[", "ISAd", "+", "SA", "[", "v2", "]", "]", ">", "SA", "[", "ISAd", "+", "SA", "[", "v4", "]", "]", ")", "{", "t", "=", "v2", ";", "v2", "=", "v4", ";", "v4", "=", "t", ";", "t", "=", "v3", ";", "v3", "=", "v5", ";", "v5", "=", "t", ";", "}", "if", "(", "SA", "[", "ISAd", "+", "SA", "[", "v1", "]", "]", ">", "SA", "[", "ISAd", "+", "SA", "[", "v3", "]", "]", ")", "{", "t", "=", "v1", ";", "v1", "=", "v3", ";", "v3", "=", "t", ";", "}", "if", "(", "SA", "[", "ISAd", "+", "SA", "[", "v1", "]", "]", ">", "SA", "[", "ISAd", "+", "SA", "[", "v4", "]", "]", ")", "{", "t", "=", "v1", ";", "v1", "=", "v4", ";", "v4", "=", "t", ";", "t", "=", "v3", ";", "v3", "=", "v5", ";", "v5", "=", "t", ";", "}", "if", "(", "SA", "[", "ISAd", "+", "SA", "[", "v3", "]", "]", ">", "SA", "[", "ISAd", "+", "SA", "[", "v4", "]", "]", ")", "{", "return", "v4", ";", "}", "return", "v3", ";", "}" ]

[ "Returns", "the", "median", "of", "five", "elements", "." ]

[ "private", "void", "trCopy", "(", "int", "ISA", ",", "int", "first", ",", "int", "a", ",", "int", "b", ",", "int", "last", ",", "int", "depth", ")", "{", "int", "c", ",", "d", ",", "e", ";", "// ptr", "int", "s", ",", "v", ";", "v", "=", "b", "-", "1", ";", "for", "(", "c", "=", "first", ",", "d", "=", "a", "-", "1", ";", "c", "<=", "d", ";", "++", "c", ")", "{", "s", "=", "SA", "[", "c", "]", "-", "depth", ";", "if", "(", "(", "0", "<=", "s", ")", "&&", "(", "SA", "[", "ISA", "+", "s", "]", "==", "v", ")", ")", "{", "SA", "[", "++", "d", "]", "=", "s", ";", "SA", "[", "ISA", "+", "s", "]", "=", "d", ";", "}", "}", "for", "(", "c", "=", "last", "-", "1", ",", "e", "=", "d", "+", "1", ",", "d", "=", "b", ";", "e", "<", "d", ";", "--", "c", ")", "{", "s", "=", "SA", "[", "c", "]", "-", "depth", ";", "if", "(", "(", "0", "<=", "s", ")", "&&", "(", "SA", "[", "ISA", "+", "s", "]", "==", "v", ")", ")", "{", "SA", "[", "--", "d", "]", "=", "s", ";", "SA", "[", "ISA", "+", "s", "]", "=", "d", ";", "}", "}", "}" ]

[ "sort", "suffixes", "of", "middle", "partition", "by", "using", "sorted", "order", "of", "suffixes", "of", "left", "and", "right", "partition", "." ]

[ "void", "add", "(", "S", "sequence", ")", "{", "for", "(", "I", "item", ":", "sequence", ")", "{", "masterSequence", ".", "add", "(", "item", ")", ";", "}", "SequenceTerminal", "<", "S", ">", "terminal", "=", "new", "SequenceTerminal", "<>", "(", "sequence", ")", ";", "masterSequence", ".", "add", "(", "terminal", ")", ";", "}" ]

[ "Adds", "a", "Sequence", "to", "the", "suffix", "tree", "." ]

[ "@", "Override", "public", "Iterator", "<", "Object", ">", "iterator", "(", ")", "{", "return", "new", "Iterator", "<", "Object", ">", "(", ")", "{", "int", "currentPosition", "=", "0", ";", "@", "Override", "public", "boolean", "hasNext", "(", ")", "{", "return", "masterSequence", ".", "size", "(", ")", ">", "currentPosition", ";", "}", "@", "Override", "public", "Object", "next", "(", ")", "{", "if", "(", "currentPosition", "<=", "masterSequence", ".", "size", "(", ")", ")", "return", "masterSequence", ".", "get", "(", "currentPosition", "++", ")", ";", "return", "null", ";", "}", "@", "Override", "public", "void", "remove", "(", ")", "{", "throw", "new", "UnsupportedOperationException", "(", "\"Remove is not supported.\"", ")", ";", "}", "}", ";", "}" ]

[ "Retrieves", "an", "iterator", "for", "the", "sequence", "." ]

[ "void", "insert", "(", "Suffix", "<", "T", ",", "S", ">", "suffix", ",", "ActivePoint", "<", "T", ",", "S", ">", "activePoint", ")", "{", "Object", "item", "=", "suffix", ".", "getEndItem", "(", ")", ";", "Object", "nextItem", "=", "getItemAt", "(", "activePoint", ".", "getLength", "(", ")", ")", ";", "if", "(", "item", ".", "equals", "(", "nextItem", ")", ")", "{", "activePoint", ".", "incrementLength", "(", ")", ";", "}", "else", "{", "split", "(", "suffix", ",", "activePoint", ")", ";", "suffix", ".", "decrement", "(", ")", ";", "activePoint", ".", "updateAfterInsert", "(", "suffix", ")", ";", "if", "(", "suffix", ".", "isEmpty", "(", ")", ")", "{", "}", "else", "tree", ".", "insert", "(", "suffix", ")", ";", "}", "}" ]

[ "Insert", "the", "given", "suffix", "at", "the", "supplied", "active", "point", "." ]

[ "private", "void", "split", "(", "Suffix", "<", "T", ",", "S", ">", "suffix", ",", "ActivePoint", "<", "T", ",", "S", ">", "activePoint", ")", "{", "Node", "<", "T", ",", "S", ">", "breakNode", "=", "new", "Node", "<>", "(", "this", ",", "sequence", ",", "tree", ")", ";", "Edge", "<", "T", ",", "S", ">", "newEdge", "=", "new", "Edge", "<>", "(", "suffix", ".", "getEndPosition", "(", ")", "-", "1", ",", "breakNode", ",", "sequence", ",", "tree", ")", ";", "breakNode", ".", "insert", "(", "newEdge", ")", ";", "Edge", "<", "T", ",", "S", ">", "oldEdge", "=", "new", "Edge", "<>", "(", "start", "+", "activePoint", ".", "getLength", "(", ")", ",", "breakNode", ",", "sequence", ",", "tree", ")", ";", "oldEdge", ".", "end", "=", "end", ";", "oldEdge", ".", "terminal", "=", "this", ".", "terminal", ";", "breakNode", ".", "insert", "(", "oldEdge", ")", ";", "this", ".", "terminal", "=", "breakNode", ";", "end", "=", "start", "+", "activePoint", ".", "getLength", "(", ")", ";", "tree", ".", "setSuffixLink", "(", "breakNode", ")", ";", "tree", ".", "incrementInsertCount", "(", ")", ";", "}" ]

[ "Splits", "the", "edge", "to", "enable", "the", "insertion", "of", "supplied", "suffix", "at", "the", "supplied", "active", "point", "." ]

[ "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "T", "getItemAt", "(", "int", "position", ")", "{", "if", "(", "position", ">", "getLength", "(", ")", ")", "throw", "new", "IllegalArgumentException", "(", "\"Index \"", "+", "position", "+", "\" is greater than \"", "+", "getLength", "(", ")", "+", "\" - the length of this edge.\"", ")", ";", "return", "(", "T", ")", "sequence", ".", "getItem", "(", "start", "+", "position", ")", ";", "}" ]

[ "Retrieves", "the", "item", "at", "given", "position", "within", "the", "current", "edge", "." ]

[ "public", "Iterator", "<", "T", ">", "iterator", "(", ")", "{", "return", "new", "Iterator", "<", "T", ">", "(", ")", "{", "private", "int", "currentPosition", "=", "start", ";", "private", "boolean", "hasNext", "=", "true", ";", "public", "boolean", "hasNext", "(", ")", "{", "return", "hasNext", ";", "}", "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "public", "T", "next", "(", ")", "{", "if", "(", "end", "==", "-", "1", ")", "hasNext", "=", "!", "sequence", ".", "getItem", "(", "currentPosition", ")", ".", "getClass", "(", ")", ".", "equals", "(", "SequenceTerminal", ".", "class", ")", ";", "else", "hasNext", "=", "currentPosition", "<", "getEnd", "(", ")", "-", "1", ";", "return", "(", "T", ")", "sequence", ".", "getItem", "(", "currentPosition", "++", ")", ";", "}", "public", "void", "remove", "(", ")", "{", "throw", "new", "UnsupportedOperationException", "(", "\"The remove method is not supported.\"", ")", ";", "}", "}", ";", "}" ]

[ "Retrieves", "an", "iterator", "that", "steps", "over", "the", "items", "in", "this", "edge", "." ]

[ "public", "boolean", "isCompetitor", "(", "Island", "isl", ")", "{", "for", "(", "Coordinate", "c", ":", "isl", ")", "{", "for", "(", "Coordinate", "d", ":", "islandCoordinates", ")", "{", "if", "(", "c", ".", "sameColumn", "(", "d", ")", "||", "c", ".", "sameRow", "(", "d", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Two", "islands", "are", "competitors", "if", "there", "is", "a", "horizontal", "or", "vertical", "line", "which", "goes", "through", "both", "islands" ]

[ "public", "IntStream", "getAllOccurrencesAsRanges", "(", ")", "{", "IntStream", "result", "=", "IntStream", ".", "empty", "(", ")", ";", "// with/or without end", "for", "(", "int", "i", "=", "start", ";", "i", "<", "end", ";", "i", "++", ")", "{", "// every i is one occurrence", "int", "token_position", "=", "tokenIndex", ".", "suffix_array", "[", "i", "]", ";", "IntStream", "range", "=", "IntStream", ".", "range", "(", "token_position", ",", "token_position", "+", "length", ")", ";", "result", "=", "IntStream", ".", "concat", "(", "result", ",", "range", ")", ";", "}", "return", "result", ";", "}" ]

[ "transform", "lcp", "interval", "into", "int", "stream", "range" ]

[ "private", "void", "select_sort_split", "(", "int", "p", ",", "int", "n", ")", "{", "int", "pa", ",", "pb", ",", "pi", ",", "pn", ";", "int", "f", ",", "v", ";", "pa", "=", "p", ";", "/* pa is start of group being picked out. */", "pn", "=", "p", "+", "n", "-", "1", ";", "/* pn is last position of subarray. */", "while", "(", "pa", "<", "pn", ")", "{", "for", "(", "pi", "=", "pb", "=", "pa", "+", "1", ",", "f", "=", "KEY", "(", "pa", ")", ";", "pi", "<=", "pn", ";", "++", "pi", ")", "if", "(", "(", "v", "=", "KEY", "(", "pi", ")", ")", "<", "f", ")", "{", "f", "=", "v", ";", "/* f is smallest key found. */", "SWAP", "(", "pi", ",", "pa", ")", ";", "/* place smallest element at beginning. */", "pb", "=", "pa", "+", "1", ";", "/* pb is position for elements equal to f. */", "}", "else", "if", "(", "v", "==", "f", ")", "{", "/* if equal to smallest key. */", "SWAP", "(", "pi", ",", "pb", ")", ";", "/* place next to other smallest elements. */", "++", "pb", ";", "}", "update_group", "(", "pa", ",", "pb", "-", "1", ")", ";", "/* update group values for new group. */", "pa", "=", "pb", ";", "/* continue sorting rest of the subarray. */", "}", "if", "(", "pa", "==", "pn", ")", "{", "/* check if last part is single element. */", "V", "[", "start", "+", "I", "[", "pa", "]", "]", "=", "pa", ";", "I", "[", "pa", "]", "=", "-", "1", ";", "/* sorted group. */", "}", "}" ]

[ "Quadratic", "sorting", "method", "to", "use", "for", "small", "subarrays", ".", "To", "be", "able", "to", "update", "group", "numbers", "consistently", "a", "variant", "of", "selection", "sorting", "is", "used", "." ]

[ "public", "static", "SuffixData", "createWithLCP", "(", "CharSequence", "s", ",", "ISuffixArrayBuilder", "builder", ")", "{", "final", "CharSequenceAdapter", "adapter", "=", "new", "CharSequenceAdapter", "(", "builder", ")", ";", "final", "int", "[", "]", "sa", "=", "adapter", ".", "buildSuffixArray", "(", "s", ")", ";", "final", "int", "[", "]", "lcp", "=", "computeLCP", "(", "adapter", ".", "input", ",", "0", ",", "s", ".", "length", "(", ")", ",", "sa", ")", ";", "return", "new", "SuffixData", "(", "sa", ",", "lcp", ")", ";", "}" ]

[ "Create", "a", "suffix", "array", "and", "an", "LCP", "array", "for", "a", "given", "character", "sequence", "use", "the", "given", "algorithm", "for", "building", "the", "suffix", "array", "." ]

[ "public", "static", "SuffixData", "createWithLCP", "(", "int", "[", "]", "input", ",", "int", "start", ",", "int", "length", ")", "{", "final", "ISuffixArrayBuilder", "builder", "=", "new", "DensePositiveDecorator", "(", "new", "ExtraTrailingCellsDecorator", "(", "defaultAlgorithm", "(", ")", ",", "3", ")", ")", ";", "return", "createWithLCP", "(", "input", ",", "start", ",", "length", ",", "builder", ")", ";", "}" ]

[ "Create", "a", "suffix", "array", "and", "an", "LCP", "array", "for", "a", "given", "input", "sequence", "of", "symbols", "." ]

[ "public", "static", "SuffixData", "createWithLCP", "(", "int", "[", "]", "input", ",", "int", "start", ",", "int", "length", ",", "ISuffixArrayBuilder", "builder", ")", "{", "final", "int", "[", "]", "sa", "=", "builder", ".", "buildSuffixArray", "(", "input", ",", "start", ",", "length", ")", ";", "final", "int", "[", "]", "lcp", "=", "computeLCP", "(", "input", ",", "start", ",", "length", ",", "sa", ")", ";", "return", "new", "SuffixData", "(", "sa", ",", "lcp", ")", ";", "}" ]

[ "Create", "a", "suffix", "array", "and", "an", "LCP", "array", "for", "a", "given", "input", "sequence", "of", "symbols", "and", "a", "custom", "suffix", "array", "building", "strategy", "." ]

[ "public", "static", "<", "T", ">", "SuffixData", "createWithLCP", "(", "T", "[", "]", "input", ",", "ISuffixArrayBuilder", "builder", ",", "Comparator", "<", "?", "super", "T", ">", "comparator", ")", "{", "final", "GenericArrayAdapter", "adapter", "=", "new", "GenericArrayAdapter", "(", "builder", ",", "comparator", ")", ";", "final", "int", "[", "]", "sa", "=", "adapter", ".", "buildSuffixArray", "(", "input", ")", ";", "final", "int", "[", "]", "lcp", "=", "computeLCP", "(", "adapter", ".", "input", ",", "0", ",", "input", ".", "length", ",", "sa", ")", ";", "return", "new", "SuffixData", "(", "sa", ",", "lcp", ")", ";", "}" ]

[ "Create", "a", "suffix", "array", "and", "an", "LCP", "array", "for", "a", "given", "generic", "array", "and", "a", "custom", "suffix", "array", "building", "strategy", "using", "the", "given", "T", "object", "comparator", "." ]

[ "static", "int", "max", "(", "int", "[", "]", "input", ",", "int", "start", ",", "int", "length", ")", "{", "assert", "length", ">=", "1", ";", "int", "max", "=", "input", "[", "start", "]", ";", "for", "(", "int", "i", "=", "length", "-", "2", ",", "index", "=", "start", "+", "1", ";", "i", ">=", "0", ";", "i", "--", ",", "index", "++", ")", "{", "final", "int", "v", "=", "input", "[", "index", "]", ";", "if", "(", "v", ">", "max", ")", "{", "max", "=", "v", ";", "}", "}", "return", "max", ";", "}" ]

[ "Determine", "the", "maximum", "value", "in", "a", "slice", "of", "an", "array", "." ]

[ "static", "int", "min", "(", "int", "[", "]", "input", ",", "int", "start", ",", "int", "length", ")", "{", "assert", "length", ">=", "1", ";", "int", "min", "=", "input", "[", "start", "]", ";", "for", "(", "int", "i", "=", "length", "-", "2", ",", "index", "=", "start", "+", "1", ";", "i", ">=", "0", ";", "i", "--", ",", "index", "++", ")", "{", "final", "int", "v", "=", "input", "[", "index", "]", ";", "if", "(", "v", "<", "min", ")", "{", "min", "=", "v", ";", "}", "}", "return", "min", ";", "}" ]

[ "Determine", "the", "minimum", "value", "in", "a", "slice", "of", "an", "array", "." ]

[ "static", "MinMax", "minmax", "(", "int", "[", "]", "input", ",", "final", "int", "start", ",", "final", "int", "length", ")", "{", "int", "max", "=", "input", "[", "start", "]", ";", "int", "min", "=", "max", ";", "for", "(", "int", "i", "=", "length", "-", "2", ",", "index", "=", "start", "+", "1", ";", "i", ">=", "0", ";", "i", "--", ",", "index", "++", ")", "{", "final", "int", "v", "=", "input", "[", "index", "]", ";", "if", "(", "v", ">", "max", ")", "{", "max", "=", "v", ";", "}", "if", "(", "v", "<", "min", ")", "{", "min", "=", "v", ";", "}", "}", "return", "new", "MinMax", "(", "min", ",", "max", ")", ";", "}" ]

[ "Calculate", "minimum", "and", "maximum", "value", "for", "a", "slice", "of", "an", "array", "." ]

[ "public", "Object", "getItemXFromEnd", "(", "int", "distanceFromEnd", ")", "{", "if", "(", "(", "end", "-", "(", "distanceFromEnd", ")", ")", "<", "start", ")", "{", "throw", "new", "IllegalArgumentException", "(", "distanceFromEnd", "+", "\" extends before the start of this suffix: \"", ")", ";", "}", "return", "sequence", ".", "getItem", "(", "end", "-", "distanceFromEnd", ")", ";", "}" ]

[ "Retrieves", "the", "item", "the", "given", "distance", "from", "the", "end", "of", "the", "suffix", "." ]

[ "public", "String", "toHtml", "(", "Archipelago", "arch", ")", "{", "int", "mat", "[", "]", "=", "new", "int", "[", "rowNum", "(", ")", "]", ";", "for", "(", "Island", "isl", ":", "arch", ".", "getIslands", "(", ")", ")", "{", "for", "(", "Coordinate", "c", ":", "isl", ")", "{", "mat", "[", "c", ".", "row", "]", "=", "c", ".", "column", ";", "}", "}", "StringBuilder", "result", "=", "new", "StringBuilder", "(", "\"<table>\\n<tr><td></td>\\n\"", ")", ";", "ArrayList", "<", "String", ">", "colLabels", "=", "columnLabels", "(", ")", ";", "for", "(", "String", "cLabel", ":", "colLabels", ")", "{", "result", ".", "append", "(", "\"<td>\"", ")", ".", "append", "(", "cLabel", ")", ".", "append", "(", "\"</td>\"", ")", ";", "}", "result", ".", "append", "(", "\"</tr>\\n\"", ")", ";", "ArrayList", "<", "String", ">", "rLabels", "=", "rowLabels", "(", ")", ";", "int", "row", "=", "0", ";", "for", "(", "String", "label", ":", "rLabels", ")", "{", "result", ".", "append", "(", "\"<tr><td>\"", ")", ".", "append", "(", "label", ")", ".", "append", "(", "\"</td>\"", ")", ";", "if", "(", "mat", "[", "row", "]", ">", "0", ")", "{", "result", ".", "append", "(", "\"<td colspan=\\\"\"", ")", ".", "append", "(", "mat", "[", "row", "]", ")", ".", "append", "(", "\"\\\"></td>\"", ")", ".", "append", "(", "\"<td BGCOLOR=\\\"lightgreen\\\">M</td>\"", ")", ";", "}", "result", ".", "append", "(", "\"</tr>\\n\"", ")", ";", "row", "++", ";", "}", "result", ".", "append", "(", "\"</table>\"", ")", ";", "return", "result", ".", "toString", "(", ")", ";", "}" ]

[ "arch", "=", "preferred", "matches" ]

[ "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "void", "insert", "(", "Suffix", "<", "T", ",", "S", ">", "suffix", ",", "ActivePoint", "<", "T", ",", "S", ">", "activePoint", ")", "{", "Object", "item", "=", "suffix", ".", "getEndItem", "(", ")", ";", "if", "(", "edges", ".", "containsKey", "(", "item", ")", ")", "{", "if", "(", "tree", ".", "isNotFirstInsert", "(", ")", "&&", "activePoint", ".", "getNode", "(", ")", "!=", "tree", ".", "getRoot", "(", ")", ")", "tree", ".", "setSuffixLink", "(", "activePoint", ".", "getNode", "(", ")", ")", ";", "activePoint", ".", "setEdge", "(", "edges", ".", "get", "(", "item", ")", ")", ";", "activePoint", ".", "incrementLength", "(", ")", ";", "}", "else", "{", "saveSequenceTerminal", "(", "item", ")", ";", "Edge", "<", "T", ",", "S", ">", "newEdge", "=", "new", "Edge", "<>", "(", "suffix", ".", "getEndPosition", "(", ")", "-", "1", ",", "this", ",", "sequence", ",", "tree", ")", ";", "edges", ".", "put", "(", "(", "T", ")", "suffix", ".", "getEndItem", "(", ")", ",", "newEdge", ")", ";", "suffix", ".", "decrement", "(", ")", ";", "activePoint", ".", "updateAfterInsert", "(", "suffix", ")", ";", "if", "(", "tree", ".", "isNotFirstInsert", "(", ")", "&&", "!", "this", ".", "equals", "(", "tree", ".", "getRoot", "(", ")", ")", ")", "{", "tree", ".", "getLastNodeInserted", "(", ")", ".", "setSuffixLink", "(", "this", ")", ";", "}", "if", "(", "suffix", ".", "isEmpty", "(", ")", ")", "{", "}", "else", "tree", ".", "insert", "(", "suffix", ")", ";", "}", "}" ]

[ "Inserts", "the", "suffix", "at", "the", "given", "active", "point", "." ]

[ "void", "insert", "(", "Edge", "<", "T", ",", "S", ">", "edge", ")", "{", "if", "(", "edges", ".", "containsKey", "(", "edge", ".", "getStartItem", "(", ")", ")", ")", "throw", "new", "IllegalArgumentException", "(", "\"Item \"", "+", "edge", ".", "getStartItem", "(", ")", "+", "\" already exists in node \"", "+", "toString", "(", ")", ")", ";", "edges", ".", "put", "(", "edge", ".", "getStartItem", "(", ")", ",", "edge", ")", ";", "}" ]

[ "Inserts", "the", "given", "edge", "as", "a", "child", "of", "this", "node", ".", "The", "edge", "must", "not", "already", "exist", "as", "child", "or", "an", "IllegalArgumentException", "will", "be", "thrown", "." ]

[ "static", "<", "I", ",", "S", "extends", "Iterable", "<", "I", ">", ">", "Object", "[", "]", "addTerminalToSequence", "(", "S", "sequence", ",", "SequenceTerminal", "<", "S", ">", "terminatingObject", ")", "{", "ArrayList", "<", "Object", ">", "list", "=", "new", "ArrayList", "<>", "(", ")", ";", "for", "(", "I", "item", ":", "sequence", ")", "list", ".", "(", "item", ")", ";", "Object", "[", "]", "newSequence", "=", "new", "Object", "[", "list", ".", "size", "(", ")", "+", "1", "]", ";", "int", "i", "=", "0", ";", "for", "(", ";", "i", "<", "list", ".", "size", "(", ")", ";", "i", "++", ")", "newSequence", "[", "i", "]", "=", "list", ".", "get", "(", "i", ")", ";", "newSequence", "[", "i", "]", "=", "terminatingObject", ";", "return", "newSequence", ";", "}" ]

[ "Appends", "a", "SequenceTerminal", "element", "to", "a", "supplied", "array", "." ]

[ "static", "<", "T", ",", "S", "extends", "Iterable", "<", "T", ">", ">", "String", "printTreeForGraphViz", "(", "SuffixTree", "<", "T", ",", "S", ">", "tree", ",", "boolean", "printSuffixLinks", ")", "{", "LinkedList", "<", "Node", "<", "T", ",", "S", ">", ">", "stack", "=", "new", "LinkedList", "<>", "(", ")", ";", "stack", ".", "add", "(", "tree", ".", "getRoot", "(", ")", ")", ";", "Map", "<", "Node", "<", "T", ",", "S", ">", ",", "Integer", ">", "nodeMap", "=", "new", "HashMap", "<>", "(", ")", ";", "nodeMap", ".", "put", "(", "tree", ".", "getRoot", "(", ")", ",", "0", ")", ";", "int", "nodeId", "=", "1", ";", "StringBuilder", "sb", "=", "new", "StringBuilder", "(", "\"\\ndigraph suffixTree{\\n node [shape=circle, label=\\\"\\\", fixedsize=true, width=0.1, height=0.1]\\n\"", ")", ";", "while", "(", "stack", ".", "size", "(", ")", ">", "0", ")", "{", "LinkedList", "<", "Node", "<", "T", ",", "S", ">", ">", "childNodes", "=", "new", "LinkedList", "<>", "(", ")", ";", "for", "(", "Node", "<", "T", ",", "S", ">", "node", ":", "stack", ")", "{", "// List<Edge> edges = node.getEdges();", "for", "(", "Edge", "<", "T", ",", "S", ">", "edge", ":", "node", ")", "{", "int", "id", "=", "nodeId", "++", ";", "if", "(", "edge", ".", "isTerminating", "(", ")", ")", "{", "childNodes", ".", "push", "(", "edge", ".", "getTerminal", "(", ")", ")", ";", "nodeMap", ".", "put", "(", "edge", ".", "getTerminal", "(", ")", ",", "id", ")", ";", "}", "sb", ".", "append", "(", "nodeMap", ".", "get", "(", "node", ")", ")", ".", "append", "(", "\" -> \"", ")", ".", "append", "(", "id", ")", ".", "append", "(", "\" [label=\\\"\"", ")", ";", "for", "(", "T", "item", ":", "edge", ")", "{", "//if(item != null)", "sb", ".", "append", "(", "item", ".", "toString", "(", ")", ")", ";", "}", "sb", ".", "append", "(", "\"\\\"];\\n\"", ")", ";", "}", "}", "stack", "=", "childNodes", ";", "}", "if", "(", "printSuffixLinks", ")", "{", "// loop again to find all suffix links.", "sb", ".", "append", "(", "\"edge [color=red]\\n\"", ")", ";", "for", "(", "Map", ".", "Entry", "<", "Node", "<", "T", ",", "S", ">", ",", "Integer", ">", "entry", ":", "nodeMap", ".", "entrySet", "(", ")", ")", "{", "Node", "n1", "=", "entry", ".", "getKey", "(", ")", ";", "int", "id1", "=", "entry", ".", "getValue", "(", ")", ";", "if", "(", "n1", ".", "hasSuffixLink", "(", ")", ")", "{", "Node", "n2", "=", "n1", ".", "getSuffixLink", "(", ")", ";", "Integer", "id2", "=", "nodeMap", ".", "get", "(", "n2", ")", ";", "// if(id2 != null)", "sb", ".", "append", "(", "id1", ")", ".", "append", "(", "\" -> \"", ")", ".", "append", "(", "id2", ")", ".", "append", "(", "\" ;\\n\"", ")", ";", "}", "}", "}", "sb", ".", "append", "(", "\"}\"", ")", ";", "return", "(", "sb", ".", "toString", "(", ")", ")", ";", "}" ]

[ "Generates", "a", ".", "dot", "format", "string", "for", "visualizing", "a", "suffix", "tree", "." ]

[ "public", "int", "[", "]", "buildSuffixArray", "(", "CharSequence", "sequence", ")", "{", "/*\n * Allocate slightly more space, some suffix construction strategies need it and\n * we don't want to waste space for multiple symbol mappings.\n */", "this", ".", "input", "=", "new", "int", "[", "sequence", ".", "length", "(", ")", "+", "SuffixArrays", ".", "MAX_EXTRA_TRAILING_SPACE", "]", ";", "for", "(", "int", "i", "=", "sequence", ".", "length", "(", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "input", "[", "i", "]", "=", "sequence", ".", "charAt", "(", "i", ")", ";", "}", "final", "int", "start", "=", "0", ";", "final", "int", "length", "=", "sequence", ".", "length", "(", ")", ";", "final", "ISymbolMapper", "mapper", "=", "new", "DensePositiveMapper", "(", "input", ",", "start", ",", "length", ")", ";", "mapper", ".", "map", "(", "input", ",", "start", ",", "length", ")", ";", "return", "delegate", ".", "buildSuffixArray", "(", "input", ",", "start", ",", "length", ")", ";", "}" ]

[ "Construct", "a", "suffix", "array", "for", "a", "given", "character", "sequence", "." ]

[ "void", "setPosition", "(", "Node", "<", "T", ",", "S", ">", "node", ",", "Edge", "<", "T", ",", "S", ">", "edge", ",", "int", "length", ")", "{", "activeNode", "=", "node", ";", "activeEdge", "=", "edge", ";", "activeLength", "=", "length", ";", "}" ]

[ "Sets", "the", "active", "point", "to", "a", "new", "node", "edge", "length", "tripple", "." ]

[ "public", "void", "updateAfterInsert", "(", "Suffix", "<", "T", ",", "S", ">", "suffix", ")", "{", "if", "(", "activeNode", "==", "root", "&&", "suffix", ".", "isEmpty", "(", ")", ")", "{", "activeNode", "=", "root", ";", "activeEdge", "=", "null", ";", "activeLength", "=", "0", ";", "}", "else", "if", "(", "activeNode", "==", "root", ")", "{", "Object", "item", "=", "suffix", ".", "getStart", "(", ")", ";", "activeEdge", "=", "root", ".", "getEdgeStarting", "(", "item", ")", ";", "decrementLength", "(", ")", ";", "fixActiveEdgeAfterSuffixLink", "(", "suffix", ")", ";", "if", "(", "activeLength", "==", "0", ")", "activeEdge", "=", "null", ";", "}", "else", "if", "(", "activeNode", ".", "hasSuffixLink", "(", ")", ")", "{", "activeNode", "=", "activeNode", ".", "getSuffixLink", "(", ")", ";", "findTrueActiveEdge", "(", ")", ";", "fixActiveEdgeAfterSuffixLink", "(", "suffix", ")", ";", "if", "(", "activeLength", "==", "0", ")", "activeEdge", "=", "null", ";", "}", "else", "{", "activeNode", "=", "root", ";", "findTrueActiveEdge", "(", ")", ";", "fixActiveEdgeAfterSuffixLink", "(", "suffix", ")", ";", "if", "(", "activeLength", "==", "0", ")", "activeEdge", "=", "null", ";", "}", "}" ]

[ "Resets", "the", "active", "point", "after", "an", "insert", "." ]

[ "private", "void", "fixActiveEdgeAfterSuffixLink", "(", "Suffix", "<", "T", ",", "S", ">", "suffix", ")", "{", "while", "(", "activeEdge", "!=", "null", "&&", "activeLength", ">", "activeEdge", ".", "getLength", "(", ")", ")", "{", "activeLength", "=", "activeLength", "-", "activeEdge", ".", "getLength", "(", ")", ";", "activeNode", "=", "activeEdge", ".", "getTerminal", "(", ")", ";", "Object", "item", "=", "suffix", ".", "getItemXFromEnd", "(", "activeLength", "+", "1", ")", ";", "activeEdge", "=", "activeNode", ".", "getEdgeStarting", "(", "item", ")", ";", "}", "resetActivePointToTerminal", "(", ")", ";", "}" ]

[ "Deal", "with", "the", "case", "when", "we", "follow", "a", "suffix", "link", "but", "the", "active", "length", "is", "greater", "than", "the", "new", "active", "edge", "length", ".", "In", "this", "situation", "we", "must", "walk", "down", "the", "tree", "updating", "the", "entire", "active", "point", "." ]

[ "private", "void", "findTrueActiveEdge", "(", ")", "{", "if", "(", "activeEdge", "!=", "null", ")", "{", "Object", "item", "=", "activeEdge", ".", "getStartItem", "(", ")", ";", "activeEdge", "=", "activeNode", ".", "getEdgeStarting", "(", "item", ")", ";", "}", "}" ]

[ "Finds", "the", "edge", "instance", "who", "s", "start", "item", "matches", "the", "current", "active", "edge", "start", "item", "but", "comes", "from", "the", "current", "active", "node", "." ]

[ "private", "boolean", "resetActivePointToTerminal", "(", ")", "{", "if", "(", "activeEdge", "!=", "null", "&&", "activeEdge", ".", "getLength", "(", ")", "==", "activeLength", "&&", "activeEdge", ".", "isTerminating", "(", ")", ")", "{", "activeNode", "=", "activeEdge", ".", "getTerminal", "(", ")", ";", "activeEdge", "=", "null", ";", "activeLength", "=", "0", ";", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Resizes", "the", "active", "length", "in", "the", "case", "where", "we", "are", "sitting", "on", "a", "terminal", "." ]

[ "public", "int", "[", "]", "buildSuffixArray", "(", "T", "[", "]", "tokens", ")", "{", "final", "int", "length", "=", "tokens", ".", "length", ";", "/*\n * Allocate slightly more space, some suffix construction strategies need it and\n * we don't want to waste space for multiple symbol mappings.\n */", "input", "=", "new", "int", "[", "length", "+", "SuffixArrays", ".", "MAX_EXTRA_TRAILING_SPACE", "]", ";", "//System.out.println(\"Assigning token ids ...\");", "/*\n * We associate every token to an id, all `equal´ tokens to the same id.\n * The suffix array is built using only the the ids.\n */", "tokIDs", "=", "new", "TreeMap", "<>", "(", "comparator", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "length", ";", "i", "++", ")", "{", "tokIDs", ".", "putIfAbsent", "(", "tokens", "[", "i", "]", ",", "i", ")", ";", "input", "[", "i", "]", "=", "tokIDs", ".", "get", "(", "tokens", "[", "i", "]", ")", ";", "}", "//System.out.println(\"Token ids assigned.\");", "return", "delegate", ".", "buildSuffixArray", "(", "input", ",", "0", ",", "length", ")", ";", "}" ]

[ "Construct", "a", "suffix", "array", "for", "a", "given", "generic", "token", "array", "." ]

[ "public", "void", "add", "(", "S", "sequence", ")", "{", "int", "start", "=", "currentEnd", ";", "this", ".", "sequence", ".", "add", "(", "sequence", ")", ";", "suffix", "=", "new", "Suffix", "<>", "(", "currentEnd", ",", "currentEnd", ",", "this", ".", "sequence", ")", ";", "activePoint", ".", "setPosition", "(", "root", ",", "null", ",", "0", ")", ";", "extendTree", "(", "start", ",", "this", ".", "sequence", ".", "getLength", "(", ")", ")", ";", "}" ]

[ "Add", "a", "sequence", "to", "the", "suffix", "tree", ".", "It", "is", "immediately", "processed", "and", "added", "to", "the", "tree", "." ]

[ "void", "insert", "(", "Suffix", "<", "I", ",", "S", ">", "suffix", ")", "{", "if", "(", "activePoint", ".", "isNode", "(", ")", ")", "{", "Node", "<", "I", ",", "S", ">", "node", "=", "activePoint", ".", "getNode", "(", ")", ";", "node", ".", "insert", "(", "suffix", ",", "activePoint", ")", ";", "}", "else", "if", "(", "activePoint", ".", "isEdge", "(", ")", ")", "{", "Edge", "<", "I", ",", "S", ">", "edge", "=", "activePoint", ".", "getEdge", "(", ")", ";", "edge", ".", "insert", "(", "suffix", ",", "activePoint", ")", ";", "}", "}" ]

[ "Inserts", "the", "given", "suffix", "into", "this", "tree", "." ]

[ "void", "setSuffixLink", "(", "Node", "<", "I", ",", "S", ">", "node", ")", "{", "if", "(", "isNotFirstInsert", "(", ")", ")", "{", "lastNodeInserted", ".", "setSuffixLink", "(", "node", ")", ";", "}", "lastNodeInserted", "=", "node", ";", "}" ]

[ "Sets", "the", "suffix", "link", "of", "the", "last", "inserted", "node", "to", "point", "to", "the", "supplied", "node", ".", "This", "method", "checks", "the", "state", "of", "the", "step", "and", "only", "applies", "the", "suffix", "link", "if", "there", "is", "a", "previous", "node", "inserted", "during", "this", "step", ".", "This", "method", "also", "set", "the", "last", "node", "inserted", "to", "the", "supplied", "node", "after", "applying", "any", "suffix", "linking", "." ]

[ "public", "static", "MatchTable", "create", "(", "VariantGraph", "graph", ",", "Iterable", "<", "Token", ">", "witness", ")", "{", "Comparator", "<", "Token", ">", "comparator", "=", "new", "EqualityTokenComparator", "(", ")", ";", "return", "MatchTableImpl", ".", "create", "(", "graph", ",", "witness", ",", "comparator", ")", ";", "}" ]

[ "assumes", "default", "token", "comparator" ]

[ "@", "Override", "public", "Set", "<", "Island", ">", "getIslands", "(", ")", "{", "Map", "<", "Coordinate", ",", "Island", ">", "coordinateMapper", "=", "new", "HashMap", "<>", "(", ")", ";", "List", "<", "Coordinate", ">", "allMatches", "=", "allMatches", "(", ")", ";", "for", "(", "Coordinate", "c", ":", "allMatches", ")", "{", "// LOG.debug(\"coordinate {}\", c);", "addToIslands", "(", "coordinateMapper", ",", "c", ")", ";", "}", "Set", "<", "Coordinate", ">", "smallestIslandsCoordinates", "=", "new", "HashSet", "<>", "(", "allMatches", ")", ";", "smallestIslandsCoordinates", ".", "removeAll", "(", "coordinateMapper", ".", "keySet", "(", ")", ")", ";", "for", "(", "Coordinate", "coordinate", ":", "smallestIslandsCoordinates", ")", "{", "Island", "island", "=", "new", "Island", "(", ")", ";", "island", ".", "add", "(", "coordinate", ")", ";", "coordinateMapper", ".", "put", "(", "coordinate", ",", "island", ")", ";", "}", "return", "new", "HashSet", "<>", "(", "coordinateMapper", ".", "values", "(", ")", ")", ";", "}" ]

[ "we", "don", "t", "need", "to", "check", "the", "lower", "right", "neighbor", "." ]

[ "private", "void", "fillTableWithMatches", "(", "VariantGraphRanking", "ranking", ",", "VariantGraph", "graph", ",", "Iterable", "<", "Token", ">", "witness", ",", "Comparator", "<", "Token", ">", "comparator", ")", "{", "Matches", "matches", "=", "Matches", ".", "between", "(", "graph", ".", "vertices", "(", ")", ",", "witness", ",", "comparator", ")", ";", "Set", "<", "Token", ">", "unique", "=", "matches", ".", "uniqueInWitness", ";", "Set", "<", "Token", ">", "ambiguous", "=", "matches", ".", "ambiguousInWitness", ";", "int", "rowIndex", "=", "0", ";", "for", "(", "Token", "t", ":", "witness", ")", "{", "if", "(", "unique", ".", "contains", "(", "t", ")", "||", "ambiguous", ".", "contains", "(", "t", ")", ")", "{", "List", "<", "VariantGraph", ".", "Vertex", ">", "matchingVertices", "=", "matches", ".", "allMatches", ".", "getOrDefault", "(", "t", ",", "Collections", ".", "emptyList", "(", ")", ")", ";", "for", "(", "VariantGraph", ".", "Vertex", "vgv", ":", "matchingVertices", ")", "{", "set", "(", "rowIndex", ",", "ranking", ".", "apply", "(", "vgv", ")", "-", "1", ",", "t", ",", "vgv", ")", ";", "}", "}", "rowIndex", "++", ";", "}", "}" ]

[ "move", "parameters", "into", "fields?" ]

[ "public", "void", "remove", "(", "int", "id", ")", "{", "String", "symbol", "=", "invert", "(", ")", ".", "keyForId", "(", "id", ")", ";", "idToSymbol", ".", "remove", "(", "id", ")", ";", "symbolToId", ".", "remove", "(", "symbol", ")", ";", "}" ]

[ "Remove", "the", "mapping", "for", "the", "given", "id", ".", "Note", "that", "the", "newly", "assigned", "next", "ids", "are", "monotonically", "increasing", "so", "removing", "one", "id", "does", "not", "free", "it", "up", "to", "be", "assigned", "in", "future", "symbol", "table", "adds", ";", "there", "will", "just", "be", "holes", "in", "the", "symbol", "mappings" ]

[ "public", "void", "trimIds", "(", ")", "{", "// typical case shortcut", "if", "(", "idToSymbol", ".", "containsKey", "(", "nextId", "-", "1", ")", ")", "{", "return", ";", "}", "int", "max", "=", "-", "1", ";", "for", "(", "IntObjectCursor", "<", "String", ">", "cursor", ":", "idToSymbol", ")", "{", "max", "=", "Math", ".", "max", "(", "max", ",", "cursor", ".", "key", ")", ";", "}", "nextId", "=", "max", "+", "1", ";", "}" ]

[ "If", "there", "are", "ids", "to", "reclaim", "at", "the", "end", "then", "this", "will", "do", "this", ".", "Certainly", "be", "careful", "if", "you", "are", "doing", "operations", "where", "it", "is", "expected", "that", "the", "id", "mappings", "will", "be", "consistent", "across", "multiple", "FSTs", "such", "as", "in", "compose", "where", "you", "want", "the", "output", "of", "A", "to", "be", "equal", "to", "the", "input", "of", "B" ]

[ "public", "static", "PrecomputedComposeFst", "precomputeInner", "(", "Fst", "fst2", ",", "Semiring", "semiring", ")", "{", "fst2", ".", "throwIfInvalid", "(", ")", ";", "MutableFst", "mutableFst", "=", "MutableFst", ".", "copyFrom", "(", "fst2", ")", ";", "WriteableSymbolTable", "table", "=", "mutableFst", ".", "getInputSymbols", "(", ")", ";", "int", "e1index", "=", "getOrAddEps", "(", "table", ",", "true", ")", ";", "int", "e2index", "=", "getOrAddEps", "(", "table", ",", "false", ")", ";", "String", "eps1", "=", "table", ".", "invert", "(", ")", ".", "keyForId", "(", "e1index", ")", ";", "String", "eps2", "=", "table", ".", "invert", "(", ")", ".", "keyForId", "(", "e2index", ")", ";", "augment", "(", "AugmentLabels", ".", "INPUT", ",", "mutableFst", ",", "semiring", ",", "eps1", ",", "eps2", ")", ";", "ArcSort", ".", "sortByInput", "(", "mutableFst", ")", ";", "MutableFst", "filter", "=", "makeFilter", "(", "table", ",", "semiring", ",", "eps1", ",", "eps2", ")", ";", "ArcSort", ".", "sortByInput", "(", "filter", ")", ";", "return", "new", "PrecomputedComposeFst", "(", "eps1", ",", "eps2", ",", "new", "ImmutableFst", "(", "mutableFst", ")", ",", "semiring", ",", "new", "ImmutableFst", "(", "filter", ")", ")", ";", "}" ]

[ "Pre", "-", "processes", "a", "FST", "that", "is", "going", "to", "be", "used", "on", "the", "right", "hand", "side", "of", "a", "compose", "operator", "many", "times" ]

[ "private", "static", "MutableFst", "makeFilter", "(", "WriteableSymbolTable", "table", ",", "Semiring", "semiring", ",", "String", "eps1", ",", "String", "eps2", ")", "{", "MutableFst", "filter", "=", "new", "MutableFst", "(", "semiring", ",", "table", ",", "table", ")", ";", "// State 0", "MutableState", "s0", "=", "filter", ".", "newStartState", "(", ")", ";", "s0", ".", "setFinalWeight", "(", "semiring", ".", "one", "(", ")", ")", ";", "MutableState", "s1", "=", "filter", ".", "newState", "(", ")", ";", "s1", ".", "setFinalWeight", "(", "semiring", ".", "one", "(", ")", ")", ";", "MutableState", "s2", "=", "filter", ".", "newState", "(", ")", ";", "s2", ".", "setFinalWeight", "(", "semiring", ".", "one", "(", ")", ")", ";", "filter", ".", "addArc", "(", "s0", ",", "eps2", ",", "eps1", ",", "s0", ",", "semiring", ".", "one", "(", ")", ")", ";", "filter", ".", "addArc", "(", "s0", ",", "eps1", ",", "eps1", ",", "s1", ",", "semiring", ".", "one", "(", ")", ")", ";", "filter", ".", "addArc", "(", "s0", ",", "eps2", ",", "eps2", ",", "s2", ",", "semiring", ".", "one", "(", ")", ")", ";", "// self loops", "filter", ".", "addArc", "(", "s1", ",", "eps1", ",", "eps1", ",", "s1", ",", "semiring", ".", "one", "(", ")", ")", ";", "filter", ".", "addArc", "(", "s2", ",", "eps2", ",", "eps2", ",", "s2", ",", "semiring", ".", "one", "(", ")", ")", ";", "for", "(", "ObjectIntCursor", "<", "String", ">", "cursor", ":", "table", ")", "{", "int", "i", "=", "cursor", ".", "value", ";", "String", "key", "=", "cursor", ".", "key", ";", "if", "(", "key", ".", "equals", "(", "Fst", ".", "EPS", ")", "||", "key", ".", "equals", "(", "eps1", ")", "||", "key", ".", "equals", "(", "eps2", ")", ")", "{", "continue", ";", "}", "filter", ".", "addArc", "(", "s0", ",", "i", ",", "i", ",", "s0", ",", "semiring", ".", "one", "(", ")", ")", ";", "filter", ".", "addArc", "(", "s1", ",", "i", ",", "i", ",", "s0", ",", "semiring", ".", "one", "(", ")", ")", ";", "filter", ".", "addArc", "(", "s2", ",", "i", ",", "i", ",", "s0", ",", "semiring", ".", "one", "(", ")", ")", ";", "}", "return", "filter", ";", "}" ]

[ "Get", "a", "filter", "to", "use", "for", "avoiding", "multiple", "epsilon", "paths", "in", "the", "resulting", "Fst" ]

[ "private", "static", "void", "augment", "(", "AugmentLabels", "label", ",", "MutableFst", "fst", ",", "Semiring", "semiring", ",", "String", "eps1", ",", "String", "eps2", ")", "{", "// label: 0->augment on ilabel", "// 1->augment on olabel", "int", "e1inputIndex", "=", "fst", ".", "getInputSymbols", "(", ")", ".", "getOrAdd", "(", "eps1", ")", ";", "int", "e2inputIndex", "=", "fst", ".", "getInputSymbols", "(", ")", ".", "getOrAdd", "(", "eps2", ")", ";", "int", "e1outputIndex", "=", "fst", ".", "getOutputSymbols", "(", ")", ".", "getOrAdd", "(", "eps1", ")", ";", "int", "e2outputIndex", "=", "fst", ".", "getOutputSymbols", "(", ")", ".", "getOrAdd", "(", "eps2", ")", ";", "int", "iEps", "=", "fst", ".", "getInputSymbols", "(", ")", ".", "get", "(", "Fst", ".", "EPS", ")", ";", "int", "oEps", "=", "fst", ".", "getOutputSymbols", "(", ")", ".", "get", "(", "Fst", ".", "EPS", ")", ";", "int", "numStates", "=", "fst", ".", "getStateCount", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "numStates", ";", "i", "++", ")", "{", "MutableState", "s", "=", "fst", ".", "getState", "(", "i", ")", ";", "for", "(", "MutableArc", "arc", ":", "s", ".", "getArcs", "(", ")", ")", "{", "if", "(", "(", "label", "==", "AugmentLabels", ".", "OUTPUT", ")", "&&", "(", "arc", ".", "getOlabel", "(", ")", "==", "oEps", ")", ")", "{", "arc", ".", "setOlabel", "(", "e2outputIndex", ")", ";", "}", "else", "if", "(", "(", "label", "==", "AugmentLabels", ".", "INPUT", ")", "&&", "(", "arc", ".", "getIlabel", "(", ")", "==", "iEps", ")", ")", "{", "arc", ".", "setIlabel", "(", "e1inputIndex", ")", ";", "}", "}", "if", "(", "label", "==", "AugmentLabels", ".", "INPUT", ")", "{", "fst", ".", "addArc", "(", "s", ",", "e2inputIndex", ",", "oEps", ",", "s", ",", "semiring", ".", "one", "(", ")", ")", ";", "}", "else", "if", "(", "label", "==", "AugmentLabels", ".", "OUTPUT", ")", "{", "fst", ".", "addArc", "(", "s", ",", "iEps", ",", "e1outputIndex", ",", "s", ",", "semiring", ".", "one", "(", ")", ")", ";", "}", "}", "}" ]

[ "Augments", "the", "labels", "of", "an", "Fst", "in", "order", "to", "use", "it", "for", "composition", "avoiding", "multiple", "epsilon", "paths", "in", "the", "resulting", "Fst" ]

[ "public", "static", "void", "apply", "(", "MutableFst", "fst", ",", "ProjectType", "pType", ")", "{", "if", "(", "pType", "==", "ProjectType", ".", "INPUT", ")", "{", "fst", ".", "setOutputSymbolsAsCopyFromThatInput", "(", "fst", ")", ";", "}", "else", "if", "(", "pType", "==", "ProjectType", ".", "OUTPUT", ")", "{", "fst", ".", "setInputSymbolsAsCopyFromThatOutput", "(", "fst", ")", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "fst", ".", "getStateCount", "(", ")", ";", "i", "++", ")", "{", "MutableState", "state", "=", "fst", ".", "getState", "(", "i", ")", ";", "// Immutable fsts hold an additional (null) arc", "for", "(", "int", "j", "=", "0", ";", "j", "<", "state", ".", "getArcCount", "(", ")", ";", "j", "++", ")", "{", "MutableArc", "a", "=", "state", ".", "getArc", "(", "j", ")", ";", "if", "(", "pType", "==", "ProjectType", ".", "INPUT", ")", "{", "a", ".", "setOlabel", "(", "a", ".", "getIlabel", "(", ")", ")", ";", "}", "else", "if", "(", "pType", "==", "ProjectType", ".", "OUTPUT", ")", "{", "a", ".", "setIlabel", "(", "a", ".", "getOlabel", "(", ")", ")", ";", "}", "}", "}", "}" ]

[ "Projects", "an", "fst", "onto", "its", "domain", "or", "range", "by", "either", "copying", "each", "arc", "s", "input", "label", "to", "its", "output", "label", "or", "vice", "versa", "." ]

[ "public", "static", "void", "apply", "(", "MutableFst", "fst", ")", "{", "fst", ".", "throwIfInvalid", "(", ")", ";", "IntOpenHashSet", "accessible", "=", "new", "IntOpenHashSet", "(", "fst", ".", "getStateCount", "(", ")", ")", ";", "IntOpenHashSet", "coaccessible", "=", "new", "IntOpenHashSet", "(", "fst", ".", "getStateCount", "(", ")", ")", ";", "dfsForward", "(", "fst", ".", "getStartState", "(", ")", ",", "accessible", ")", ";", "int", "numStates", "=", "fst", ".", "getStateCount", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "numStates", ";", "i", "++", ")", "{", "MutableState", "s", "=", "fst", ".", "getState", "(", "i", ")", ";", "if", "(", "fst", ".", "getSemiring", "(", ")", ".", "isNotZero", "(", "s", ".", "getFinalWeight", "(", ")", ")", ")", "{", "dfsBackward", "(", "s", ",", "coaccessible", ")", ";", "}", "}", "if", "(", "accessible", ".", "size", "(", ")", "==", "fst", ".", "getStateCount", "(", ")", "&&", "coaccessible", ".", "size", "(", ")", "==", "fst", ".", "getStateCount", "(", ")", ")", "{", "// common case, optimization bail early", "return", ";", "}", "ArrayList", "<", "MutableState", ">", "toDelete", "=", "new", "ArrayList", "<>", "(", ")", ";", "int", "startId", "=", "fst", ".", "getStartState", "(", ")", ".", "getId", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "numStates", ";", "i", "++", ")", "{", "MutableState", "s", "=", "fst", ".", "getState", "(", "i", ")", ";", "if", "(", "s", ".", "getId", "(", ")", "==", "startId", ")", "{", "continue", ";", "// cant delete the start state", "}", "if", "(", "!", "accessible", ".", "contains", "(", "s", ".", "getId", "(", ")", ")", "||", "!", "coaccessible", ".", "contains", "(", "s", ".", "getId", "(", ")", ")", ")", "{", "toDelete", ".", "add", "(", "s", ")", ";", "}", "}", "fst", ".", "deleteStates", "(", "toDelete", ")", ";", "}" ]

[ "Trims", "an", "Fst", "removing", "states", "and", "arcs", "that", "are", "not", "on", "successful", "paths", "." ]

[ "public", "MutableState", "setStart", "(", "MutableState", "start", ")", "{", "checkArgument", "(", "start", ".", "getId", "(", ")", ">=", "0", ",", "\"must set id before setting start\"", ")", ";", "throwIfSymbolTableMissingId", "(", "start", ".", "getId", "(", ")", ")", ";", "correctStateWeight", "(", "start", ")", ";", "this", ".", "start", "=", "start", ";", "return", "start", ";", "}" ]

[ "Set", "the", "initial", "state" ]

[ "public", "void", "deleteStates", "(", "Collection", "<", "MutableState", ">", "statesToDelete", ")", "{", "if", "(", "statesToDelete", ".", "isEmpty", "(", ")", ")", "{", "return", ";", "}", "for", "(", "MutableState", "state", ":", "statesToDelete", ")", "{", "deleteState", "(", "state", ")", ";", "}", "remapStateIds", "(", ")", ";", "}" ]

[ "Deletes", "the", "given", "states", "and", "remaps", "the", "existing", "state", "ids" ]

[ "private", "void", "deleteState", "(", "MutableState", "state", ")", "{", "if", "(", "state", ".", "getId", "(", ")", "==", "this", ".", "start", ".", "getId", "(", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Cannot delete start state.\"", ")", ";", "}", "// we're going to \"compact\" all of the nulls out and remap state ids at the end", "this", ".", "states", ".", "set", "(", "state", ".", "getId", "(", ")", ",", "null", ")", ";", "if", "(", "isUsingStateSymbols", "(", ")", ")", "{", "stateSymbols", ".", "remove", "(", "state", ".", "getId", "(", ")", ")", ";", "}", "// this state won't be incoming to any of its arc's targets anymore", "for", "(", "MutableArc", "mutableArc", ":", "state", ".", "getArcs", "(", ")", ")", "{", "mutableArc", ".", "getNextState", "(", ")", ".", "removeIncomingState", "(", "state", ")", ";", "}", "// delete arc's with nextstate equal to stateid", "for", "(", "MutableState", "inState", ":", "state", ".", "getIncomingStates", "(", ")", ")", "{", "Iterator", "<", "MutableArc", ">", "iter", "=", "inState", ".", "getArcs", "(", ")", ".", "iterator", "(", ")", ";", "while", "(", "iter", ".", "hasNext", "(", ")", ")", "{", "MutableArc", "arc", "=", "iter", ".", "next", "(", ")", ";", "if", "(", "arc", ".", "getNextState", "(", ")", "==", "state", ")", "{", "iter", ".", "remove", "(", ")", ";", "}", "}", "}", "}" ]

[ "Deletes", "a", "state", ";" ]

[ "public", "MutableFst", "compute", "(", "final", "Fst", "fst", ")", "{", "fst", ".", "throwIfInvalid", "(", ")", ";", "// init for this run of compute", "this", ".", "semiring", "=", "fst", ".", "getSemiring", "(", ")", ";", "this", ".", "gallicSemiring", "=", "new", "GallicSemiring", "(", "this", ".", "semiring", ",", "this", ".", "gallicMode", ")", ";", "this", ".", "unionSemiring", "=", "makeUnionRing", "(", "semiring", ",", "gallicSemiring", ",", "mode", ")", ";", "this", ".", "inputFst", "=", "fst", ";", "this", ".", "outputFst", "=", "MutableFst", ".", "emptyWithCopyOfSymbols", "(", "fst", ")", ";", "this", ".", "outputStateIdToTuple", "=", "HashBiMap", ".", "create", "(", ")", ";", "// workQueue holds the pending work of determinizing the input fst", "Deque", "<", "DetStateTuple", ">", "workQueue", "=", "new", "LinkedList", "<>", "(", ")", ";", "// finalQueue holds the pending work of expanding out the final paths (handled by the FactorFst in the", "// open fst implementation)", "Deque", "<", "DetElement", ">", "finalQueue", "=", "new", "LinkedList", "<>", "(", ")", ";", "// start the algorithm by starting with the input start state", "MutableState", "initialOutState", "=", "outputFst", ".", "newStartState", "(", ")", ";", "DetElement", "initialElement", "=", "new", "DetElement", "(", "fst", ".", "getStartState", "(", ")", ".", "getId", "(", ")", ",", "GallicWeight", ".", "createEmptyLabels", "(", "semiring", ".", "one", "(", ")", ")", ")", ";", "DetStateTuple", "initialTuple", "=", "new", "DetStateTuple", "(", "initialElement", ")", ";", "workQueue", ".", "addLast", "(", "initialTuple", ")", ";", "this", ".", "outputStateIdToTuple", ".", "put", "(", "initialOutState", ".", "getId", "(", ")", ",", "initialTuple", ")", ";", "// process all of the input states via the work queue", "while", "(", "!", "workQueue", ".", "isEmpty", "(", ")", ")", "{", "DetStateTuple", "entry", "=", "workQueue", ".", "removeFirst", "(", ")", ";", "MutableState", "outStateForTuple", "=", "getOutputStateForStateTuple", "(", "entry", ")", ";", "Collection", "<", "DetArcWork", ">", "arcWorks", "=", "groupByInputLabel", "(", "entry", ")", ";", "arcWorks", ".", "forEach", "(", "this", "::", "normalizeArcWork", ")", ";", "for", "(", "DetArcWork", "arcWork", ":", "arcWorks", ")", "{", "DetStateTuple", "targetTuple", "=", "new", "DetStateTuple", "(", "arcWork", ".", "pendingElements", ")", ";", "if", "(", "!", "this", ".", "outputStateIdToTuple", ".", "inverse", "(", ")", ".", "containsKey", "(", "targetTuple", ")", ")", "{", "// we've never seen this tuple before so new state + enqueue the work", "MutableState", "newOutState", "=", "outputFst", ".", "newState", "(", ")", ";", "this", ".", "outputStateIdToTuple", ".", "put", "(", "newOutState", ".", "getId", "(", ")", ",", "targetTuple", ")", ";", "newOutState", ".", "setFinalWeight", "(", "computeFinalWeight", "(", "newOutState", ".", "getId", "(", ")", ",", "targetTuple", ",", "finalQueue", ")", ")", ";", "workQueue", ".", "addLast", "(", "targetTuple", ")", ";", "}", "MutableState", "targetOutState", "=", "getOutputStateForStateTuple", "(", "targetTuple", ")", ";", "// the computed divisor is a 'legal' arc meaning that it only has zero or one substring; though there", "// might be multiple entries if we're in non_functional mode", "UnionWeight", "<", "GallicWeight", ">", "unionWeight", "=", "arcWork", ".", "computedDivisor", ";", "for", "(", "GallicWeight", "gallicWeight", ":", "unionWeight", ".", "getWeights", "(", ")", ")", "{", "Preconditions", ".", "checkState", "(", "gallicSemiring", ".", "isNotZero", "(", "gallicWeight", ")", ",", "\"gallic weight zero computed from group by\"", ",", "gallicWeight", ")", ";", "int", "oLabel", "=", "this", ".", "outputEps", ";", "if", "(", "!", "gallicWeight", ".", "getLabels", "(", ")", ".", "isEmpty", "(", ")", ")", "{", "Preconditions", ".", "checkState", "(", "gallicWeight", ".", "getLabels", "(", ")", ".", "size", "(", ")", "==", "1", ",", "\"cant gave gallic arc weight with more than a single symbol\"", ",", "gallicWeight", ")", ";", "oLabel", "=", "gallicWeight", ".", "getLabels", "(", ")", ".", "get", "(", "0", ")", ";", "}", "outputFst", ".", "addArc", "(", "outStateForTuple", ",", "arcWork", ".", "inputLabel", ",", "oLabel", ",", "targetOutState", ",", "gallicWeight", ".", "getWeight", "(", ")", ")", ";", "}", "}", "}", "// we might've deferred some final state work that needs to be expanded", "expandDeferredFinalStates", "(", "finalQueue", ")", ";", "return", "outputFst", ";", "}" ]

[ "Determinizes", "an", "FSA", "or", "FST", ".", "For", "this", "algorithm", "epsilon", "transitions", "are", "treated", "as", "regular", "symbols", "." ]

[ "private", "void", "normalizeArcWork", "(", "final", "DetArcWork", "arcWork", ")", "{", "Collections", ".", "sort", "(", "arcWork", ".", "pendingElements", ")", ";", "ArrayList", "<", "DetElement", ">", "deduped", "=", "Lists", ".", "newArrayList", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "arcWork", ".", "pendingElements", ".", "size", "(", ")", ";", "i", "++", ")", "{", "// first update the running common divisor that we'll use later", "DetElement", "currentElement", "=", "arcWork", ".", "pendingElements", ".", "get", "(", "i", ")", ";", "arcWork", ".", "computedDivisor", "=", "unionSemiring", ".", "commonDivisor", "(", "arcWork", ".", "computedDivisor", ",", "currentElement", ".", "residual", ")", ";", "// now we want to add and dedup at the same time (this is ok because we sorted)", "if", "(", "deduped", ".", "isEmpty", "(", ")", "||", "deduped", ".", "get", "(", "deduped", ".", "size", "(", ")", "-", "1", ")", ".", "inputStateId", "!=", "currentElement", ".", "inputStateId", ")", "{", "deduped", ".", "add", "(", "currentElement", ")", ";", "}", "else", "{", "// merge this next one into the existing one", "int", "lastIndex", "=", "deduped", ".", "size", "(", ")", "-", "1", ";", "DetElement", "lastElement", "=", "deduped", ".", "get", "(", "lastIndex", ")", ";", "UnionWeight", "<", "GallicWeight", ">", "merged", "=", "unionSemiring", ".", "plus", "(", "lastElement", ".", "residual", ",", "currentElement", ".", "residual", ")", ";", "deduped", ".", "set", "(", "lastIndex", ",", "lastElement", ".", "withResidual", "(", "merged", ")", ")", ";", "}", "}", "arcWork", ".", "pendingElements", "=", "deduped", ";", "// dividing out the weights with the divisor across all elements", "for", "(", "int", "i", "=", "0", ";", "i", "<", "arcWork", ".", "pendingElements", ".", "size", "(", ")", ";", "i", "++", ")", "{", "DetElement", "currentElement", "=", "arcWork", ".", "pendingElements", ".", "get", "(", "i", ")", ";", "UnionWeight", "<", "GallicWeight", ">", "divided", "=", "unionSemiring", ".", "divide", "(", "currentElement", ".", "residual", ",", "arcWork", ".", "computedDivisor", ")", ";", "arcWork", ".", "pendingElements", ".", "set", "(", "i", ",", "currentElement", ".", "withResidual", "(", "divided", ")", ")", ";", "// we aren't quantizing anything in jopenfst but we would want to quantize here if we add that in the future", "}", "}" ]

[ "and", "compute", "new", "resulting", "arc", "weights" ]

[ "private", "double", "computeFinalWeight", "(", "final", "int", "outputStateId", ",", "final", "DetStateTuple", "targetTuple", ",", "Deque", "<", "DetElement", ">", "finalQueue", ")", "{", "UnionWeight", "<", "GallicWeight", ">", "result", "=", "this", ".", "unionSemiring", ".", "zero", "(", ")", ";", "for", "(", "DetElement", "detElement", ":", "targetTuple", ".", "getElements", "(", ")", ")", "{", "State", "inputState", "=", "this", ".", "getInputStateForId", "(", "detElement", ".", "inputStateId", ")", ";", "if", "(", "this", ".", "semiring", ".", "isZero", "(", "inputState", ".", "getFinalWeight", "(", ")", ")", ")", "{", "continue", ";", "// not final so it wont contribute", "}", "UnionWeight", "<", "GallicWeight", ">", "origFinal", "=", "UnionWeight", ".", "createSingle", "(", "GallicWeight", ".", "createEmptyLabels", "(", "inputState", ".", "getFinalWeight", "(", ")", ")", ")", ";", "result", "=", "this", ".", "unionSemiring", ".", "plus", "(", "result", ",", "this", ".", "unionSemiring", ".", "times", "(", "detElement", ".", "residual", ",", "origFinal", ")", ")", ";", "}", "if", "(", "this", ".", "unionSemiring", ".", "isZero", "(", "result", ")", ")", "{", "return", "this", ".", "semiring", ".", "zero", "(", ")", ";", "}", "if", "(", "result", ".", "size", "(", ")", "==", "1", "&&", "result", ".", "get", "(", "0", ")", ".", "getLabels", "(", ")", ".", "isEmpty", "(", ")", ")", "{", "// by good fortune the residual is just a weight, no path to expand so this new state can have a final weight", "// set now! with nothing to enqueue", "return", "result", ".", "get", "(", "0", ")", ".", "getWeight", "(", ")", ";", "}", "// this state can't be a final state because we have more path to emit so defer until later; we know that we cant", "// have any duplicate elements in the finalQueue since we only call computeFinalWeight once for each outputStateId", "finalQueue", ".", "addLast", "(", "new", "DetElement", "(", "outputStateId", ",", "result", ")", ")", ";", "return", "this", ".", "semiring", ".", "zero", "(", ")", ";", "// since we're deferring this weight can't be a final weight", "}" ]

[ "_this_", "new", "outState", "a", "final", "state", "and", "instead", "we", "queue", "it", "into", "a", "separate", "queue", "for", "later", "expansion" ]

[ "private", "void", "expandDeferredFinalStates", "(", "Deque", "<", "DetElement", ">", "finalQueue", ")", "{", "HashBiMap", "<", "Integer", ",", "GallicWeight", ">", "outputStateIdToFinalSuffix", "=", "HashBiMap", ".", "create", "(", ")", ";", "while", "(", "!", "finalQueue", ".", "isEmpty", "(", ")", ")", "{", "DetElement", "element", "=", "finalQueue", ".", "removeFirst", "(", ")", ";", "for", "(", "GallicWeight", "gallicWeight", ":", "element", ".", "residual", ".", "getWeights", "(", ")", ")", "{", "// factorization is like a simple version of the divisor/divide calculation earlier", "Pair", "<", "GallicWeight", ",", "GallicWeight", ">", "factorized", "=", "gallicSemiring", ".", "factorize", "(", "gallicWeight", ")", ";", "GallicWeight", "prefix", "=", "factorized", ".", "getLeft", "(", ")", ";", "GallicWeight", "suffix", "=", "factorized", ".", "getRight", "(", ")", ";", "if", "(", "!", "outputStateIdToFinalSuffix", ".", "inverse", "(", ")", ".", "containsKey", "(", "suffix", ")", ")", "{", "// we don't have a synthetic state for this suffix yet", "MutableState", "newOutputState", "=", "outputFst", ".", "newState", "(", ")", ";", "outputStateIdToFinalSuffix", ".", "put", "(", "newOutputState", ".", "getId", "(", ")", ",", "suffix", ")", ";", "if", "(", "suffix", ".", "getLabels", "(", ")", ".", "isEmpty", "(", ")", ")", "{", "// this suffix is a real final state, and there's no more work to do", "newOutputState", ".", "setFinalWeight", "(", "suffix", ".", "getWeight", "(", ")", ")", ";", "}", "else", "{", "// this suffix still has more labels to emit, so leave final weight as zero and enqueue for expansion", "finalQueue", ".", "addLast", "(", "new", "DetElement", "(", "newOutputState", ".", "getId", "(", ")", ",", "suffix", ")", ")", ";", "}", "}", "Integer", "outputStateId", "=", "outputStateIdToFinalSuffix", ".", "inverse", "(", ")", ".", "get", "(", "suffix", ")", ";", "MutableState", "nextState", "=", "checkNotNull", "(", "outputFst", ".", "getState", "(", "outputStateId", ")", ",", "\"state should exist\"", ",", "outputStateId", ")", ";", "MutableState", "thisState", "=", "checkNotNull", "(", "outputFst", ".", "getState", "(", "element", ".", "inputStateId", ")", ")", ";", "Preconditions", ".", "checkArgument", "(", "prefix", ".", "getLabels", "(", ")", ".", "size", "(", ")", "==", "1", ",", "\"prefix size should be 1\"", ",", "prefix", ")", ";", "int", "oLabel", "=", "prefix", ".", "getLabels", "(", ")", ".", "get", "(", "0", ")", ";", "// note that openfst has an 'increment subsequent epsilons' feature so that these paths can still be", "// guarenteed to be deterministic (with just multiple definitions of <EPS>; this feature would go here", "// if we decide to implement it in the future", "outputFst", ".", "addArc", "(", "thisState", ",", "this", ".", "outputEps", ",", "oLabel", ",", "nextState", ",", "prefix", ".", "getWeight", "(", ")", ")", ";", "}", "}", "}" ]

[ "residual", "primitive", "weight", "early", "in", "the", "path", ")" ]

[ "public", "static", "MutableSymbolTable", "readStringMap", "(", "ObjectInput", "in", ")", "throws", "IOException", ",", "ClassNotFoundException", "{", "int", "mapSize", "=", "in", ".", "readInt", "(", ")", ";", "MutableSymbolTable", "syms", "=", "new", "MutableSymbolTable", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "mapSize", ";", "i", "++", ")", "{", "String", "sym", "=", "in", ".", "readUTF", "(", ")", ";", "int", "index", "=", "in", ".", "readInt", "(", ")", ";", "syms", ".", "put", "(", "sym", ",", "index", ")", ";", "}", "return", "syms", ";", "}" ]

[ "Deserializes", "a", "symbol", "map", "from", "an", "java", ".", "io", ".", "ObjectInput" ]

[ "public", "static", "MutableFst", "readFstFromBinaryStream", "(", "ObjectInput", "in", ")", "throws", "IOException", ",", "ClassNotFoundException", "{", "int", "version", "=", "in", ".", "readInt", "(", ")", ";", "if", "(", "version", "<", "FIRST_VERSION", "&&", "version", ">", "CURRENT_VERSION", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"cant read version fst model \"", "+", "version", ")", ";", "}", "MutableSymbolTable", "is", "=", "readStringMap", "(", "in", ")", ";", "MutableSymbolTable", "os", "=", "readStringMap", "(", "in", ")", ";", "MutableSymbolTable", "ss", "=", "null", ";", "if", "(", "in", ".", "readBoolean", "(", ")", ")", "{", "ss", "=", "readStringMap", "(", "in", ")", ";", "}", "return", "readFstWithTables", "(", "in", ",", "is", ",", "os", ",", "ss", ")", ";", "}" ]

[ "Deserializes", "an", "Fst", "from", "an", "ObjectInput" ]

[ "private", "static", "void", "writeStringMap", "(", "SymbolTable", "map", ",", "ObjectOutput", "out", ")", "throws", "IOException", "{", "out", ".", "writeInt", "(", "map", ".", "size", "(", ")", ")", ";", "for", "(", "ObjectIntCursor", "<", "String", ">", "cursor", ":", "map", ")", "{", "out", ".", "writeUTF", "(", "cursor", ".", "key", ")", ";", "out", ".", "writeInt", "(", "cursor", ".", "value", ")", ";", "}", "}" ]

[ "Serializes", "a", "symbol", "map", "to", "an", "ObjectOutput" ]

[ "public", "static", "void", "writeFstToBinaryStream", "(", "Fst", "fst", ",", "ObjectOutput", "out", ")", "throws", "IOException", "{", "out", ".", "writeInt", "(", "CURRENT_VERSION", ")", ";", "writeStringMap", "(", "fst", ".", "getInputSymbols", "(", ")", ",", "out", ")", ";", "writeStringMap", "(", "fst", ".", "getOutputSymbols", "(", ")", ",", "out", ")", ";", "out", ".", "writeBoolean", "(", "fst", ".", "isUsingStateSymbols", "(", ")", ")", ";", "// whether or not we used a state symbol table", "if", "(", "fst", ".", "isUsingStateSymbols", "(", ")", ")", "{", "writeStringMap", "(", "fst", ".", "getStateSymbols", "(", ")", ",", "out", ")", ";", "}", "out", ".", "writeInt", "(", "fst", ".", "getStartState", "(", ")", ".", "getId", "(", ")", ")", ";", "out", ".", "writeObject", "(", "fst", ".", "getSemiring", "(", ")", ")", ";", "out", ".", "writeInt", "(", "fst", ".", "getStateCount", "(", ")", ")", ";", "Map", "<", "State", ",", "Integer", ">", "stateMap", "=", "new", "IdentityHashMap", "<>", "(", "fst", ".", "getStateCount", "(", ")", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "fst", ".", "getStateCount", "(", ")", ";", "i", "++", ")", "{", "State", "s", "=", "fst", ".", "getState", "(", "i", ")", ";", "out", ".", "writeInt", "(", "s", ".", "getArcCount", "(", ")", ")", ";", "out", ".", "writeDouble", "(", "s", ".", "getFinalWeight", "(", ")", ")", ";", "out", ".", "writeInt", "(", "s", ".", "getId", "(", ")", ")", ";", "stateMap", ".", "put", "(", "s", ",", "i", ")", ";", "}", "int", "numStates", "=", "fst", ".", "getStateCount", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "numStates", ";", "i", "++", ")", "{", "State", "s", "=", "fst", ".", "getState", "(", "i", ")", ";", "int", "numArcs", "=", "s", ".", "getArcCount", "(", ")", ";", "for", "(", "int", "j", "=", "0", ";", "j", "<", "numArcs", ";", "j", "++", ")", "{", "Arc", "a", "=", "s", ".", "getArc", "(", "j", ")", ";", "out", ".", "writeInt", "(", "a", ".", "getIlabel", "(", ")", ")", ";", "out", ".", "writeInt", "(", "a", ".", "getOlabel", "(", ")", ")", ";", "out", ".", "writeDouble", "(", "a", ".", "getWeight", "(", ")", ")", ";", "out", ".", "writeInt", "(", "stateMap", ".", "get", "(", "a", ".", "getNextState", "(", ")", ")", ")", ";", "}", "}", "}" ]

[ "Serializes", "the", "current", "Fst", "instance", "to", "an", "ObjectOutput" ]

[ "public", "static", "void", "sortBy", "(", "MutableFst", "fst", ",", "Comparator", "<", "Arc", ">", "comparator", ")", "{", "int", "numStates", "=", "fst", ".", "getStateCount", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "numStates", ";", "i", "++", ")", "{", "MutableState", "s", "=", "fst", ".", "getState", "(", "i", ")", ";", "s", ".", "arcSort", "(", "comparator", ")", ";", "}", "}" ]

[ "Applies", "the", "ArcSort", "on", "the", "provided", "fst", ".", "Sorting", "can", "be", "applied", "either", "on", "input", "or", "output", "label", "based", "on", "the", "provided", "comparator", "." ]

[ "public", "static", "boolean", "isSorted", "(", "State", "state", ",", "Comparator", "<", "Arc", ">", "comparator", ")", "{", "return", "Ordering", ".", "from", "(", "comparator", ")", ".", "isOrdered", "(", "state", ".", "getArcs", "(", ")", ")", ";", "}" ]

[ "Returns", "true", "if", "the", "given", "state", "is", "sorted", "by", "the", "comparator" ]

[ "private", "static", "void", "exportFst", "(", "Fst", "fst", ",", "String", "filename", ")", "{", "FileWriter", "file", ";", "try", "{", "file", "=", "new", "FileWriter", "(", "filename", ")", ";", "PrintWriter", "out", "=", "new", "PrintWriter", "(", "file", ")", ";", "// print start first", "State", "start", "=", "fst", ".", "getStartState", "(", ")", ";", "out", ".", "println", "(", "start", ".", "getId", "(", ")", "+", "\"\\t\"", "+", "start", ".", "getFinalWeight", "(", ")", ")", ";", "// print all states", "int", "numStates", "=", "fst", ".", "getStateCount", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "numStates", ";", "i", "++", ")", "{", "State", "s", "=", "fst", ".", "getState", "(", "i", ")", ";", "if", "(", "s", ".", "getId", "(", ")", "==", "fst", ".", "getStartState", "(", ")", ".", "getId", "(", ")", ")", "{", "continue", ";", "}", "if", "(", "fst", ".", "getSemiring", "(", ")", ".", "isNotZero", "(", "s", ".", "getFinalWeight", "(", ")", ")", "||", "!", "omitZeroStates", ")", "{", "out", ".", "println", "(", "s", ".", "getId", "(", ")", "+", "\"\\t\"", "+", "s", ".", "getFinalWeight", "(", ")", ")", ";", "}", "}", "MutableSymbolTable", ".", "InvertedSymbolTable", "inputIds", "=", "fst", ".", "getInputSymbols", "(", ")", ".", "invert", "(", ")", ";", "MutableSymbolTable", ".", "InvertedSymbolTable", "outputIds", "=", "fst", ".", "getOutputSymbols", "(", ")", ".", "invert", "(", ")", ";", "numStates", "=", "fst", ".", "getStateCount", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "numStates", ";", "i", "++", ")", "{", "State", "s", "=", "fst", ".", "getState", "(", "i", ")", ";", "int", "numArcs", "=", "s", ".", "getArcCount", "(", ")", ";", "for", "(", "int", "j", "=", "0", ";", "j", "<", "numArcs", ";", "j", "++", ")", "{", "Arc", "arc", "=", "s", ".", "getArc", "(", "j", ")", ";", "String", "isym", ";", "String", "osym", ";", "if", "(", "useSymbolIdsInText", ")", "{", "isym", "=", "Integer", ".", "toString", "(", "arc", ".", "getIlabel", "(", ")", ")", ";", "osym", "=", "Integer", ".", "toString", "(", "arc", ".", "getOlabel", "(", ")", ")", ";", "}", "else", "{", "isym", "=", "inputIds", ".", "keyForId", "(", "arc", ".", "getIlabel", "(", ")", ")", ";", "osym", "=", "outputIds", ".", "keyForId", "(", "arc", ".", "getOlabel", "(", ")", ")", ";", "}", "out", ".", "println", "(", "s", ".", "getId", "(", ")", "+", "\"\\t\"", "+", "arc", ".", "getNextState", "(", ")", ".", "getId", "(", ")", "+", "\"\\t\"", "+", "isym", "+", "\"\\t\"", "+", "osym", "+", "\"\\t\"", "+", "arc", ".", "getWeight", "(", ")", ")", ";", "}", "}", "out", ".", "close", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "Throwables", ".", "propagate", "(", "e", ")", ";", "}", "}" ]

[ "Exports", "an", "fst", "to", "the", "openfst", "text", "format" ]