Datasets:

---

stojchet

/

base_prediction_dataset

like 0

[ "private", "Node", "makeNode", "(", "Random", "rng", ",", "int", "maxDepth", ")", "{", "if", "(", "functionProbability", ".", "nextEvent", "(", "rng", ")", "&&", "maxDepth", ">", "1", ")", "{", "// Max depth for sub-trees is one less than max depth for this node.", "int", "depth", "=", "maxDepth", "-", "1", ";", "switch", "(", "rng", ".", "nextInt", "(", "5", ")", ")", "{", "case", "0", ":", "return", "new", "Addition", "(", "makeNode", "(", "rng", ",", "depth", ")", ",", "makeNode", "(", "rng", ",", "depth", ")", ")", ";", "case", "1", ":", "return", "new", "Subtraction", "(", "makeNode", "(", "rng", ",", "depth", ")", ",", "makeNode", "(", "rng", ",", "depth", ")", ")", ";", "case", "2", ":", "return", "new", "Multiplication", "(", "makeNode", "(", "rng", ",", "depth", ")", ",", "makeNode", "(", "rng", ",", "depth", ")", ")", ";", "case", "3", ":", "return", "new", "IfThenElse", "(", "makeNode", "(", "rng", ",", "depth", ")", ",", "makeNode", "(", "rng", ",", "depth", ")", ",", "makeNode", "(", "rng", ",", "depth", ")", ")", ";", "default", ":", "return", "new", "IsGreater", "(", "makeNode", "(", "rng", ",", "depth", ")", ",", "makeNode", "(", "rng", ",", "depth", ")", ")", ";", "}", "}", "else", "if", "(", "parameterProbability", ".", "nextEvent", "(", "rng", ")", ")", "{", "return", "new", "Parameter", "(", "rng", ".", "nextInt", "(", "parameterCount", ")", ")", ";", "}", "else", "{", "return", "new", "Constant", "(", "rng", ".", "nextInt", "(", "11", ")", ")", ";", "}", "}" ]

[ "Recursively", "constructs", "a", "tree", "of", "Nodes", "up", "to", "the", "specified", "maximum", "depth", "." ]

[ "@", "Override", "public", "CPOptionValue", "fetchByC_K", "(", "long", "CPOptionId", ",", "String", "key", ")", "{", "return", "fetchByC_K", "(", "CPOptionId", ",", "key", ",", "true", ")", ";", "}" ]

[ "Returns", "the", "cp", "option", "value", "where", "CPOptionId", "=", "&#63", ";", "and", "key", "=", "&#63", ";", "or", "returns", "<code", ">", "null<", "/", "code", ">", "if", "it", "could", "not", "be", "found", ".", "Uses", "the", "finder", "cache", "." ]

[ "protected", "void", "formatMessage", "(", "String", "aID", ",", "Map", "<", "Object", ",", "Object", ">", "aBindValues", ")", "{", "Presenter", "presenter", "=", "Presenter", ".", "getPresenter", "(", "this", ".", "getClass", "(", ")", ")", ";", "message", "=", "presenter", ".", "getText", "(", "aID", ",", "aBindValues", ")", ";", "}" ]

[ "Format", "the", "exception", "message", "using", "the", "presenter", "getText", "method" ]

[ "public", "static", "NumberBinding", "divideSafe", "(", "ObservableValue", "<", "Number", ">", "dividend", ",", "ObservableValue", "<", "Number", ">", "divisor", ",", "ObservableValue", "<", "Number", ">", "defaultValue", ")", "{", "return", "Bindings", ".", "createDoubleBinding", "(", "(", ")", "->", "{", "if", "(", "divisor", ".", "getValue", "(", ")", ".", "doubleValue", "(", ")", "==", "0", ")", "{", "return", "defaultValue", ".", "getValue", "(", ")", ".", "doubleValue", "(", ")", ";", "}", "else", "{", "return", "dividend", ".", "getValue", "(", ")", ".", "doubleValue", "(", ")", "/", "divisor", ".", "getValue", "(", ")", ".", "doubleValue", "(", ")", ";", "}", "}", ",", "dividend", ",", "divisor", ")", ";", "}" ]

[ "An", "number", "binding", "of", "a", "division", "that", "won", "t", "throw", "an", "{", "@link", "java", ".", "lang", ".", "ArithmeticException", "}", "when", "a", "division", "by", "zero", "happens", ".", "See", "{", "@link", "#divideSafe", "(", "javafx", ".", "beans", ".", "value", ".", "ObservableIntegerValue", "javafx", ".", "beans", ".", "value", ".", "ObservableIntegerValue", ")", "}", "for", "more", "informations", "." ]

[ "public", "void", "zDrawTextFieldIndicators", "(", ")", "{", "if", "(", "!", "isEnabled", "(", ")", ")", "{", "// (Possibility: DisabledComponent)", "// Note: The time should always be validated (as if the component lost focus), before", "// the component is disabled.", "timeTextField", ".", "setBackground", "(", "new", "Color", "(", "240", ",", "240", ",", "240", ")", ")", ";", "timeTextField", ".", "setForeground", "(", "new", "Color", "(", "109", ",", "109", ",", "109", ")", ")", ";", "timeTextField", ".", "setFont", "(", "settings", ".", "fontValidTime", ")", ";", "return", ";", "}", "// Reset all atributes to normal before going further.", "// (Possibility: ValidFullOrEmptyValue)", "timeTextField", ".", "setBackground", "(", "settings", ".", "getColor", "(", "TimeArea", ".", "TextFieldBackgroundValidTime", ")", ")", ";", "timeTextField", ".", "setForeground", "(", "settings", ".", "getColor", "(", "TimeArea", ".", "TimePickerTextValidTime", ")", ")", ";", "timeTextField", ".", "setFont", "(", "settings", ".", "fontValidTime", ")", ";", "// Get the text, and check to see if it is empty.", "String", "timeText", "=", "timeTextField", ".", "getText", "(", ")", ";", "boolean", "textIsEmpty", "=", "timeText", ".", "trim", "(", ")", ".", "isEmpty", "(", ")", ";", "// Handle the various possibilities.", "if", "(", "textIsEmpty", ")", "{", "if", "(", "settings", ".", "getAllowEmptyTimes", "(", ")", ")", "{", "// (Possibility: ValidFullOrEmptyValue)", "}", "else", "{", "// (Possibility: DisallowedEmptyValue)", "timeTextField", ".", "setBackground", "(", "settings", ".", "getColor", "(", "TimeArea", ".", "TextFieldBackgroundDisallowedEmptyTime", ")", ")", ";", "}", "return", ";", "}", "// The text is not empty.", "LocalTime", "parsedTime", "=", "InternalUtilities", ".", "getParsedTimeOrNull", "(", "timeText", ",", "settings", ".", "getFormatForDisplayTime", "(", ")", ",", "settings", ".", "getFormatForMenuTimes", "(", ")", ",", "settings", ".", "formatsForParsing", ",", "settings", ".", "getLocale", "(", ")", ")", ";", "if", "(", "parsedTime", "==", "null", ")", "{", "// (Possibility: UnparsableValue)", "timeTextField", ".", "setBackground", "(", "settings", ".", "getColor", "(", "TimeArea", ".", "TextFieldBackgroundInvalidTime", ")", ")", ";", "timeTextField", ".", "setForeground", "(", "settings", ".", "getColor", "(", "TimeArea", ".", "TimePickerTextInvalidTime", ")", ")", ";", "timeTextField", ".", "setFont", "(", "settings", ".", "fontInvalidTime", ")", ";", "return", ";", "}", "// The text was parsed to a value.", "TimeVetoPolicy", "vetoPolicy", "=", "settings", ".", "getVetoPolicy", "(", ")", ";", "boolean", "isTimeVetoed", "=", "InternalUtilities", ".", "isTimeVetoed", "(", "vetoPolicy", ",", "parsedTime", ")", ";", "if", "(", "isTimeVetoed", ")", "{", "// (Possibility: VetoedValue)", "timeTextField", ".", "setBackground", "(", "settings", ".", "getColor", "(", "TimeArea", ".", "TextFieldBackgroundVetoedTime", ")", ")", ";", "timeTextField", ".", "setForeground", "(", "settings", ".", "getColor", "(", "TimeArea", ".", "TimePickerTextVetoedTime", ")", ")", ";", "timeTextField", ".", "setFont", "(", "settings", ".", "fontVetoedTime", ")", ";", "}", "}" ]

[ "zDrawTextFieldIndicators", "This", "will", "draw", "the", "text", "field", "indicators", "to", "indicate", "to", "the", "user", "the", "state", "of", "any", "text", "in", "the", "text", "field", "including", "the", "validity", "of", "any", "time", "that", "has", "been", "typed", ".", "The", "text", "field", "indicators", "include", "the", "text", "field", "background", "color", "foreground", "color", "font", "color", "and", "font", "." ]

[ "public", "static", "void", "lazyInsertBefore", "(", "Element", "newElement", ",", "Element", "before", ")", "{", "if", "(", "!", "before", ".", "parentNode", ".", "contains", "(", "newElement", ")", ")", "{", "before", ".", "parentNode", ".", "insertBefore", "(", "newElement", ",", "before", ")", ";", "}", "}" ]

[ "Inserts", "the", "specified", "element", "into", "the", "parent", "of", "the", "before", "element", "if", "not", "already", "present", ".", "If", "parent", "already", "contains", "child", "this", "method", "does", "nothing", "." ]

[ "public", "static", "int", "nextClearBit", "(", "long", "v", ",", "int", "start", ")", "{", "if", "(", "start", ">=", "Long", ".", "SIZE", ")", "{", "return", "-", "1", ";", "}", "start", "=", "start", "<", "0", "?", "0", ":", "start", ";", "long", "cur", "=", "~", "v", "&", "(", "LONG_ALL_BITS", "<<", "start", ")", ";", "return", "cur", "==", "0", "?", "-", "1", ":", "Long", ".", "numberOfTrailingZeros", "(", "cur", ")", ";", "}" ]

[ "Find", "the", "next", "clear", "bit", "." ]

[ "public", "Element", "getWithData", "(", "Ehcache", "cache", ",", "Object", "key", ",", "A", "data", ")", "{", "this", ".", "threadData", ".", "set", "(", "data", ")", ";", "try", "{", "return", "cache", ".", "get", "(", "key", ")", ";", "}", "finally", "{", "this", ".", "threadData", ".", "remove", "(", ")", ";", "}", "}" ]

[ "Wraps", "an", "{" ]

[ "public", "V", "get", "(", "K", "key", ",", "Callable", "<", "V", ">", "callable", ")", "{", "Future", "<", "V", ">", "future", "=", "concurrentMap", ".", "get", "(", "key", ")", ";", "if", "(", "future", "==", "null", ")", "{", "FutureTask", "<", "V", ">", "futureTask", "=", "new", "FutureTask", "<", "V", ">", "(", "callable", ")", ";", "future", "=", "concurrentMap", ".", "putIfAbsent", "(", "key", ",", "futureTask", ")", ";", "if", "(", "future", "==", "null", ")", "{", "future", "=", "futureTask", ";", "futureTask", ".", "run", "(", ")", ";", "}", "}", "try", "{", "// 此时阻塞", "return", "future", ".", "get", "(", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "concurrentMap", ".", "remove", "(", "key", ")", ";", "return", "null", ";", "}", "}" ]

[ "通过关键字获取数据，如果存在则直接返回，如果不存在，则通过计算<code", ">", "callable<", "/", "code", ">", "来生成" ]

[ "public", "void", "writeSFixed64", "(", "final", "int", "fieldNumber", ",", "final", "long", "value", ")", "throws", "IOException", "{", "writeTag", "(", "fieldNumber", ",", "WireFormat", ".", "WIRETYPE_FIXED64", ")", ";", "writeSFixed64NoTag", "(", "value", ")", ";", "}" ]

[ "Write", "an", "{" ]

[ "public", "static", "Pattern", "neighborOf", "(", ")", "{", "Pattern", "p", "=", "new", "Pattern", "(", "SequenceEntityReference", ".", "class", ",", "\"Protein 1\"", ")", ";", "p", ".", "add", "(", "linkedER", "(", "true", ")", ",", "\"Protein 1\"", ",", "\"generic Protein 1\"", ")", ";", "p", ".", "add", "(", "erToPE", "(", ")", ",", "\"generic Protein 1\"", ",", "\"SPE1\"", ")", ";", "p", ".", "add", "(", "linkToComplex", "(", ")", ",", "\"SPE1\"", ",", "\"PE1\"", ")", ";", "p", ".", "add", "(", "peToInter", "(", ")", ",", "\"PE1\"", ",", "\"Inter\"", ")", ";", "p", ".", "add", "(", "interToPE", "(", ")", ",", "\"Inter\"", ",", "\"PE2\"", ")", ";", "p", ".", "add", "(", "linkToSpecific", "(", ")", ",", "\"PE2\"", ",", "\"SPE2\"", ")", ";", "p", ".", "add", "(", "equal", "(", "false", ")", ",", "\"SPE1\"", ",", "\"SPE2\"", ")", ";", "p", ".", "add", "(", "type", "(", "SequenceEntity", ".", "class", ")", ",", "\"SPE2\"", ")", ";", "p", ".", "add", "(", "peToER", "(", ")", ",", "\"SPE2\"", ",", "\"generic Protein 2\"", ")", ";", "p", ".", "add", "(", "linkedER", "(", "false", ")", ",", "\"generic Protein 2\"", ",", "\"Protein 2\"", ")", ";", "p", ".", "add", "(", "equal", "(", "false", ")", ",", "\"Protein 1\"", ",", "\"Protein 2\"", ")", ";", "return", "p", ";", "}" ]

[ "Constructs", "a", "pattern", "where", "first", "and", "last", "proteins", "are", "related", "through", "an", "interaction", ".", "They", "can", "be", "participants", "or", "controllers", ".", "No", "limitation", "." ]

[ "public", "Request", "setContent", "(", "String", "text", ",", "ContentType", "contentType", ")", "{", "entity", "=", "new", "StringEntity", "(", "text", ",", "contentType", ")", ";", "return", "this", ";", "}" ]

[ "set", "request", "content", "from", "input", "text", "string", "with", "given", "content", "type" ]

[ "public", "void", "updateInt", "(", "int", "columnIndex", ",", "int", "x", ")", "throws", "SQLException", "{", "startUpdate", "(", "columnIndex", ")", ";", "preparedStatement", ".", "setIntParameter", "(", "columnIndex", ",", "x", ")", ";", "}" ]

[ "<!", "--", "start", "generic", "documentation", "--", ">", "Updates", "the", "designated", "column", "with", "an", "<code", ">", "int<", "/", "code", ">", "value", ".", "The", "updater", "methods", "are", "used", "to", "update", "column", "values", "in", "the", "current", "row", "or", "the", "insert", "row", ".", "The", "updater", "methods", "do", "not", "update", "the", "underlying", "database", ";", "instead", "the", "<code", ">", "updateRow<", "/", "code", ">", "or", "<code", ">", "insertRow<", "/", "code", ">", "methods", "are", "called", "to", "update", "the", "database", ".", "<!", "--", "end", "generic", "documentation", "--", ">" ]

[ "@", "SuppressWarnings", "(", "\"rawtypes\"", ")", "public", "static", "<", "E", "extends", "Exception", ">", "DataSet", "loadCSV", "(", "final", "File", "csvFile", ",", "final", "long", "offset", ",", "final", "long", "count", ",", "final", "Try", ".", "Predicate", "<", "String", "[", "]", ",", "E", ">", "filter", ",", "final", "Map", "<", "String", ",", "?", "extends", "Type", ">", "columnTypeMap", ")", "throws", "UncheckedIOException", ",", "E", "{", "InputStream", "csvInputStream", "=", "null", ";", "try", "{", "csvInputStream", "=", "new", "FileInputStream", "(", "csvFile", ")", ";", "return", "loadCSV", "(", "csvInputStream", ",", "offset", ",", "count", ",", "filter", ",", "columnTypeMap", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "new", "UncheckedIOException", "(", "e", ")", ";", "}", "finally", "{", "IOUtil", ".", "closeQuietly", "(", "csvInputStream", ")", ";", "}", "}" ]

[ "Load", "the", "data", "from", "CSV", ".", "@param", "csvFile", "@param", "offset", "@param", "count", "@param", "filter", "@param", "columnTypeMap" ]

[ "protected", "void", "invokeCall", "(", "RTMPConnection", "conn", ",", "IServiceCall", "call", ")", "{", "final", "IScope", "scope", "=", "conn", ".", "getScope", "(", ")", ";", "if", "(", "scope", "!=", "null", ")", "{", "if", "(", "scope", ".", "hasHandler", "(", ")", ")", "{", "final", "IScopeHandler", "handler", "=", "scope", ".", "getHandler", "(", ")", ";", "log", ".", "debug", "(", "\"Scope: {} handler: {}\"", ",", "scope", ",", "handler", ")", ";", "if", "(", "!", "handler", ".", "serviceCall", "(", "conn", ",", "call", ")", ")", "{", "// XXX: What to do here? Return an error?\r", "log", ".", "warn", "(", "\"Scope: {} handler failed on service call\"", ",", "scope", ".", "getName", "(", ")", ",", "new", "Exception", "(", "\"Service call failed\"", ")", ")", ";", "return", ";", "}", "}", "final", "IContext", "context", "=", "scope", ".", "getContext", "(", ")", ";", "log", ".", "debug", "(", "\"Context: {}\"", ",", "context", ")", ";", "context", ".", "getServiceInvoker", "(", ")", ".", "invoke", "(", "call", ",", "scope", ")", ";", "}", "else", "{", "log", ".", "warn", "(", "\"Scope was null for invoke: {} connection state: {}\"", ",", "call", ".", "getServiceMethodName", "(", ")", ",", "conn", ".", "getStateCode", "(", ")", ")", ";", "}", "}" ]

[ "Remoting", "call", "invocation", "handler", "." ]

[ "private", "void", "addDateRange", "(", "ProjectCalendarHours", "hours", ",", "Date", "start", ",", "Date", "end", ")", "{", "if", "(", "start", "!=", "null", "&&", "end", "!=", "null", ")", "{", "Calendar", "cal", "=", "DateHelper", ".", "popCalendar", "(", "end", ")", ";", "// If the time ends on midnight, the date should be the next day. Otherwise problems occur.", "if", "(", "cal", ".", "get", "(", "Calendar", ".", "HOUR_OF_DAY", ")", "==", "0", "&&", "cal", ".", "get", "(", "Calendar", ".", "MINUTE", ")", "==", "0", "&&", "cal", ".", "get", "(", "Calendar", ".", "SECOND", ")", "==", "0", "&&", "cal", ".", "get", "(", "Calendar", ".", "MILLISECOND", ")", "==", "0", ")", "{", "cal", ".", "add", "(", "Calendar", ".", "DAY_OF_YEAR", ",", "1", ")", ";", "}", "end", "=", "cal", ".", "getTime", "(", ")", ";", "DateHelper", ".", "pushCalendar", "(", "cal", ")", ";", "hours", ".", "addRange", "(", "new", "DateRange", "(", "start", ",", "end", ")", ")", ";", "}", "}" ]

[ "Get", "a", "date", "range", "that", "correctly", "handles", "the", "case", "where", "the", "end", "time", "is", "midnight", ".", "In", "this", "instance", "the", "end", "time", "should", "be", "the", "start", "of", "the", "next", "day", "." ]

[ "public", "void", "insertNodeAfter", "(", "Node", "insert", ",", "Node", "after", ",", "double", "split", ")", "{", "addChild", "(", "insert", ",", "children", ".", "indexOf", "(", "after", ")", "+", "1", ",", "split", ")", ";", "notifyStateChange", "(", ")", ";", "}" ]

[ "Inserts", "a", "node", "after", "(", "right", "of", "or", "bottom", "of", ")", "a", "given", "node", "by", "splitting", "the", "inserted", "node", "with", "the", "given", "node", "." ]

[ "private", "void", "sawLoad", "(", "int", "seen", ",", "int", "pc", ")", "{", "int", "reg", "=", "RegisterUtils", ".", "getLoadReg", "(", "this", ",", "seen", ")", ";", "if", "(", "!", "ignoreRegs", ".", "get", "(", "reg", ")", ")", "{", "ScopeBlock", "sb", "=", "findScopeBlock", "(", "rootScopeBlock", ",", "pc", ")", ";", "if", "(", "sb", "!=", "null", ")", "{", "sb", ".", "addLoad", "(", "reg", ",", "pc", ")", ";", "}", "else", "{", "ignoreRegs", ".", "set", "(", "reg", ")", ";", "}", "}", "}" ]

[ "processes", "a", "register", "store", "by", "updating", "the", "appropriate", "scope", "block", "to", "mark", "this", "register", "as", "being", "read", "in", "the", "block" ]

[ "public", "final", "Morpheme", "createMorpheme", "(", "final", "String", "word", ",", "final", "String", "tag", ")", "{", "final", "Morpheme", "morpheme", "=", "new", "Morpheme", "(", ")", ";", "morpheme", ".", "setValue", "(", "word", ")", ";", "morpheme", ".", "setTag", "(", "tag", ")", ";", "return", "morpheme", ";", "}" ]

[ "Construct", "morpheme", "object", "with", "word", "and", "morphological", "tag", "." ]

[ "public", "static", "ConstructorBuilder", "getInstance", "(", "Context", "context", ",", "TypeElement", "typeElement", ",", "ConstructorWriter", "writer", ")", "{", "return", "new", "ConstructorBuilder", "(", "context", ",", "typeElement", ",", "writer", ")", ";", "}" ]

[ "Construct", "a", "new", "ConstructorBuilder", "." ]

[ "public", "Entry", "addEntry", "(", "final", "Entry", "entry", ")", "throws", "Exception", "{", "synchronized", "(", "FileStore", ".", "getFileStore", "(", ")", ")", "{", "final", "Feed", "f", "=", "getFeedDocument", "(", ")", ";", "final", "String", "fsid", "=", "FileStore", ".", "getFileStore", "(", ")", ".", "getNextId", "(", ")", ";", "updateTimestamps", "(", "entry", ")", ";", "// Save entry to file", "final", "String", "entryPath", "=", "getEntryPath", "(", "fsid", ")", ";", "final", "OutputStream", "os", "=", "FileStore", ".", "getFileStore", "(", ")", ".", "getFileOutputStream", "(", "entryPath", ")", ";", "updateEntryAppLinks", "(", "entry", ",", "fsid", ",", "true", ")", ";", "Atom10Generator", ".", "serializeEntry", "(", "entry", ",", "new", "OutputStreamWriter", "(", "os", ",", "\"UTF-8\"", ")", ")", ";", "os", ".", "flush", "(", ")", ";", "os", ".", "close", "(", ")", ";", "// Update feed file", "updateEntryAppLinks", "(", "entry", ",", "fsid", ",", "false", ")", ";", "updateFeedDocumentWithNewEntry", "(", "f", ",", "entry", ")", ";", "return", "entry", ";", "}", "}" ]

[ "Add", "entry", "to", "collection", "." ]

[ "public", "final", "void", "addItem", "(", "@", "Nullable", "final", "CharSequence", "title", ",", "@", "NonNull", "final", "Class", "<", "?", "extends", "Fragment", ">", "fragmentClass", ",", "@", "Nullable", "final", "Bundle", "arguments", ")", "{", "Condition", ".", "INSTANCE", ".", "ensureNotNull", "(", "fragmentClass", ",", "\"The fragment class may not be null\"", ")", ";", "items", ".", "add", "(", "new", "ViewPagerItem", "(", "title", ",", "fragmentClass", ",", "arguments", ")", ")", ";", "notifyDataSetChanged", "(", ")", ";", "}" ]

[ "Adds", "a", "new", "fragment", "to", "the", "adapter", "." ]

[ "public", "String", "getSenderName", "(", ")", "{", "String", "value", "=", "null", ";", "try", "{", "value", "=", "this", ".", "JOB", ".", "getFromUser", "(", ")", ";", "}", "catch", "(", "Exception", "exception", ")", "{", "throw", "new", "FaxException", "(", "\"Error while extracting job sender name.\"", ",", "exception", ")", ";", "}", "return", "value", ";", "}" ]

[ "This", "function", "returns", "the", "fax", "job", "sender", "name", "." ]

[ "private", "Node", "maybeReplaceChildWithNumber", "(", "Node", "n", ",", "Node", "parent", ",", "int", "num", ")", "{", "Node", "newNode", "=", "IR", ".", "number", "(", "num", ")", ";", "if", "(", "!", "newNode", ".", "isEquivalentTo", "(", "n", ")", ")", "{", "parent", ".", "replaceChild", "(", "n", ",", "newNode", ")", ";", "reportChangeToEnclosingScope", "(", "newNode", ")", ";", "markFunctionsDeleted", "(", "n", ")", ";", "return", "newNode", ";", "}", "return", "n", ";", "}" ]

[ "Replaces", "a", "node", "with", "a", "number", "node", "if", "the", "new", "number", "node", "is", "not", "equivalent", "to", "the", "current", "node", "." ]

[ "public", "OvhPcsFile", "billingAccount_historyConsumption_date_file_GET", "(", "String", "billingAccount", ",", "java", ".", "util", ".", "Date", "date", ",", "OvhBillDocument", "extension", ")", "throws", "IOException", "{", "String", "qPath", "=", "\"/telephony/{billingAccount}/historyConsumption/{date}/file\"", ";", "StringBuilder", "sb", "=", "path", "(", "qPath", ",", "billingAccount", ",", "date", ")", ";", "query", "(", "sb", ",", "\"extension\"", ",", "extension", ")", ";", "String", "resp", "=", "exec", "(", "qPath", ",", "\"GET\"", ",", "sb", ".", "toString", "(", ")", ",", "null", ")", ";", "return", "convertTo", "(", "resp", ",", "OvhPcsFile", ".", "class", ")", ";", "}" ]

[ "Previous", "billed", "consumption", "files" ]

[ "public", "ClientResponse", "updateApplicationCatalog", "(", "File", "catalogPath", ",", "File", "deploymentPath", ")", "throws", "IOException", ",", "NoConnectionsException", ",", "ProcCallException", "{", "ClientImpl", "currentClient", "=", "this", ".", "getClient", "(", ")", ";", "try", "{", "return", "currentClient", ".", "updateApplicationCatalog", "(", "catalogPath", ",", "deploymentPath", ")", ";", "}", "catch", "(", "NoConnectionsException", "e", ")", "{", "this", ".", "dropClient", "(", "currentClient", ")", ";", "throw", "e", ";", "}", "}" ]

[ "Synchronously", "invokes", "UpdateApplicationCatalog", "procedure", ".", "Blocks", "until", "a", "result", "is", "available", ".", "A", "{", "@link", "ProcCallException", "}", "is", "thrown", "if", "the", "response", "is", "anything", "other", "then", "success", "." ]

[ "public", "static", "IntStreamEx", "rangeClosed", "(", "int", "startInclusive", ",", "int", "endInclusive", ",", "int", "step", ")", "{", "if", "(", "step", "==", "0", ")", "throw", "new", "IllegalArgumentException", "(", "\"step = 0\"", ")", ";", "if", "(", "step", "==", "1", ")", "return", "seq", "(", "IntStream", ".", "rangeClosed", "(", "startInclusive", ",", "endInclusive", ")", ")", ";", "if", "(", "step", "==", "-", "1", ")", "{", "// Handled specially as number of elements can exceed", "// Integer.MAX_VALUE", "int", "sum", "=", "endInclusive", "+", "startInclusive", ";", "return", "seq", "(", "IntStream", ".", "rangeClosed", "(", "endInclusive", ",", "startInclusive", ")", ".", "map", "(", "x", "->", "sum", "-", "x", ")", ")", ";", "}", "if", "(", "endInclusive", ">", "startInclusive", "^", "step", ">", "0", ")", "return", "empty", "(", ")", ";", "int", "limit", "=", "(", "endInclusive", "-", "startInclusive", ")", "*", "Integer", ".", "signum", "(", "step", ")", ";", "limit", "=", "Integer", ".", "divideUnsigned", "(", "limit", ",", "Math", ".", "abs", "(", "step", ")", ")", ";", "return", "seq", "(", "IntStream", ".", "rangeClosed", "(", "0", ",", "limit", ")", ".", "map", "(", "x", "->", "x", "*", "step", "+", "startInclusive", ")", ")", ";", "}" ]

[ "Returns", "a", "sequential", "ordered", "{", "@code", "IntStreamEx", "}", "from", "{", "@code", "startInclusive", "}", "(", "inclusive", ")", "to", "{", "@code", "endInclusive", "}", "(", "inclusive", ")", "by", "the", "specified", "incremental", "step", ".", "The", "negative", "step", "values", "are", "also", "supported", ".", "In", "this", "case", "the", "{", "@code", "startInclusive", "}", "should", "be", "greater", "than", "{", "@code", "endInclusive", "}", "." ]

[ "private", "boolean", "isNotPresentDisplayedEnabledInput", "(", "String", "action", ",", "String", "expected", ",", "String", "extra", ")", "{", "// wait for element to be present", "if", "(", "isNotPresent", "(", "action", ",", "expected", ",", "extra", ")", ")", "{", "return", "true", ";", "}", "// wait for element to be displayed", "if", "(", "isNotDisplayed", "(", "action", ",", "expected", ",", "extra", ")", ")", "{", "return", "true", ";", "}", "// wait for element to be enabled", "return", "isNotEnabled", "(", "action", ",", "expected", ",", "extra", ")", "||", "isNotInput", "(", "action", ",", "expected", ",", "extra", ")", ";", "}" ]

[ "Determines", "if", "something", "is", "present", "displayed", "enabled", "and", "an", "input", ".", "This", "returns", "true", "if", "all", "four", "are", "true", "otherwise", "it", "returns", "false" ]

[ "public", "Content", "getTagletOutput", "(", "Element", "element", ",", "DocTree", "tag", ",", "TagletWriter", "writer", ")", "{", "throw", "new", "UnsupportedTagletOperationException", "(", "\"Method not supported in taglet \"", "+", "getName", "(", ")", "+", "\".\"", ")", ";", "}" ]

[ "{" ]

[ "protected", "final", "boolean", "checkTTC", "(", "FontFileReader", "in", ",", "String", "name", ")", "throws", "IOException", "{", "String", "tag", "=", "in", ".", "readTTFString", "(", "4", ")", ";", "if", "(", "\"ttcf\"", ".", "equals", "(", "tag", ")", ")", "{", "// This is a TrueType Collection", "in", ".", "skip", "(", "4", ")", ";", "// Read directory offsets", "int", "numDirectories", "=", "(", "int", ")", "in", ".", "readTTFULong", "(", ")", ";", "// int numDirectories=in.readTTFUShort();", "long", "[", "]", "dirOffsets", "=", "new", "long", "[", "numDirectories", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "numDirectories", ";", "i", "++", ")", "{", "dirOffsets", "[", "i", "]", "=", "in", ".", "readTTFULong", "(", ")", ";", "}", "log", ".", "info", "(", "\"This is a TrueType collection file with \"", "+", "numDirectories", "+", "\" fonts\"", ")", ";", "log", ".", "info", "(", "\"Containing the following fonts: \"", ")", ";", "// Read all the directories and name tables to check", "// If the font exists - this is a bit ugly, but...", "boolean", "found", "=", "false", ";", "// Iterate through all name tables even if font", "// Is found, just to show all the names", "long", "dirTabOffset", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "(", "i", "<", "numDirectories", ")", ";", "i", "++", ")", "{", "in", ".", "seekSet", "(", "dirOffsets", "[", "i", "]", ")", ";", "readDirTabs", "(", "in", ")", ";", "readName", "(", "in", ")", ";", "if", "(", "fullName", ".", "equals", "(", "name", ")", ")", "{", "found", "=", "true", ";", "dirTabOffset", "=", "dirOffsets", "[", "i", "]", ";", "log", ".", "info", "(", "fullName", "+", "\" <-- selected\"", ")", ";", "}", "else", "{", "log", ".", "info", "(", "fullName", ")", ";", "}", "// Reset names", "notice", "=", "\"\"", ";", "fullName", "=", "\"\"", ";", "familyName", "=", "\"\"", ";", "fontName", "=", "\"\"", ";", "subFamilyName", "=", "\"\"", ";", "}", "in", ".", "seekSet", "(", "dirTabOffset", ")", ";", "return", "found", ";", "}", "else", "{", "in", ".", "seekSet", "(", "0", ")", ";", "return", "true", ";", "}", "}" ]

[ "Check", "if", "this", "is", "a", "TrueType", "collection", "and", "that", "the", "given", "name", "exists", "in", "the", "collection", ".", "If", "it", "does", "set", "offset", "in", "fontfile", "to", "the", "beginning", "of", "the", "Table", "Directory", "for", "that", "font", "." ]

[ "@", "Override", "protected", "int", "calculateTabWidth", "(", "final", "int", "tabPlacement", ",", "final", "int", "tabIndex", ",", "final", "FontMetrics", "metrics", ")", "{", "if", "(", "_pane", ".", "getSeparators", "(", ")", ".", "contains", "(", "tabIndex", ")", ")", "{", "return", "SEPARATOR_WIDTH", ";", "}", "int", "width", "=", "super", ".", "calculateTabWidth", "(", "tabPlacement", ",", "tabIndex", ",", "metrics", ")", ";", "if", "(", "!", "_pane", ".", "getUnclosables", "(", ")", ".", "contains", "(", "tabIndex", ")", ")", "{", "width", "+=", "CLOSE_ICON_WIDTH", ";", "}", "return", "width", ";", "}" ]

[ "Override", "this", "to", "provide", "extra", "space", "on", "right", "for", "close", "button" ]

[ "public", "static", "double", "getRandomDouble", "(", "double", "min", ",", "double", "max", ")", "{", "Random", "r", "=", "new", "Random", "(", ")", ";", "return", "min", "+", "(", "max", "-", "min", ")", "*", "r", ".", "nextDouble", "(", ")", ";", "}" ]

[ "Returns", "a", "random", "double", "between", "MIN", "inclusive", "and", "MAX", "inclusive", "." ]

[ "public", "CreateInstanceResponse", "createInstance", "(", "CreateInstanceRequest", "request", ")", "throws", "BceClientException", "{", "checkNotNull", "(", "request", ",", "\"request should not be null.\"", ")", ";", "if", "(", "Strings", ".", "isNullOrEmpty", "(", "request", ".", "getClientToken", "(", ")", ")", ")", "{", "request", ".", "setClientToken", "(", "this", ".", "generateClientToken", "(", ")", ")", ";", "}", "if", "(", "null", "==", "request", ".", "getBilling", "(", ")", ")", "{", "request", ".", "setBilling", "(", "generateDefaultBilling", "(", ")", ")", ";", "}", "checkStringNotEmpty", "(", "request", ".", "getImageId", "(", ")", ",", "\"imageId should not be empty\"", ")", ";", "InternalRequest", "internalRequest", "=", "this", ".", "createRequest", "(", "request", ",", "HttpMethodName", ".", "POST", ",", "INSTANCE_PREFIX", ")", ";", "internalRequest", ".", "addParameter", "(", "\"clientToken\"", ",", "request", ".", "getClientToken", "(", ")", ")", ";", "if", "(", "!", "Strings", ".", "isNullOrEmpty", "(", "request", ".", "getAdminPass", "(", ")", ")", ")", "{", "BceCredentials", "credentials", "=", "config", ".", "getCredentials", "(", ")", ";", "if", "(", "internalRequest", ".", "getCredentials", "(", ")", "!=", "null", ")", "{", "credentials", "=", "internalRequest", ".", "getCredentials", "(", ")", ";", "}", "try", "{", "request", ".", "setAdminPass", "(", "this", ".", "aes128WithFirst16Char", "(", "request", ".", "getAdminPass", "(", ")", ",", "credentials", ".", "getSecretKey", "(", ")", ")", ")", ";", "}", "catch", "(", "GeneralSecurityException", "e", ")", "{", "throw", "new", "BceClientException", "(", "\"Encryption procedure exception\"", ",", "e", ")", ";", "}", "}", "fillPayload", "(", "internalRequest", ",", "request", ")", ";", "return", "invokeHttpClient", "(", "internalRequest", ",", "CreateInstanceResponse", ".", "class", ")", ";", "}" ]

[ "Create", "a", "bcc", "Instance", "with", "the", "specified", "options", "see", "all", "the", "supported", "instance", "in", "{", "@link", "com", ".", "baidubce", ".", "services", ".", "bcc", ".", "model", ".", "instance", ".", "InstanceType", "}", "You", "must", "fill", "the", "field", "of", "clientToken", "which", "is", "especially", "for", "keeping", "idempotent", "." ]

[ "public", "Observable", "<", "Void", ">", "resetAsync", "(", "String", "resourceGroupName", ",", "String", "accountName", ",", "String", "liveEventName", ")", "{", "return", "resetWithServiceResponseAsync", "(", "resourceGroupName", ",", "accountName", ",", "liveEventName", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "Void", ">", ",", "Void", ">", "(", ")", "{", "@", "Override", "public", "Void", "call", "(", "ServiceResponse", "<", "Void", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Reset", "Live", "Event", ".", "Resets", "an", "existing", "Live", "Event", "." ]

[ "public", "final", "BigDecimal", "getDecimal", "(", "final", "int", "pos", ",", "final", "int", "precision", ",", "final", "int", "scale", ")", "{", "final", "int", "intg", "=", "precision", "-", "scale", ";", "final", "int", "frac", "=", "scale", ";", "final", "int", "intg0", "=", "intg", "/", "DIG_PER_INT32", ";", "final", "int", "frac0", "=", "frac", "/", "DIG_PER_INT32", ";", "final", "int", "intg0x", "=", "intg", "-", "intg0", "*", "DIG_PER_INT32", ";", "final", "int", "frac0x", "=", "frac", "-", "frac0", "*", "DIG_PER_INT32", ";", "final", "int", "binSize", "=", "intg0", "*", "SIZE_OF_INT32", "+", "dig2bytes", "[", "intg0x", "]", "+", "frac0", "*", "SIZE_OF_INT32", "+", "dig2bytes", "[", "frac0x", "]", ";", "if", "(", "pos", "+", "binSize", ">", "limit", "||", "pos", "<", "0", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"limit excceed: \"", "+", "(", "pos", "<", "0", "?", "pos", ":", "(", "pos", "+", "binSize", ")", ")", ")", ";", "}", "return", "getDecimal0", "(", "origin", "+", "pos", ",", "intg", ",", "frac", ",", "// NL\r", "intg0", ",", "frac0", ",", "intg0x", ",", "frac0x", ")", ";", "}" ]

[ "Return", "big", "decimal", "from", "buffer", "." ]

[ "protected", "void", "writeParamsEntry", "(", "StringBuilder", "sb", ",", "ExecutionInfo", "execInfo", ",", "List", "<", "QueryInfo", ">", "queryInfoList", ")", "{", "boolean", "isPrepared", "=", "execInfo", ".", "getStatementType", "(", ")", "==", "StatementType", ".", "PREPARED", ";", "sb", ".", "append", "(", "\"Params:[\"", ")", ";", "for", "(", "QueryInfo", "queryInfo", ":", "queryInfoList", ")", "{", "for", "(", "List", "<", "ParameterSetOperation", ">", "parameters", ":", "queryInfo", ".", "getParametersList", "(", ")", ")", "{", "SortedMap", "<", "String", ",", "String", ">", "paramMap", "=", "getParametersToDisplay", "(", "parameters", ")", ";", "// parameters per batch.", "// for prepared: (val1,val2,...)", "// for callable: (key1=val1,key2=val2,...)", "if", "(", "isPrepared", ")", "{", "writeParamsForSinglePreparedEntry", "(", "sb", ",", "paramMap", ",", "execInfo", ",", "queryInfoList", ")", ";", "}", "else", "{", "writeParamsForSingleCallableEntry", "(", "sb", ",", "paramMap", ",", "execInfo", ",", "queryInfoList", ")", ";", "}", "}", "}", "chompIfEndWith", "(", "sb", ",", "'", "'", ")", ";", "sb", ".", "append", "(", "\"]\"", ")", ";", "}" ]

[ "Write", "query", "parameters", "." ]

[ "public", "void", "setXi", "(", "double", "xi", ")", "{", "if", "(", "xi", "<=", "0", "||", "xi", ">=", "1", "||", "Double", ".", "isNaN", "(", "xi", ")", ")", "throw", "new", "ArithmeticException", "(", "\"xi must be in the range (0, 1) not \"", "+", "xi", ")", ";", "this", ".", "xi", "=", "xi", ";", "this", ".", "one_min_xi", "=", "1.0", "-", "xi", ";", "}" ]

[ "Sets", "the", "xi", "value", "used", "in", "{", "@link", "ExtractionMethod#XI_STEEP_ORIGINAL", "}", "to", "produce", "cluster", "results", "." ]

[ "public", "void", "shutdown", "(", ")", "{", "if", "(", "m_done", ".", "compareAndSet", "(", "false", ",", "true", ")", ")", "{", "m_es", ".", "shutdown", "(", ")", ";", "m_buses", ".", "shutdown", "(", ")", ";", "DeleteNode", "deleteHost", "=", "new", "DeleteNode", "(", "joinZKPath", "(", "HOST_DN", ",", "m_hostId", ")", ")", ";", "DeleteNode", "deleteCandidate", "=", "new", "DeleteNode", "(", "m_candidate", ")", ";", "try", "{", "m_es", ".", "awaitTermination", "(", "365", ",", "TimeUnit", ".", "DAYS", ")", ";", "}", "catch", "(", "InterruptedException", "e", ")", "{", "throw", "loggedDistributerException", "(", "e", ",", "\"interrupted while waiting for executor termination\"", ")", ";", "}", "try", "{", "m_buses", ".", "awaitTermination", "(", "365", ",", "TimeUnit", ".", "DAYS", ")", ";", "}", "catch", "(", "InterruptedException", "e", ")", "{", "throw", "loggedDistributerException", "(", "e", ",", "\"interrupted while waiting for executor termination\"", ")", ";", "}", "deleteHost", ".", "onComplete", "(", ")", ";", "deleteCandidate", ".", "onComplete", "(", ")", ";", "}", "}" ]

[ "Sets", "the", "done", "flag", "shuts", "down", "its", "executor", "thread", "and", "deletes", "its", "own", "host", "and", "candidate", "nodes" ]

[ "@", "Override", "public", "void", "eventCallback", "(", "String", "eventName", ",", "Object", "eventData", ")", "{", "for", "(", "IActionTarget", "target", ":", "new", "ArrayList", "<>", "(", "targets", ")", ")", "{", "try", "{", "target", ".", "doAction", "(", "action", ")", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "}", "}", "}" ]

[ "This", "is", "the", "callback", "for", "the", "generic", "event", "that", "is", "monitored", "by", "this", "listener", ".", "It", "will", "result", "in", "the", "invocation", "of", "the", "doAction", "method", "of", "each", "bound", "action", "target", "." ]

[ "public", "static", "UnsupportedOperationException", "newUnsupportedOperationException", "(", "Throwable", "cause", ",", "String", "message", ",", "Object", "...", "args", ")", "{", "return", "new", "UnsupportedOperationException", "(", "format", "(", "message", ",", "args", ")", ",", "cause", ")", ";", "}" ]

[ "Constructs", "and", "initializes", "a", "new", "{", "@link", "UnsupportedOperationException", "}", "with", "the", "given", "{", "@link", "Throwable", "cause", "}", "and", "{", "@link", "String", "message", "}", "formatted", "with", "the", "given", "{", "@link", "Object", "[]", "arguments", "}", "." ]

[ "public", "void", "buildContent", "(", "XMLNode", "node", ",", "Content", "contentTree", ")", "{", "Content", "profileContentTree", "=", "profileWriter", ".", "getContentHeader", "(", ")", ";", "buildChildren", "(", "node", ",", "profileContentTree", ")", ";", "contentTree", ".", "addContent", "(", "profileContentTree", ")", ";", "}" ]

[ "Build", "the", "content", "for", "the", "profile", "doc", "." ]

[ "public", "String", "getDeployedViewURI", "(", "String", "controllerName", ",", "String", "viewName", ")", "{", "FastStringWriter", "buf", "=", "new", "FastStringWriter", "(", "PATH_TO_VIEWS", ")", ";", "return", "getViewURIInternal", "(", "controllerName", ",", "viewName", ",", "buf", ",", "true", ")", ";", "}" ]

[ "Obtains", "a", "view", "URI", "when", "deployed", "within", "the", "/", "WEB", "-", "INF", "/", "grails", "-", "app", "/", "views", "context" ]

[ "public", "void", "callRpcChecked", "(", "S", "request", ",", "RpcResponseHandler", "<", "?", "extends", "T", ">", "responseHandler", ")", "throws", "IOException", "{", "callRpcChecked", "(", "request", ",", "responseHandler", ",", "chooseIP", "(", "request", ".", "getIpKey", "(", ")", ")", ")", ";", "}" ]

[ "Convenience", "wrapper", "for", "NFS", "RPC", "calls", "where", "the", "IP", "is", "determined", "by", "a", "byte", "[]", "key", ".", "This", "method", "just", "determines", "the", "IP", "address", "and", "calls", "the", "basic", "method", "." ]

[ "private", "static", "int", "get", "(", "byte", "[", "]", "block", ",", "int", "offset", ",", "ByteBuffer", "buf", ",", "int", "len", ")", "{", "buf", ".", "put", "(", "block", ",", "offset", ",", "len", ")", ";", "return", "len", ";", "}" ]

[ "Reads", "len", "bytes", "starting", "at", "the", "given", "offset", "in", "the", "given", "block", "into", "the", "given", "byte", "buffer", "." ]

[ "public", "void", "challengeReceived", "(", "String", "challenge", ",", "boolean", "finalChallenge", ")", "throws", "SmackSaslException", ",", "NotConnectedException", ",", "InterruptedException", "{", "try", "{", "currentMechanism", ".", "challengeReceived", "(", "challenge", ",", "finalChallenge", ")", ";", "}", "catch", "(", "InterruptedException", "|", "SmackSaslException", "|", "NotConnectedException", "e", ")", "{", "authenticationFailed", "(", "e", ")", ";", "throw", "e", ";", "}", "}" ]

[ "The", "server", "is", "challenging", "the", "SASL", "authentication", "we", "just", "sent", ".", "Forward", "the", "challenge", "to", "the", "current", "SASLMechanism", "we", "are", "using", ".", "The", "SASLMechanism", "will", "eventually", "send", "a", "response", "to", "the", "server", ".", "The", "length", "of", "the", "challenge", "-", "response", "sequence", "varies", "according", "to", "the", "SASLMechanism", "in", "use", "." ]

[ "public", "static", "String", "getDirectoryname", "(", "final", "String", "pPath", ",", "final", "char", "pSeparator", ")", "{", "int", "index", "=", "pPath", ".", "lastIndexOf", "(", "pSeparator", ")", ";", "if", "(", "index", "<", "0", ")", "{", "return", "\"\"", ";", "// Assume only filename\r", "}", "return", "pPath", ".", "substring", "(", "0", ",", "index", ")", ";", "}" ]

[ "Extracts", "the", "directory", "path", "without", "the", "filename", "from", "a", "complete", "filename", "path", "." ]

[ "public", "static", "void", "putAuthenticationResultBuilder", "(", "final", "AuthenticationResultBuilder", "builder", ",", "final", "RequestContext", "ctx", ")", "{", "ctx", ".", "getConversationScope", "(", ")", ".", "put", "(", "PARAMETER_AUTHENTICATION_RESULT_BUILDER", ",", "builder", ")", ";", "}" ]

[ "Put", "authentication", "result", "builder", "." ]

[ "public", "static", "Method", "findSetter", "(", "final", "Object", "object", ",", "final", "String", "fieldName", ",", "final", "Class", "<", "?", ">", "argumentType", ")", "{", "if", "(", "object", "==", "null", ")", "{", "throw", "new", "NullPointerException", "(", "\"object should not be null\"", ")", ";", "}", "else", "if", "(", "fieldName", "==", "null", ")", "{", "throw", "new", "NullPointerException", "(", "\"fieldName should not be null\"", ")", ";", "}", "else", "if", "(", "argumentType", "==", "null", ")", "{", "throw", "new", "NullPointerException", "(", "\"argumentType should not be null\"", ")", ";", "}", "final", "String", "setterName", "=", "getMethodNameForField", "(", "SET_PREFIX", ",", "fieldName", ")", ";", "final", "Class", "<", "?", ">", "clazz", "=", "object", ".", "getClass", "(", ")", ";", "// find a setter compatible with the supplied argument type", "Method", "setter", "=", "findSetterWithCompatibleParamType", "(", "clazz", ",", "setterName", ",", "argumentType", ")", ";", "// if that failed, try the corresponding primitive/wrapper if it's a type that can be autoboxed/unboxed", "if", "(", "setter", "==", "null", "&&", "AUTOBOXING_CONVERTER", ".", "containsKey", "(", "argumentType", ")", ")", "{", "setter", "=", "findSetterWithCompatibleParamType", "(", "clazz", ",", "setterName", ",", "AUTOBOXING_CONVERTER", ".", "get", "(", "argumentType", ")", ")", ";", "}", "if", "(", "setter", "==", "null", ")", "{", "throw", "new", "SuperCsvReflectionException", "(", "String", ".", "format", "(", "\"unable to find method %s(%s) in class %s - check that the corresponding nameMapping element matches the field name in the bean, \"", "+", "\"and the cell processor returns a type compatible with the field\"", ",", "setterName", ",", "argumentType", ".", "getName", "(", ")", ",", "clazz", ".", "getName", "(", ")", ")", ")", ";", "}", "return", "setter", ";", "}" ]

[ "Returns", "the", "setter", "method", "associated", "with", "the", "object", "s", "field", ".", "<p", ">", "This", "method", "handles", "any", "autoboxing", "/", "unboxing", "of", "the", "argument", "passed", "to", "the", "setter", "(", "e", ".", "g", ".", "if", "the", "setter", "type", "is", "a", "primitive", "{", "@code", "int", "}", "but", "the", "argument", "passed", "to", "the", "setter", "is", "an", "{", "@code", "Integer", "}", ")", "by", "looking", "for", "a", "setter", "with", "the", "same", "type", "and", "failing", "that", "checking", "for", "a", "setter", "with", "the", "corresponding", "primitive", "/", "wrapper", "type", ".", "<p", ">", "It", "also", "allows", "for", "an", "argument", "type", "that", "is", "a", "subclass", "or", "implementation", "of", "the", "setter", "type", "(", "when", "the", "setter", "type", "is", "an", "{", "@code", "Object", "}", "or", "{", "@code", "interface", "}", "respectively", ")", "." ]

[ "public", "static", "boolean", "serializeField", "(", "String", "keyName", ",", "Field", "field", ",", "Method", "getter", ")", "{", "log", ".", "trace", "(", "\"serializeField - keyName: {} field: {} method: {}\"", ",", "new", "Object", "[", "]", "{", "keyName", ",", "field", ",", "getter", "}", ")", ";", "// if \"field\" is a class or is transient, skip it", "if", "(", "\"class\"", ".", "equals", "(", "keyName", ")", ")", "{", "return", "false", ";", "}", "if", "(", "field", "!=", "null", ")", "{", "if", "(", "Modifier", ".", "isTransient", "(", "field", ".", "getModifiers", "(", ")", ")", ")", "{", "log", ".", "trace", "(", "\"Skipping {} because its transient\"", ",", "keyName", ")", ";", "return", "false", ";", "}", "else", "if", "(", "field", ".", "isAnnotationPresent", "(", "DontSerialize", ".", "class", ")", ")", "{", "log", ".", "trace", "(", "\"Skipping {} because its marked with @DontSerialize\"", ",", "keyName", ")", ";", "return", "false", ";", "}", "}", "if", "(", "getter", "!=", "null", "&&", "getter", ".", "isAnnotationPresent", "(", "DontSerialize", ".", "class", ")", ")", "{", "log", ".", "trace", "(", "\"Skipping {} because its marked with @DontSerialize\"", ",", "keyName", ")", ";", "return", "false", ";", "}", "log", ".", "trace", "(", "\"Serialize field: {}\"", ",", "field", ")", ";", "return", "true", ";", "}" ]

[ "Checks", "whether", "the", "field", "should", "be", "serialized", "or", "not" ]

[ "static", "Generator", "serialSecondGenerator", "(", "final", "int", "interval", ",", "final", "DateValue", "dtStart", ")", "{", "final", "TimeValue", "dtStartTime", "=", "TimeUtils", ".", "timeOf", "(", "dtStart", ")", ";", "return", "new", "Generator", "(", ")", "{", "int", "second", "=", "dtStartTime", ".", "second", "(", ")", "-", "interval", ";", "int", "minute", "=", "dtStartTime", ".", "minute", "(", ")", ";", "int", "hour", "=", "dtStartTime", ".", "hour", "(", ")", ";", "int", "day", "=", "dtStart", ".", "day", "(", ")", ";", "int", "month", "=", "dtStart", ".", "month", "(", ")", ";", "int", "year", "=", "dtStart", ".", "year", "(", ")", ";", "@", "Override", "boolean", "generate", "(", "DTBuilder", "builder", ")", "{", "int", "nsecond", ";", "if", "(", "minute", "!=", "builder", ".", "minute", "||", "hour", "!=", "builder", ".", "hour", "||", "day", "!=", "builder", ".", "day", "||", "month", "!=", "builder", ".", "month", "||", "year", "!=", "builder", ".", "year", ")", "{", "int", "secondsBetween", "=", "(", "(", "daysBetween", "(", "builder", ",", "year", ",", "month", ",", "day", ")", "*", "24", "+", "builder", ".", "hour", "-", "hour", ")", "*", "60", "+", "builder", ".", "minute", "-", "minute", ")", "*", "60", "-", "second", ";", "nsecond", "=", "(", "(", "interval", "-", "(", "secondsBetween", "%", "interval", ")", ")", "%", "interval", ")", ";", "if", "(", "nsecond", ">", "59", ")", "{", "/*\n\t\t\t\t\t\t * Don't update day so that the difference calculation\n\t\t\t\t\t\t * above is correct when this function is reentered with\n\t\t\t\t\t\t * a different day.\n\t\t\t\t\t\t */", "return", "false", ";", "}", "minute", "=", "builder", ".", "minute", ";", "hour", "=", "builder", ".", "hour", ";", "day", "=", "builder", ".", "day", ";", "month", "=", "builder", ".", "month", ";", "year", "=", "builder", ".", "year", ";", "}", "else", "{", "nsecond", "=", "second", "+", "interval", ";", "if", "(", "nsecond", ">", "59", ")", "{", "return", "false", ";", "}", "}", "second", "=", "builder", ".", "second", "=", "nsecond", ";", "return", "true", ";", "}", "@", "Override", "public", "String", "toString", "(", ")", "{", "return", "\"serialSecondGenerator:\"", "+", "interval", ";", "}", "}", ";", "}" ]

[ "Constructs", "a", "generator", "that", "generates", "seconds", "in", "the", "given", "date", "s", "minute", "successively", "counting", "from", "the", "first", "second", "passed", "in", "." ]

[ "public", "StorageRef", "getTables", "(", "OnTableSnapshot", "onTableSnapshot", ",", "OnError", "onError", ")", "{", "PostBodyBuilder", "pbb", "=", "new", "PostBodyBuilder", "(", "context", ")", ";", "Rest", "r", "=", "new", "Rest", "(", "context", ",", "RestType", ".", "LISTTABLES", ",", "pbb", ",", "null", ")", ";", "r", ".", "onError", "=", "onError", ";", "r", ".", "onTableSnapshot", "=", "onTableSnapshot", ";", "context", ".", "processRest", "(", "r", ")", ";", "return", "this", ";", "}" ]

[ "Retrieves", "a", "list", "of", "the", "names", "of", "all", "tables", "created", "by", "the", "user", "s", "subscription", "." ]

[ "public", "int", "setState", "(", "boolean", "bState", ",", "boolean", "bDisplayOption", ",", "int", "iMoveMode", ")", "{", "int", "iFieldValue", "=", "(", "int", ")", "this", ".", "getValue", "(", ")", ";", "if", "(", "!", "m_bTrueIfMatch", ")", "bState", "=", "!", "bState", ";", "// Do opposite operation", "if", "(", "bState", ")", "iFieldValue", "|=", "(", "1", "<<", "m_iBitNumber", ")", ";", "// Set the bit", "else", "iFieldValue", "&=", "~", "(", "1", "<<", "m_iBitNumber", ")", ";", "// Clear the bit", "return", "this", ".", "setValue", "(", "iFieldValue", ",", "bDisplayOption", ",", "iMoveMode", ")", ";", "}" ]

[ "For", "binary", "fields", "set", "the", "current", "state", ".", "Sets", "the", "target", "bit", "to", "the", "state", "." ]

[ "protected", "void", "addSpecial", "(", "String", "c", ",", "String", "replacement", ")", "{", "specialString", "+=", "c", ";", "special", ".", "put", "(", "c", ",", "replacement", ")", ";", "}" ]

[ "Add", "a", "replacement", "for", "the", "special", "character", "c", "which", "may", "be", "a", "string" ]

[ "public", "boolean", "notEquals", "(", "XObject", "obj2", ")", "throws", "javax", ".", "xml", ".", "transform", ".", "TransformerException", "{", "return", "compare", "(", "obj2", ",", "S_NEQ", ")", ";", "}" ]

[ "Tell", "if", "two", "objects", "are", "functionally", "not", "equal", "." ]

[ "private", "void", "ruleChanges", "(", ")", "{", "// NP: don't want a POS to be the head\r", "nonTerminalInfo", ".", "put", "(", "\"NP\"", ",", "new", "String", "[", "]", "[", "]", "{", "{", "\"rightdis\"", ",", "\"NN\"", ",", "\"NNP\"", ",", "\"NNPS\"", ",", "\"NNS\"", ",", "\"NX\"", ",", "\"NML\"", ",", "\"JJR\"", "}", ",", "{", "\"left\"", ",", "\"NP\"", ",", "\"PRP\"", "}", ",", "{", "\"rightdis\"", ",", "\"$\"", ",", "\"ADJP\"", ",", "\"FW\"", "}", ",", "{", "\"right\"", ",", "\"CD\"", "}", ",", "{", "\"rightdis\"", ",", "\"JJ\"", ",", "\"JJS\"", ",", "\"QP\"", ",", "\"DT\"", ",", "\"WDT\"", ",", "\"NML\"", ",", "\"PRN\"", ",", "\"RB\"", ",", "\"RBR\"", ",", "\"ADVP\"", "}", ",", "{", "\"left\"", ",", "\"POS\"", "}", ",", "rightExceptPunct", "}", ")", ";", "// WHNP clauses should have the same sort of head as an NP\r", "// but it a WHNP has a NP and a WHNP under it, the WHNP should be the head. E.g., (WHNP (WHNP (WP$ whose) (JJ chief) (JJ executive) (NN officer))(, ,) (NP (NNP James) (NNP Gatward))(, ,))\r", "nonTerminalInfo", ".", "put", "(", "\"WHNP\"", ",", "new", "String", "[", "]", "[", "]", "{", "{", "\"rightdis\"", ",", "\"NN\"", ",", "\"NNP\"", ",", "\"NNPS\"", ",", "\"NNS\"", ",", "\"NX\"", ",", "\"NML\"", ",", "\"JJR\"", ",", "\"WP\"", "}", ",", "{", "\"left\"", ",", "\"WHNP\"", ",", "\"NP\"", "}", ",", "{", "\"rightdis\"", ",", "\"$\"", ",", "\"ADJP\"", ",", "\"PRN\"", ",", "\"FW\"", "}", ",", "{", "\"right\"", ",", "\"CD\"", "}", ",", "{", "\"rightdis\"", ",", "\"JJ\"", ",", "\"JJS\"", ",", "\"RB\"", ",", "\"QP\"", "}", ",", "{", "\"left\"", ",", "\"WHPP\"", ",", "\"WHADJP\"", ",", "\"WP$\"", ",", "\"WDT\"", "}", "}", ")", ";", "//WHADJP\r", "nonTerminalInfo", ".", "put", "(", "\"WHADJP\"", ",", "new", "String", "[", "]", "[", "]", "{", "{", "\"left\"", ",", "\"ADJP\"", ",", "\"JJ\"", ",", "\"JJR\"", "}", ",", "{", "\"right\"", ",", "\"RB\"", "}", ",", "rightExceptPunct", "}", ")", ";", "//WHADJP\r", "nonTerminalInfo", ".", "put", "(", "\"WHADVP\"", ",", "new", "String", "[", "]", "[", "]", "{", "{", "\"rightdis\"", ",", "\"WRB\"", ",", "\"WHADVP\"", ",", "\"RB\"", ",", "\"JJ\"", "}", ",", "rightExceptPunct", "}", ")", ";", "// if not WRB or WHADVP, probably has flat NP structure, allow JJ for \"how long\" constructions\r", "// QP: we don't want the first CD to be the semantic head (e.g., \"three billion\": head should be \"billion\"), so we go from right to left\r", "nonTerminalInfo", ".", "put", "(", "\"QP\"", ",", "new", "String", "[", "]", "[", "]", "{", "{", "\"right\"", ",", "\"$\"", ",", "\"NNS\"", ",", "\"NN\"", ",", "\"CD\"", ",", "\"JJ\"", ",", "\"PDT\"", ",", "\"DT\"", ",", "\"IN\"", ",", "\"RB\"", ",", "\"NCD\"", ",", "\"QP\"", ",", "\"JJR\"", ",", "\"JJS\"", "}", "}", ")", ";", "// S, SBAR and SQ clauses should prefer the main verb as the head\r", "// S: \"He considered him a friend\" -> we want a friend to be the head\r", "nonTerminalInfo", ".", "put", "(", "\"S\"", ",", "new", "String", "[", "]", "[", "]", "{", "{", "\"left\"", ",", "\"VP\"", ",", "\"S\"", ",", "\"FRAG\"", ",", "\"SBAR\"", ",", "\"ADJP\"", ",", "\"UCP\"", ",", "\"TO\"", "}", ",", "{", "\"right\"", ",", "\"NP\"", "}", "}", ")", ";", "nonTerminalInfo", ".", "put", "(", "\"SBAR\"", ",", "new", "String", "[", "]", "[", "]", "{", "{", "\"left\"", ",", "\"S\"", ",", "\"SQ\"", ",", "\"SINV\"", ",", "\"SBAR\"", ",", "\"FRAG\"", ",", "\"VP\"", ",", "\"WHNP\"", ",", "\"WHPP\"", ",", "\"WHADVP\"", ",", "\"WHADJP\"", ",", "\"IN\"", ",", "\"DT\"", "}", "}", ")", ";", "// VP shouldn't be needed in SBAR, but occurs in one buggy tree in PTB3 wsj_1457 and otherwise does no harm\r", "nonTerminalInfo", ".", "put", "(", "\"SQ\"", ",", "new", "String", "[", "]", "[", "]", "{", "{", "\"left\"", ",", "\"VP\"", ",", "\"SQ\"", ",", "\"ADJP\"", ",", "\"VB\"", ",", "\"VBZ\"", ",", "\"VBD\"", ",", "\"VBP\"", ",", "\"MD\"", ",", "\"AUX\"", ",", "\"AUXG\"", "}", "}", ")", ";", "// UCP take the first element as head\r", "nonTerminalInfo", ".", "put", "(", "\"UCP\"", ",", "new", "String", "[", "]", "[", "]", "{", "leftExceptPunct", "}", ")", ";", "// CONJP: we want different heads for \"but also\" and \"but not\" and we don't want \"not\" to be the head in \"not to mention\"; now make \"mention\" head of \"not to mention\"\r", "nonTerminalInfo", ".", "put", "(", "\"CONJP\"", ",", "new", "String", "[", "]", "[", "]", "{", "{", "\"right\"", ",", "\"VB\"", ",", "\"JJ\"", ",", "\"RB\"", ",", "\"IN\"", ",", "\"CC\"", "}", ",", "rightExceptPunct", "}", ")", ";", "// FRAG: crap rule needs to be change if you want to parse glosses\r", "nonTerminalInfo", ".", "put", "(", "\"FRAG\"", ",", "new", "String", "[", "]", "[", "]", "{", "{", "\"left\"", ",", "\"IN\"", "}", ",", "{", "\"right\"", ",", "\"RB\"", "}", ",", "{", "\"left\"", ",", "\"NP\"", "}", ",", "{", "\"left\"", ",", "\"ADJP\"", ",", "\"ADVP\"", ",", "\"FRAG\"", ",", "\"S\"", ",", "\"SBAR\"", ",", "\"VP\"", "}", ",", "leftExceptPunct", "}", ")", ";", "// PP first word (especially in coordination of PPs)\r", "nonTerminalInfo", ".", "put", "(", "\"PP\"", ",", "new", "String", "[", "]", "[", "]", "{", "{", "\"right\"", ",", "\"IN\"", ",", "\"TO\"", ",", "\"VBG\"", ",", "\"VBN\"", ",", "\"RP\"", ",", "\"FW\"", ",", "\"JJ\"", "}", ",", "{", "\"left\"", ",", "\"PP\"", "}", "}", ")", ";", "// PRN: sentence first\r", "nonTerminalInfo", ".", "put", "(", "\"PRN\"", ",", "new", "String", "[", "]", "[", "]", "{", "{", "\"left\"", ",", "\"VP\"", ",", "\"SQ\"", ",", "\"S\"", ",", "\"SINV\"", ",", "\"SBAR\"", ",", "\"NP\"", ",", "\"ADJP\"", ",", "\"PP\"", ",", "\"ADVP\"", ",", "\"INTJ\"", ",", "\"WHNP\"", ",", "\"NAC\"", ",", "\"VBP\"", ",", "\"JJ\"", ",", "\"NN\"", ",", "\"NNP\"", "}", ",", "leftExceptPunct", "}", ")", ";", "// add the constituent XS (special node to add a layer in a QP tree introduced in our QPTreeTransformer)\r", "nonTerminalInfo", ".", "put", "(", "\"XS\"", ",", "new", "String", "[", "]", "[", "]", "{", "{", "\"right\"", ",", "\"IN\"", "}", "}", ")", ";", "}" ]

[ "makes", "modifications", "of", "Collins", "rules", "to", "better", "fit", "with", "semantic", "notions", "of", "heads" ]

[ "public", "void", "addProperty", "(", "String", "name", ",", "String", "...", "values", ")", "{", "List", "<", "String", ">", "valueList", "=", "new", "ArrayList", "<", "String", ">", "(", ")", ";", "for", "(", "String", "value", ":", "values", ")", "{", "valueList", ".", "add", "(", "value", ".", "trim", "(", ")", ")", ";", "}", "properties", ".", "put", "(", "name", ".", "trim", "(", ")", ",", "valueList", ")", ";", "}" ]

[ "Add", "a", "property", "with", "the", "given", "name", "and", "the", "given", "list", "of", "values", "to", "this", "Properties", "object", ".", "Name", "and", "values", "are", "trimmed", "before", "the", "property", "is", "added", "." ]

[ "public", "MockResponse", "setChunkedBody", "(", "byte", "[", "]", "body", ",", "int", "maxChunkSize", ")", "{", "removeHeader", "(", "\"Content-Length\"", ")", ";", "headers", ".", "add", "(", "CHUNKED_BODY_HEADER", ")", ";", "try", "{", "ByteArrayOutputStream", "bytesOut", "=", "new", "ByteArrayOutputStream", "(", ")", ";", "int", "pos", "=", "0", ";", "while", "(", "pos", "<", "body", ".", "length", ")", "{", "int", "chunkSize", "=", "Math", ".", "min", "(", "body", ".", "length", "-", "pos", ",", "maxChunkSize", ")", ";", "bytesOut", ".", "write", "(", "Integer", ".", "toHexString", "(", "chunkSize", ")", ".", "getBytes", "(", "US_ASCII", ")", ")", ";", "bytesOut", ".", "write", "(", "\"\\r\\n\"", ".", "getBytes", "(", "US_ASCII", ")", ")", ";", "bytesOut", ".", "write", "(", "body", ",", "pos", ",", "chunkSize", ")", ";", "bytesOut", ".", "write", "(", "\"\\r\\n\"", ".", "getBytes", "(", "US_ASCII", ")", ")", ";", "pos", "+=", "chunkSize", ";", "}", "bytesOut", ".", "write", "(", "\"0\\r\\n\\r\\n\"", ".", "getBytes", "(", "US_ASCII", ")", ")", ";", "// last chunk + empty trailer + crlf", "this", ".", "body", "=", "bytesOut", ".", "toByteArray", "(", ")", ";", "return", "this", ";", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "new", "AssertionError", "(", ")", ";", "// In-memory I/O doesn't throw IOExceptions.", "}", "}" ]

[ "Sets", "the", "response", "body", "to", "{" ]

[ "private", "static", "void", "insertAddressUsingCallable", "(", "AddressClient", "client", ",", "String", "newAddressName", ")", "throws", "InterruptedException", ",", "ExecutionException", "{", "// Begin samplegen code for insertAddress().", "ProjectRegionName", "region", "=", "ProjectRegionName", ".", "of", "(", "PROJECT_NAME", ",", "REGION", ")", ";", "Address", "address", "=", "Address", ".", "newBuilder", "(", ")", ".", "build", "(", ")", ";", "InsertAddressHttpRequest", "request", "=", "InsertAddressHttpRequest", ".", "newBuilder", "(", ")", ".", "setRegion", "(", "region", ".", "toString", "(", ")", ")", ".", "setAddressResource", "(", "address", ")", ".", "build", "(", ")", ";", "ApiFuture", "<", "Operation", ">", "future", "=", "client", ".", "insertAddressCallable", "(", ")", ".", "futureCall", "(", "request", ")", ";", "// Do something", "Operation", "response", "=", "future", ".", "get", "(", ")", ";", "// End samplegen code for insertAddress().", "System", ".", "out", ".", "format", "(", "\"Result of insert: %s\\n\"", ",", "response", ".", "toString", "(", ")", ")", ";", "}" ]

[ "Use", "an", "callable", "object", "to", "make", "an", "addresses", ".", "insert", "method", "call", "." ]

[ "public", "Observable", "<", "PersistedFace", ">", "getFaceAsync", "(", "String", "personGroupId", ",", "UUID", "personId", ",", "UUID", "persistedFaceId", ")", "{", "return", "getFaceWithServiceResponseAsync", "(", "personGroupId", ",", "personId", ",", "persistedFaceId", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "PersistedFace", ">", ",", "PersistedFace", ">", "(", ")", "{", "@", "Override", "public", "PersistedFace", "call", "(", "ServiceResponse", "<", "PersistedFace", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Retrieve", "information", "about", "a", "persisted", "face", "(", "specified", "by", "persistedFaceId", "personId", "and", "its", "belonging", "personGroupId", ")", "." ]

[ "public", "static", "Long", "getLongProperty", "(", "Configuration", "config", ",", "String", "key", ")", "throws", "DeployerConfigurationException", "{", "return", "getLongProperty", "(", "config", ",", "key", ",", "null", ")", ";", "}" ]

[ "Returns", "the", "specified", "Long", "property", "from", "the", "configuration" ]

[ "private", "static", "int", "compare", "(", "Treenode", "item1", ",", "Treenode", "item2", ")", "{", "String", "label1", "=", "item1", ".", "getLabel", "(", ")", ";", "String", "label2", "=", "item2", ".", "getLabel", "(", ")", ";", "return", "label1", "==", "label2", "?", "0", ":", "label1", "==", "null", "?", "-", "1", ":", "label2", "==", "null", "?", "-", "1", ":", "label1", ".", "compareToIgnoreCase", "(", "label2", ")", ";", "}" ]

[ "Case", "insensitive", "comparison", "of", "labels", "of", "two", "tree", "items", "." ]

[ "public", "void", "setChild", "(", "final", "int", "index", ",", "final", "String", "label", ")", "{", "final", "Parse", "newChild", "=", "(", "Parse", ")", "this", ".", "parts", ".", "get", "(", "index", ")", ".", "clone", "(", ")", ";", "newChild", ".", "setLabel", "(", "label", ")", ";", "this", ".", "parts", ".", "set", "(", "index", ",", "newChild", ")", ";", "}" ]

[ "Replaces", "the", "child", "at", "the", "specified", "index", "with", "a", "new", "child", "with", "the", "specified", "label", "." ]

[ "public", "static", "String", "getDisplayString", "(", "final", "Object", "value", ",", "final", "boolean", "htmlEscape", ")", "{", "final", "String", "displayValue", "=", "ObjectUtils", ".", "getDisplayString", "(", "value", ")", ";", "return", "(", "htmlEscape", "?", "HtmlUtils", ".", "htmlEscape", "(", "displayValue", ")", ":", "displayValue", ")", ";", "}" ]

[ "/", "*", "NOTE", "This", "code", "is", "based", "on", "org", ".", "springframework", ".", "web", ".", "servlet", ".", "tags", ".", "form", ".", "ValueFormatter", "as", "of", "Spring", "5", ".", "0", ".", "0", "Original", "license", "is", "Apache", "License", "2", ".", "0", "which", "is", "the", "same", "as", "the", "license", "for", "this", "file", ".", "Original", "copyright", "notice", "is", "Copyright", "2002", "-", "2012", "the", "original", "author", "or", "authors", ".", "Original", "authors", "are", "Rob", "Harrop", "and", "Juergen", "Hoeller", "." ]

[ "public", "static", "<", "T", ">", "T", "notNullAndEquals", "(", "final", "T", "aValue", ",", "final", "String", "sName", ",", "@", "Nonnull", "final", "T", "aExpectedValue", ")", "{", "if", "(", "isEnabled", "(", ")", ")", "return", "notNullAndEquals", "(", "aValue", ",", "(", ")", "->", "sName", ",", "aExpectedValue", ")", ";", "return", "aValue", ";", "}" ]

[ "Check", "that", "the", "passed", "value", "is", "not", "<code", ">", "null<", "/", "code", ">", "and", "equal", "to", "the", "provided", "expected", "value", "." ]

[ "protected", "Iterator", "findLocalMemberGroups", "(", "IEntityGroup", "eg", ")", "throws", "GroupsException", "{", "Collection", "groups", "=", "new", "ArrayList", "(", "10", ")", ";", "IEntityGroup", "group", "=", "null", ";", "for", "(", "Iterator", "it", "=", "getGroupStore", "(", ")", ".", "findMemberGroups", "(", "eg", ")", ";", "it", ".", "hasNext", "(", ")", ";", ")", "{", "group", "=", "(", "IEntityGroup", ")", "it", ".", "next", "(", ")", ";", "if", "(", "group", "==", "null", ")", "{", "log", ".", "warn", "(", "\"A null IEntityGroup object was part of a list groupStore.findMemberGroups\"", ")", ";", "continue", ";", "}", "group", ".", "setLocalGroupService", "(", "this", ")", ";", "groups", ".", "add", "(", "group", ")", ";", "if", "(", "cacheInUse", "(", ")", ")", "{", "try", "{", "if", "(", "getGroupFromCache", "(", "group", ".", "getEntityIdentifier", "(", ")", ".", "getKey", "(", ")", ")", "==", "null", ")", "{", "cacheAdd", "(", "group", ")", ";", "}", "}", "catch", "(", "CachingException", "ce", ")", "{", "throw", "new", "GroupsException", "(", "\"Problem finding member groups\"", ",", "ce", ")", ";", "}", "}", "}", "return", "groups", ".", "iterator", "(", ")", ";", "}" ]

[ "Returns", "and", "caches", "the", "member", "groups", "for", "the", "<code", ">", "IEntityGroup<", "/", "code", ">" ]

[ "public", "void", "init", "(", "Record", "record", ",", "String", "thisFileFieldName", ",", "BaseField", "fldThisFile", ",", "String", "thisFileFieldName2", ",", "BaseField", "fldThisFile2", ",", "String", "thisFileFieldName3", ",", "BaseField", "fldThisFile3", ")", "{", "super", ".", "init", "(", "record", ")", ";", "this", ".", "thisFileFieldName", "=", "thisFileFieldName", ";", "m_fldThisFile", "=", "fldThisFile", ";", "this", ".", "thisFileFieldName2", "=", "thisFileFieldName2", ";", "m_fldThisFile2", "=", "fldThisFile2", ";", "this", ".", "thisFileFieldName3", "=", "thisFileFieldName3", ";", "m_fldThisFile3", "=", "fldThisFile3", ";", "m_bInitialKey", "=", "true", ";", "m_bEndKey", "=", "true", ";", "}" ]

[ "Constructor", "." ]

[ "public", "static", "Between", "betweenExclusiveMin", "(", "String", "property", ",", "int", "minimum", ",", "int", "maximum", ")", "{", "return", "new", "Between", "(", "moreThan", "(", "property", ",", "minimum", ")", ",", "notMoreThan", "(", "property", ",", "maximum", ")", ")", ";", "}" ]

[ "Returns", "a", "{" ]

[ "public", "FluentSelect", "selectByVisibleText", "(", "final", "String", "text", ")", "{", "executeAndWrapReThrowIfNeeded", "(", "new", "SelectByVisibleText", "(", "text", ")", ",", "Context", ".", "singular", "(", "context", ",", "\"selectByVisibleText\"", ",", "null", ",", "text", ")", ",", "true", ")", ";", "return", "new", "FluentSelect", "(", "super", ".", "delegate", ",", "currentElement", ".", "getFound", "(", ")", ",", "this", ".", "context", ",", "monitor", ",", "booleanInsteadOfNotFoundException", ")", ";", "}" ]

[ "<p", ">", "Select", "all", "options", "that", "display", "text", "matching", "the", "argument", ".", "That", "is", "when", "given", "Bar", "this", "would", "select", "an", "option", "like", ":", "<", "/", "p", ">", "&lt", ";", "option", "value", "=", "foo", "&gt", ";", "Bar&lt", ";", "/", "option&gt", ";" ]

[ "public", "String", "getText", "(", "String", "indentation", ",", "char", "indentationChar", ")", "{", "newCode", "=", "FormatterHelper", ".", "indent", "(", "newNode", ".", "getPrettySource", "(", "indentationChar", ",", "indentationLevel", ",", "indentationSize", ",", "acceptedComments", ")", ",", "indentation", ",", "indentationChar", ",", "indentationLevel", ",", "indentationSize", ",", "requiresExtraIndentationOnFirstLine", "(", ")", ")", ";", "return", "newCode", ";", "}" ]

[ "Returns", "the", "new", "text", "to", "insert", "with", "the", "appropriate", "indentation", "and", "comments" ]

[ "public", "String", "fromByteArray", "(", "byte", "[", "]", "bytes", ",", "int", "offset", ",", "int", "length", ")", "{", "java", ".", "util", ".", "Objects", ".", "requireNonNull", "(", "bytes", ",", "\"bytes\"", ")", ";", "Objects", ".", "validArgument", "(", "offset", ">=", "0", ",", "\"offset must be equal or greater than zero\"", ")", ";", "Objects", ".", "validArgument", "(", "length", ">", "0", ",", "\"length must be greater than zero\"", ")", ";", "Objects", ".", "validArgument", "(", "offset", "+", "length", "<=", "bytes", ".", "length", ",", "\"(offset + length) must be less than %s\"", ",", "bytes", ".", "length", ")", ";", "if", "(", "byteSeparator", "!=", "null", "&&", "byteSeparator", ".", "length", "(", ")", ">", "0", ")", "{", "return", "fromByteArrayInternal", "(", "bytes", ",", "offset", ",", "length", ",", "byteSeparator", ")", ";", "}", "else", "{", "return", "fromByteArrayInternal", "(", "bytes", ",", "offset", ",", "length", ")", ";", "}", "}" ]

[ "Returns", "a", "hexadecimal", "string", "representation", "of", "{", "@code", "length", "}", "bytes", "of", "{", "@code", "bytes", "}", "starting", "at", "offset", "{", "@code", "offset", "}", "." ]

[ "static", "public", "InputStream", "replaceProperties", "(", "InputStream", "source", ",", "Properties", "props", ",", "String", "startStr", ",", "String", "endStr", ")", "throws", "IOException", ",", "SubstitutionException", "{", "String", "template", "=", "streamToString", "(", "source", ")", ";", "String", "replaced", "=", "StringUtil", ".", "substituteWithProperties", "(", "template", ",", "startStr", ",", "endStr", ",", "props", ")", ";", "System", ".", "err", ".", "println", "(", "template", ")", ";", "System", ".", "err", ".", "println", "(", "replaced", ")", ";", "return", "new", "ByteArrayInputStream", "(", "replaced", ".", "getBytes", "(", ")", ")", ";", "}" ]

[ "Creates", "an", "InputStream", "containing", "the", "document", "resulting", "from", "replacing", "template", "parameters", "in", "the", "given", "InputStream", "source", "." ]

[ "private", "MapObject", "iterateAndPopulateRmap", "(", "Object", "entity", ",", "MetamodelImpl", "metaModel", ",", "Iterator", "<", "Attribute", ">", "iterator", ")", "{", "MapObject", "map", "=", "r", ".", "hashMap", "(", ")", ";", "while", "(", "iterator", ".", "hasNext", "(", ")", ")", "{", "Attribute", "attribute", "=", "iterator", ".", "next", "(", ")", ";", "Field", "field", "=", "(", "Field", ")", "attribute", ".", "getJavaMember", "(", ")", ";", "Object", "value", "=", "PropertyAccessorHelper", ".", "getObject", "(", "entity", ",", "field", ")", ";", "if", "(", "field", ".", "isAnnotationPresent", "(", "Id", ".", "class", ")", ")", "{", "map", ".", "with", "(", "ID", ",", "value", ")", ";", "}", "else", "{", "map", ".", "with", "(", "(", "(", "AbstractAttribute", ")", "attribute", ")", ".", "getJPAColumnName", "(", ")", ",", "value", ")", ";", "}", "}", "return", "map", ";", "}" ]

[ "Iterate", "and", "populate", "rmap", "." ]

[ "public", "Observable", "<", "Void", ">", "beginOnlineRegionAsync", "(", "String", "resourceGroupName", ",", "String", "accountName", ",", "String", "region", ")", "{", "return", "beginOnlineRegionWithServiceResponseAsync", "(", "resourceGroupName", ",", "accountName", ",", "region", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "Void", ">", ",", "Void", ">", "(", ")", "{", "@", "Override", "public", "Void", "call", "(", "ServiceResponse", "<", "Void", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Online", "the", "specified", "region", "for", "the", "specified", "Azure", "Cosmos", "DB", "database", "account", "." ]

[ "public", "static", "LongBigArrayBigList", "index", "(", "final", "InputStream", "in", ",", "final", "ProgressLogger", "pl", ")", "throws", "IOException", "{", "final", "LongBigArrayBigList", "pointers", "=", "new", "LongBigArrayBigList", "(", ")", ";", "long", "current", "=", "0", ";", "final", "GZIPArchiveReader", "gzar", "=", "new", "GZIPArchiveReader", "(", "in", ")", ";", "GZIPArchive", ".", "ReadEntry", "re", ";", "for", "(", ";", ";", ")", "{", "re", "=", "gzar", ".", "skipEntry", "(", ")", ";", "if", "(", "re", "==", "null", ")", "break", ";", "pointers", ".", "add", "(", "current", ")", ";", "current", "+=", "re", ".", "compressedSkipLength", ";", "if", "(", "pl", "!=", "null", ")", "pl", ".", "lightUpdate", "(", ")", ";", "}", "in", ".", "close", "(", ")", ";", "return", "pointers", ";", "}" ]

[ "Returns", "a", "list", "of", "pointers", "to", "a", "GZIP", "archive", "entries", "positions", "(", "including", "the", "end", "of", "file", ")", "." ]

[ "protected", "Level", "createEmptyLevelFromType", "(", "final", "int", "lineNumber", ",", "final", "LevelType", "levelType", ",", "final", "String", "input", ")", "{", "// Create the level based on the type", "switch", "(", "levelType", ")", "{", "case", "APPENDIX", ":", "return", "new", "Appendix", "(", "null", ",", "lineNumber", ",", "input", ")", ";", "case", "CHAPTER", ":", "return", "new", "Chapter", "(", "null", ",", "lineNumber", ",", "input", ")", ";", "case", "SECTION", ":", "return", "new", "Section", "(", "null", ",", "lineNumber", ",", "input", ")", ";", "case", "PART", ":", "return", "new", "Part", "(", "null", ",", "lineNumber", ",", "input", ")", ";", "case", "PROCESS", ":", "return", "new", "Process", "(", "null", ",", "lineNumber", ",", "input", ")", ";", "case", "INITIAL_CONTENT", ":", "return", "new", "InitialContent", "(", "lineNumber", ",", "input", ")", ";", "default", ":", "return", "new", "Level", "(", "null", ",", "lineNumber", ",", "input", ",", "levelType", ")", ";", "}", "}" ]

[ "Creates", "an", "empty", "Level", "using", "the", "LevelType", "to", "determine", "which", "Level", "subclass", "to", "instantiate", "." ]

[ "public", "BoxFile", ".", "Info", "uploadNewVersion", "(", "InputStream", "fileContent", ",", "String", "fileContentSHA1", ")", "{", "return", "this", ".", "uploadNewVersion", "(", "fileContent", ",", "fileContentSHA1", ",", "null", ")", ";", "}" ]

[ "Uploads", "a", "new", "version", "of", "this", "file", "replacing", "the", "current", "version", ".", "Note", "that", "only", "users", "with", "premium", "accounts", "will", "be", "able", "to", "view", "and", "recover", "previous", "versions", "of", "the", "file", "." ]

[ "protected", "DataHash", "calculateMac", "(", ")", "throws", "KSIException", "{", "try", "{", "HashAlgorithm", "algorithm", "=", "HashAlgorithm", ".", "getByName", "(", "\"DEFAULT\"", ")", ";", "algorithm", ".", "checkExpiration", "(", ")", ";", "return", "new", "DataHash", "(", "algorithm", ",", "Util", ".", "calculateHMAC", "(", "getContent", "(", ")", ",", "this", ".", "loginKey", ",", "algorithm", ".", "getName", "(", ")", ")", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "new", "KSIProtocolException", "(", "\"Problem with HMAC\"", ",", "e", ")", ";", "}", "catch", "(", "InvalidKeyException", "e", ")", "{", "throw", "new", "KSIProtocolException", "(", "\"Problem with HMAC key.\"", ",", "e", ")", ";", "}", "catch", "(", "NoSuchAlgorithmException", "e", ")", "{", "// If the default algorithm changes to be outside of MD5 / SHA1 /", "// SHA256 list.", "throw", "new", "KSIProtocolException", "(", "\"Unsupported HMAC algorithm.\"", ",", "e", ")", ";", "}", "catch", "(", "HashException", "e", ")", "{", "throw", "new", "KSIProtocolException", "(", "e", ".", "getMessage", "(", ")", ",", "e", ")", ";", "}", "}" ]

[ "Calculates", "the", "MAC", "based", "on", "header", "and", "payload", "TLVs", "." ]

[ "public", "WebArchive", "genericCreateArchiveWithoutJsps", "(", "String", "baseWarName", ",", "List", "<", "String", ">", "classList", ")", "throws", "Exception", "{", "try", "{", "String", "warName", "=", "getWarName", "(", "baseWarName", ")", ";", "WebArchive", "newWar", "=", "ShrinkWrap", ".", "create", "(", "WebArchive", ".", "class", ",", "warName", ")", ";", "addDefaultFileAssetsForAppsToWar", "(", "warName", ",", "newWar", ")", ";", "for", "(", "String", "theClass", ":", "classList", ")", "{", "newWar", ".", "addClass", "(", "theClass", ")", ";", "}", "return", "newWar", ";", "}", "catch", "(", "Exception", "e", ")", "{", "Log", ".", "error", "(", "thisClass", ",", "\"genericCreateArchive\"", ",", "e", ")", ";", "throw", "e", ";", "}", "}" ]

[ "Create", "a", "new", "war", "with", "standard", "content", "for", "tests", "using", "these", "utils", ".", "Finally", "add", "the", "classes", "that", "are", "specific", "to", "this", "war", "(", "they", "come", "from", "the", "classList", "passed", "in", ")" ]

[ "public", "void", "setPattern", "(", "NumberPattern", "pattern", ",", "int", "_maxSigDigits", ",", "int", "_minSigDigits", ")", "{", "Format", "format", "=", "pattern", ".", "format", "(", ")", ";", "minIntDigits", "=", "orDefault", "(", "options", ".", "minimumIntegerDigits", "(", ")", ",", "format", ".", "minimumIntegerDigits", "(", ")", ")", ";", "maxFracDigits", "=", "currencyDigits", "==", "-", "1", "?", "format", ".", "maximumFractionDigits", "(", ")", ":", "currencyDigits", ";", "maxFracDigits", "=", "orDefault", "(", "options", ".", "maximumFractionDigits", "(", ")", ",", "maxFracDigits", ")", ";", "minFracDigits", "=", "currencyDigits", "==", "-", "1", "?", "format", ".", "minimumFractionDigits", "(", ")", ":", "currencyDigits", ";", "minFracDigits", "=", "orDefault", "(", "options", ".", "minimumFractionDigits", "(", ")", ",", "minFracDigits", ")", ";", "boolean", "useSignificant", "=", "formatMode", "==", "SIGNIFICANT", "||", "formatMode", "==", "SIGNIFICANT_MAXFRAC", ";", "if", "(", "useSignificant", ")", "{", "maxSigDigits", "=", "orDefault", "(", "options", ".", "maximumSignificantDigits", "(", ")", ",", "_maxSigDigits", ")", ";", "minSigDigits", "=", "orDefault", "(", "options", ".", "minimumSignificantDigits", "(", ")", ",", "_minSigDigits", ")", ";", "}", "else", "{", "maxSigDigits", "=", "-", "1", ";", "minSigDigits", "=", "-", "1", ";", "}", "}" ]

[ "Set", "the", "pattern", "and", "initialize", "parameters", "based", "on", "the", "arguments", "pattern", "and", "options", "settings", "." ]

[ "public", "static", "void", "configureTrainingDatabases", "(", "IFindBugsEngine", "findBugs", ")", "throws", "IOException", "{", "if", "(", "findBugs", ".", "emitTrainingOutput", "(", ")", ")", "{", "String", "trainingOutputDir", "=", "findBugs", ".", "getTrainingOutputDir", "(", ")", ";", "if", "(", "!", "new", "File", "(", "trainingOutputDir", ")", ".", "isDirectory", "(", ")", ")", "{", "throw", "new", "IOException", "(", "\"Training output directory \"", "+", "trainingOutputDir", "+", "\" does not exist\"", ")", ";", "}", "AnalysisContext", ".", "currentAnalysisContext", "(", ")", ".", "setDatabaseOutputDir", "(", "trainingOutputDir", ")", ";", "// XXX: hack", "System", ".", "setProperty", "(", "\"findbugs.checkreturn.savetraining\"", ",", "new", "File", "(", "trainingOutputDir", ",", "\"checkReturn.db\"", ")", ".", "getPath", "(", ")", ")", ";", "}", "if", "(", "findBugs", ".", "useTrainingInput", "(", ")", ")", "{", "String", "trainingInputDir", "=", "findBugs", ".", "getTrainingInputDir", "(", ")", ";", "if", "(", "!", "new", "File", "(", "trainingInputDir", ")", ".", "isDirectory", "(", ")", ")", "{", "throw", "new", "IOException", "(", "\"Training input directory \"", "+", "trainingInputDir", "+", "\" does not exist\"", ")", ";", "}", "AnalysisContext", ".", "currentAnalysisContext", "(", ")", ".", "setDatabaseInputDir", "(", "trainingInputDir", ")", ";", "AnalysisContext", ".", "currentAnalysisContext", "(", ")", ".", "loadInterproceduralDatabases", "(", ")", ";", "// XXX: hack", "System", ".", "setProperty", "(", "\"findbugs.checkreturn.loadtraining\"", ",", "new", "File", "(", "trainingInputDir", ",", "\"checkReturn.db\"", ")", ".", "getPath", "(", ")", ")", ";", "}", "else", "{", "AnalysisContext", ".", "currentAnalysisContext", "(", ")", ".", "loadDefaultInterproceduralDatabases", "(", ")", ";", "}", "}" ]

[ "Configure", "training", "databases", "." ]

[ "public", "Observable", "<", "ImageCreateSummary", ">", "createImagesFromUrlsAsync", "(", "UUID", "projectId", ",", "ImageUrlCreateBatch", "batch", ")", "{", "return", "createImagesFromUrlsWithServiceResponseAsync", "(", "projectId", ",", "batch", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "ImageCreateSummary", ">", ",", "ImageCreateSummary", ">", "(", ")", "{", "@", "Override", "public", "ImageCreateSummary", "call", "(", "ServiceResponse", "<", "ImageCreateSummary", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Add", "the", "provided", "images", "urls", "to", "the", "set", "of", "training", "images", ".", "This", "API", "accepts", "a", "batch", "of", "urls", "and", "optionally", "tags", "to", "create", "images", ".", "There", "is", "a", "limit", "of", "64", "images", "and", "20", "tags", "." ]

[ "public", "static", "void", "putVarLong", "(", "long", "v", ",", "ByteBuffer", "sink", ")", "{", "while", "(", "true", ")", "{", "int", "bits", "=", "(", "(", "int", ")", "v", ")", "&", "0x7f", ";", "v", ">>>=", "7", ";", "if", "(", "v", "==", "0", ")", "{", "sink", ".", "put", "(", "(", "byte", ")", "bits", ")", ";", "return", ";", "}", "sink", ".", "put", "(", "(", "byte", ")", "(", "bits", "|", "0x80", ")", ")", ";", "}", "}" ]

[ "Encodes", "a", "long", "integer", "in", "a", "variable", "-", "length", "encoding", "7", "bits", "per", "byte", "to", "a", "ByteBuffer", "sink", "." ]

[ "public", "GitlabBuildVariable", "getBuildVariable", "(", "Integer", "projectId", ",", "String", "key", ")", "throws", "IOException", "{", "String", "tailUrl", "=", "GitlabProject", ".", "URL", "+", "\"/\"", "+", "projectId", "+", "GitlabBuildVariable", ".", "URL", "+", "\"/\"", "+", "key", ";", "return", "retrieve", "(", ")", ".", "to", "(", "tailUrl", ",", "GitlabBuildVariable", ".", "class", ")", ";", "}" ]

[ "Gets", "build", "variable", "associated", "with", "a", "project", "and", "key", "." ]

[ "public", "AffectedEntity", "withTags", "(", "java", ".", "util", ".", "Map", "<", "String", ",", "String", ">", "tags", ")", "{", "setTags", "(", "tags", ")", ";", "return", "this", ";", "}" ]

[ "<p", ">", "A", "map", "of", "entity", "tags", "attached", "to", "the", "affected", "entity", ".", "<", "/", "p", ">" ]

[ "private", "Object", "getColumnValue", "(", "String", "table", ",", "String", "column", ",", "String", "data", ",", "int", "type", ",", "boolean", "epochDateFormat", ")", "throws", "MPXJException", "{", "try", "{", "Object", "value", "=", "null", ";", "switch", "(", "type", ")", "{", "case", "Types", ".", "BIT", ":", "{", "value", "=", "DatatypeConverter", ".", "parseBoolean", "(", "data", ")", ";", "break", ";", "}", "case", "Types", ".", "VARCHAR", ":", "case", "Types", ".", "LONGVARCHAR", ":", "{", "value", "=", "DatatypeConverter", ".", "parseString", "(", "data", ")", ";", "break", ";", "}", "case", "Types", ".", "TIME", ":", "{", "value", "=", "DatatypeConverter", ".", "parseBasicTime", "(", "data", ")", ";", "break", ";", "}", "case", "Types", ".", "TIMESTAMP", ":", "{", "if", "(", "epochDateFormat", ")", "{", "value", "=", "DatatypeConverter", ".", "parseEpochTimestamp", "(", "data", ")", ";", "}", "else", "{", "value", "=", "DatatypeConverter", ".", "parseBasicTimestamp", "(", "data", ")", ";", "}", "break", ";", "}", "case", "Types", ".", "DOUBLE", ":", "{", "value", "=", "DatatypeConverter", ".", "parseDouble", "(", "data", ")", ";", "break", ";", "}", "case", "Types", ".", "INTEGER", ":", "{", "value", "=", "DatatypeConverter", ".", "parseInteger", "(", "data", ")", ";", "break", ";", "}", "default", ":", "{", "throw", "new", "IllegalArgumentException", "(", "\"Unsupported SQL type: \"", "+", "type", ")", ";", "}", "}", "return", "value", ";", "}", "catch", "(", "Exception", "ex", ")", "{", "throw", "new", "MPXJException", "(", "\"Failed to parse \"", "+", "table", "+", "\".\"", "+", "column", "+", "\" (data=\"", "+", "data", "+", "\", type=\"", "+", "type", "+", "\")\"", ",", "ex", ")", ";", "}", "}" ]

[ "Maps", "the", "text", "representation", "of", "column", "data", "to", "Java", "types", "." ]

[ "private", "void", "executeGlobalPreprocessing", "(", "List", "<", "JoinableResourceBundle", ">", "bundlesToBuild", ",", "boolean", "processBundleFlag", ",", "StopWatch", "stopWatch", ")", "{", "stopProcessIfNeeded", "(", ")", ";", "if", "(", "resourceTypePreprocessor", "!=", "null", ")", "{", "if", "(", "stopWatch", "!=", "null", ")", "{", "stopWatch", ".", "start", "(", "\"Global preprocessing\"", ")", ";", "}", "GlobalPreprocessingContext", "ctx", "=", "new", "GlobalPreprocessingContext", "(", "config", ",", "resourceHandler", ",", "processBundleFlag", ")", ";", "resourceTypePreprocessor", ".", "processBundles", "(", "ctx", ",", "bundles", ")", ";", "// Update the list of bundle to rebuild if new bundles have been", "// detected as dirty in the global preprocessing phase", "List", "<", "JoinableResourceBundle", ">", "currentBundles", "=", "getBundlesToRebuild", "(", ")", ";", "for", "(", "JoinableResourceBundle", "b", ":", "currentBundles", ")", "{", "if", "(", "!", "bundlesToBuild", ".", "contains", "(", "b", ")", ")", "{", "bundlesToBuild", ".", "add", "(", "b", ")", ";", "}", "}", "if", "(", "stopWatch", "!=", "null", ")", "{", "stopWatch", ".", "stop", "(", ")", ";", "}", "}", "}" ]

[ "Executes", "the", "global", "preprocessing" ]

[ "private", "void", "onScrollPositionChanged", "(", "int", "oldScrollPosition", ",", "int", "newScrollPosition", ")", "{", "int", "newScrollDirection", ";", "if", "(", "newScrollPosition", "<", "oldScrollPosition", ")", "{", "newScrollDirection", "=", "SCROLL_TO_TOP", ";", "}", "else", "{", "newScrollDirection", "=", "SCROLL_TO_BOTTOM", ";", "}", "if", "(", "directionHasChanged", "(", "newScrollDirection", ")", ")", "{", "translateYAnimatedView", "(", "newScrollDirection", ")", ";", "}", "}" ]

[ "Perform", "the", "translateY", "animation", "using", "the", "new", "scroll", "position", "and", "the", "old", "scroll", "position", "to", "show", "or", "hide", "the", "animated", "view", "." ]

[ "public", "static", "Object", "buildGenericType", "(", "final", "Class", "<", "?", ">", "mainClass", ",", "final", "Class", "<", "?", ">", "assignableClass", ",", "final", "Object", "...", "parameters", ")", "throws", "CoreException", "{", "return", "buildGenericType", "(", "mainClass", ",", "new", "Class", "<", "?", ">", "[", "]", "{", "assignableClass", "}", ",", "parameters", ")", ";", "}" ]

[ "Build", "the", "nth", "generic", "type", "of", "a", "class", "." ]

[ "public", "static", "void", "escapeUriQueryParam", "(", "final", "Reader", "reader", ",", "final", "Writer", "writer", ",", "final", "String", "encoding", ")", "throws", "IOException", "{", "if", "(", "writer", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Argument 'writer' cannot be null\"", ")", ";", "}", "if", "(", "encoding", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Argument 'encoding' cannot be null\"", ")", ";", "}", "UriEscapeUtil", ".", "escape", "(", "reader", ",", "writer", ",", "UriEscapeUtil", ".", "UriEscapeType", ".", "QUERY_PARAM", ",", "encoding", ")", ";", "}" ]

[ "<p", ">", "Perform", "am", "URI", "query", "parameter", "(", "name", "or", "value", ")", "<strong", ">", "escape<", "/", "strong", ">", "operation", "on", "a", "<tt", ">", "Reader<", "/", "tt", ">", "input", "writing", "results", "to", "a", "<tt", ">", "Writer<", "/", "tt", ">", ".", "<", "/", "p", ">", "<p", ">", "The", "following", "are", "the", "only", "allowed", "chars", "in", "an", "URI", "query", "parameter", "(", "will", "not", "be", "escaped", ")", ":", "<", "/", "p", ">", "<ul", ">", "<li", ">", "<tt", ">", "A", "-", "Z", "a", "-", "z", "0", "-", "9<", "/", "tt", ">", "<", "/", "li", ">", "<li", ">", "<tt", ">", "-", ".", "_", "~<", "/", "tt", ">", "<", "/", "li", ">", "<li", ">", "<tt", ">", "!", "$", "(", ")", "*", ";", "<", "/", "tt", ">", "<", "/", "li", ">", "<li", ">", "<tt", ">", ":", "@<", "/", "tt", ">", "<", "/", "li", ">", "<li", ">", "<tt", ">", "/", "?<", "/", "tt", ">", "<", "/", "li", ">", "<", "/", "ul", ">", "<p", ">", "All", "other", "chars", "will", "be", "escaped", "by", "converting", "them", "to", "the", "sequence", "of", "bytes", "that", "represents", "them", "in", "the", "specified", "<em", ">", "encoding<", "/", "em", ">", "and", "then", "representing", "each", "byte", "in", "<tt", ">", "%HH<", "/", "tt", ">", "syntax", "being", "<tt", ">", "HH<", "/", "tt", ">", "the", "hexadecimal", "representation", "of", "the", "byte", ".", "<", "/", "p", ">", "<p", ">", "This", "method", "is", "<strong", ">", "thread", "-", "safe<", "/", "strong", ">", ".", "<", "/", "p", ">" ]

[ "@", "BetaApi", "public", "final", "Operation", "setTagsInstance", "(", "String", "instance", ",", "Tags", "tagsResource", ")", "{", "SetTagsInstanceHttpRequest", "request", "=", "SetTagsInstanceHttpRequest", ".", "newBuilder", "(", ")", ".", "setInstance", "(", "instance", ")", ".", "setTagsResource", "(", "tagsResource", ")", ".", "build", "(", ")", ";", "return", "setTagsInstance", "(", "request", ")", ";", "}" ]

[ "Sets", "network", "tags", "for", "the", "specified", "instance", "to", "the", "data", "included", "in", "the", "request", "." ]

[ "public", "ArchiveCoordinateModel", "getSingleOrCreate", "(", "String", "groupId", ",", "String", "artifactId", ",", "String", "version", ")", "{", "ArchiveCoordinateModel", "archive", "=", "findSingle", "(", "groupId", ",", "artifactId", ",", "version", ")", ";", "if", "(", "archive", "!=", "null", ")", "return", "archive", ";", "else", "return", "create", "(", ")", ".", "setGroupId", "(", "groupId", ")", ".", "setArtifactId", "(", "artifactId", ")", ".", "setVersion", "(", "version", ")", ";", "}" ]

[ "Returns", "a", "single", "ArchiveCoordinateModel", "with", "given", "G", ":", "A", ":", "V", ".", "Creates", "it", "if", "it", "does", "not", "already", "exist", "." ]

[ "protected", "void", "setField", "(", "final", "Field", "field", ",", "final", "IFile", "pData", ",", "final", "Object", "pValue", ")", "{", "if", "(", "field", "!=", "null", ")", "{", "try", "{", "field", ".", "set", "(", "pData", ",", "pValue", ")", ";", "}", "catch", "(", "IllegalArgumentException", "e", ")", "{", "LOGGER", ".", "error", "(", "\"Parameters of fied.set are not valid\"", ",", "e", ")", ";", "}", "catch", "(", "IllegalAccessException", "e", ")", "{", "LOGGER", ".", "error", "(", "\"Impossible to set the Field :\"", "+", "field", ".", "getName", "(", ")", ",", "e", ")", ";", "}", "}", "}" ]

[ "Method", "used", "to", "set", "the", "value", "of", "a", "field" ]

[ "public", "final", "void", "beginTransaction", "(", "GlobalTransaction", "globalTransaction", ",", "boolean", "local", ")", "{", "if", "(", "local", ")", "{", "//Not overriding the InitialValue method leads me to have \"null\" at the first invocation of get()", "TransactionStatistics", "lts", "=", "createTransactionStatisticIfAbsent", "(", "globalTransaction", ",", "true", ")", ";", "if", "(", "trace", ")", "{", "log", ".", "tracef", "(", "\"Local transaction statistic is already initialized: %s\"", ",", "lts", ")", ";", "}", "}", "else", "{", "TransactionStatistics", "rts", "=", "createTransactionStatisticIfAbsent", "(", "globalTransaction", ",", "false", ")", ";", "if", "(", "trace", ")", "{", "log", ".", "tracef", "(", "\"Using the remote transaction statistic %s for transaction %s\"", ",", "rts", ",", "globalTransaction", ")", ";", "}", "}", "}" ]

[ "Signals", "the", "start", "of", "a", "transaction", "." ]

[ "public", "static", "Fraction", "of", "(", "String", "str", ")", "{", "if", "(", "str", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"The string must not be null\"", ")", ";", "}", "// parse double format", "int", "pos", "=", "str", ".", "indexOf", "(", "'", "'", ")", ";", "if", "(", "pos", ">=", "0", ")", "{", "return", "of", "(", "Double", ".", "parseDouble", "(", "str", ")", ")", ";", "}", "// parse X Y/Z format", "pos", "=", "str", ".", "indexOf", "(", "'", "'", ")", ";", "if", "(", "pos", ">", "0", ")", "{", "final", "int", "whole", "=", "Integer", ".", "parseInt", "(", "str", ".", "substring", "(", "0", ",", "pos", ")", ")", ";", "str", "=", "str", ".", "substring", "(", "pos", "+", "1", ")", ";", "pos", "=", "str", ".", "indexOf", "(", "'", "'", ")", ";", "if", "(", "pos", "<", "0", ")", "{", "throw", "new", "NumberFormatException", "(", "\"The fraction could not be parsed as the format X Y/Z\"", ")", ";", "}", "else", "{", "final", "int", "numer", "=", "Integer", ".", "parseInt", "(", "str", ".", "substring", "(", "0", ",", "pos", ")", ")", ";", "final", "int", "denom", "=", "Integer", ".", "parseInt", "(", "str", ".", "substring", "(", "pos", "+", "1", ")", ")", ";", "return", "of", "(", "whole", ",", "numer", ",", "denom", ")", ";", "}", "}", "// parse Y/Z format", "pos", "=", "str", ".", "indexOf", "(", "'", "'", ")", ";", "if", "(", "pos", "<", "0", ")", "{", "// simple whole number", "return", "of", "(", "Integer", ".", "parseInt", "(", "str", ")", ",", "1", ")", ";", "}", "else", "{", "final", "int", "numer", "=", "Integer", ".", "parseInt", "(", "str", ".", "substring", "(", "0", ",", "pos", ")", ")", ";", "final", "int", "denom", "=", "Integer", ".", "parseInt", "(", "str", ".", "substring", "(", "pos", "+", "1", ")", ")", ";", "return", "of", "(", "numer", ",", "denom", ")", ";", "}", "}" ]

[ "<p", ">", "Creates", "a", "Fraction", "from", "a", "<code", ">", "String<", "/", "code", ">", ".", "<", "/", "p", ">" ]

[ "private", "File", "findBuildFile", "(", "final", "String", "start", ",", "final", "String", "suffix", ")", "{", "if", "(", "args", ".", "msgOutputLevel", ">=", "Project", ".", "MSG_INFO", ")", "{", "System", ".", "out", ".", "println", "(", "\"Searching for \"", "+", "suffix", "+", "\" ...\"", ")", ";", "}", "File", "parent", "=", "new", "File", "(", "new", "File", "(", "start", ")", ".", "getAbsolutePath", "(", ")", ")", ";", "File", "file", "=", "new", "File", "(", "parent", ",", "suffix", ")", ";", "// check if the target file exists in the current directory", "while", "(", "!", "file", ".", "exists", "(", ")", ")", "{", "// change to parent directory", "parent", "=", "getParentFile", "(", "parent", ")", ";", "// if parent is null, then we are at the root of the fs,", "// complain that we can't find the build file.", "if", "(", "parent", "==", "null", ")", "{", "return", "null", ";", "}", "// refresh our file handle", "file", "=", "new", "File", "(", "parent", ",", "suffix", ")", ";", "}", "return", "file", ";", "}" ]

[ "Search", "parent", "directories", "for", "the", "build", "file", ".", "<p", ">", "Takes", "the", "given", "target", "as", "a", "suffix", "to", "append", "to", "each", "parent", "directory", "in", "search", "of", "a", "build", "file", ".", "Once", "the", "root", "of", "the", "file", "-", "system", "has", "been", "reached", "<code", ">", "null<", "/", "code", ">", "is", "returned", "." ]

[ "private", "boolean", "readMetaSegment", "(", "ReadStream", "is", ",", "int", "crc", ")", "throws", "IOException", "{", "long", "value", "=", "BitsUtil", ".", "readLong", "(", "is", ")", ";", "crc", "=", "Crc32Caucho", ".", "generate", "(", "crc", ",", "value", ")", ";", "int", "crcFile", "=", "BitsUtil", ".", "readInt", "(", "is", ")", ";", "if", "(", "crcFile", "!=", "crc", ")", "{", "log", ".", "fine", "(", "\"meta-segment crc mismatch\"", ")", ";", "return", "false", ";", "}", "long", "address", "=", "value", "&", "~", "0xffff", ";", "int", "length", "=", "(", "int", ")", "(", "(", "value", "&", "0xffff", ")", "<<", "16", ")", ";", "SegmentExtent", "segment", "=", "new", "SegmentExtent", "(", "_segmentId", "++", ",", "address", ",", "length", ")", ";", "SegmentMeta", "segmentMeta", "=", "findSegmentMeta", "(", "length", ")", ";", "segmentMeta", ".", "addSegment", "(", "segment", ")", ";", "return", "true", ";", "}" ]

[ "metadata", "for", "a", "segment" ]

[ "private", "static", "long", "calcSliceFence", "(", "long", "skip", ",", "long", "limit", ")", "{", "long", "sliceFence", "=", "limit", ">=", "0", "?", "skip", "+", "limit", ":", "Long", ".", "MAX_VALUE", ";", "// Check for overflow", "return", "(", "sliceFence", ">=", "0", ")", "?", "sliceFence", ":", "Long", ".", "MAX_VALUE", ";", "}" ]

[ "Calculates", "the", "slice", "fence", "which", "is", "one", "past", "the", "index", "of", "the", "slice", "range" ]

[ "public", "Observable", "<", "TaskInner", ">", "beginCreateAsync", "(", "String", "resourceGroupName", ",", "String", "registryName", ",", "String", "taskName", ",", "TaskInner", "taskCreateParameters", ")", "{", "return", "beginCreateWithServiceResponseAsync", "(", "resourceGroupName", ",", "registryName", ",", "taskName", ",", "taskCreateParameters", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "TaskInner", ">", ",", "TaskInner", ">", "(", ")", "{", "@", "Override", "public", "TaskInner", "call", "(", "ServiceResponse", "<", "TaskInner", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Creates", "a", "task", "for", "a", "container", "registry", "with", "the", "specified", "parameters", "." ]

[ "public", "void", "addReaction", "(", "Emoji", "emoji", ",", "boolean", "you", ")", "{", "Optional", "<", "Reaction", ">", "reaction", "=", "reactions", ".", "stream", "(", ")", ".", "filter", "(", "r", "->", "emoji", ".", "equalsEmoji", "(", "r", ".", "getEmoji", "(", ")", ")", ")", ".", "findAny", "(", ")", ";", "reaction", ".", "ifPresent", "(", "r", "->", "(", "(", "ReactionImpl", ")", "r", ")", ".", "incrementCount", "(", "you", ")", ")", ";", "if", "(", "!", "reaction", ".", "isPresent", "(", ")", ")", "{", "reactions", ".", "add", "(", "new", "ReactionImpl", "(", "this", ",", "emoji", ",", "1", ",", "you", ")", ")", ";", "}", "}" ]

[ "Adds", "an", "emoji", "to", "the", "list", "of", "reactions", "." ]

[ "@", "Override", "protected", "Object", "doExec", "(", "Element", "element", ",", "Object", "scope", ",", "String", "propertyPath", ",", "Object", "...", "arguments", ")", "throws", "TemplateException", "{", "if", "(", "!", "propertyPath", ".", "equals", "(", "\".\"", ")", "&&", "ConverterRegistry", ".", "hasType", "(", "scope", ".", "getClass", "(", ")", ")", ")", "{", "throw", "new", "TemplateException", "(", "\"Operand is property path but scope is not an object.\"", ")", ";", "}", "String", "value", "=", "null", ";", "Format", "format", "=", "(", "Format", ")", "arguments", "[", "0", "]", ";", "if", "(", "format", "!=", "null", ")", "{", "value", "=", "this", ".", "content", ".", "getString", "(", "scope", ",", "propertyPath", ",", "format", ")", ";", "}", "else", "{", "Object", "object", "=", "this", ".", "content", ".", "getObject", "(", "scope", ",", "propertyPath", ")", ";", "if", "(", "object", "!=", "null", ")", "{", "if", "(", "!", "ConverterRegistry", ".", "hasType", "(", "object", ".", "getClass", "(", ")", ")", ")", "{", "throw", "new", "TemplateException", "(", "\"Invalid element |%s|. Operand for VALUE operator without formatter should be convertible to string.\"", ",", "element", ")", ";", "}", "value", "=", "ConverterRegistry", ".", "getConverter", "(", ")", ".", "asString", "(", "object", ")", ";", "}", "}", "if", "(", "value", "==", "null", ")", "{", "return", "null", ";", "}", "return", "new", "AttrImpl", "(", "\"value\"", ",", "value", ")", ";", "}" ]

[ "Execute", "VALUE", "operator", ".", "Uses", "property", "path", "to", "extract", "content", "value", "convert", "it", "to", "string", "and", "set", "element", "<em", ">", "value<", "/", "em", ">", "attribute", "." ]