Datasets:

---

stojchet

/

base_prediction_dataset

like 0

[ "public", "BidiWrappingText", "spanWrappingText", "(", "@", "Nullable", "Dir", "dir", ",", "String", "str", ",", "boolean", "isHtml", ")", "{", "if", "(", "dir", "==", "null", ")", "{", "dir", "=", "estimateDirection", "(", "str", ",", "isHtml", ")", ";", "}", "StringBuilder", "beforeText", "=", "new", "StringBuilder", "(", ")", ";", "StringBuilder", "afterText", "=", "new", "StringBuilder", "(", ")", ";", "boolean", "dirCondition", "=", "(", "dir", "!=", "Dir", ".", "NEUTRAL", "&&", "dir", "!=", "contextDir", ")", ";", "if", "(", "dirCondition", ")", "{", "beforeText", ".", "append", "(", "\"<span dir=\\\"\"", ")", ".", "append", "(", "dir", "==", "Dir", ".", "RTL", "?", "\"rtl\"", ":", "\"ltr\"", ")", ".", "append", "(", "\"\\\">\"", ")", ";", "afterText", ".", "append", "(", "\"</span>\"", ")", ";", "}", "afterText", ".", "append", "(", "markAfter", "(", "dir", ",", "str", ",", "isHtml", ")", ")", ";", "return", "BidiWrappingText", ".", "create", "(", "beforeText", ".", "toString", "(", ")", ",", "afterText", ".", "toString", "(", ")", ")", ";", "}" ]

[ "Operates", "like", "{", "@link", "#spanWrap", "(", "Dir", "String", "boolean", ")", "}", "but", "only", "returns", "the", "text", "that", "would", "be", "prepended", "and", "appended", "to", "{", "@code", "str", "}", "." ]

[ "public", "static", "boolean", "isAssignableOrConvertibleFrom", "(", "Class", "<", "?", ">", "clazz", ",", "Class", "<", "?", ">", "type", ")", "{", "if", "(", "type", "==", "null", "||", "clazz", "==", "null", ")", "{", "return", "false", ";", "}", "if", "(", "type", ".", "isPrimitive", "(", ")", ")", "{", "// convert primitive type to compatible class", "Class", "<", "?", ">", "primitiveClass", "=", "GrailsClassUtils", ".", "PRIMITIVE_TYPE_COMPATIBLE_CLASSES", ".", "get", "(", "type", ")", ";", "if", "(", "primitiveClass", "==", "null", ")", "{", "// no compatible class found for primitive type", "return", "false", ";", "}", "return", "clazz", ".", "isAssignableFrom", "(", "primitiveClass", ")", ";", "}", "return", "clazz", ".", "isAssignableFrom", "(", "type", ")", ";", "}" ]

[ "Returns", "true", "if", "the", "specified", "clazz", "parameter", "is", "either", "the", "same", "as", "or", "is", "a", "superclass", "or", "superinterface", "of", "the", "specified", "type", "parameter", ".", "Converts", "primitive", "types", "to", "compatible", "class", "automatically", "." ]

[ "public", "void", "setSourceSubsampling", "(", "int", "pXSub", ",", "int", "pYSub", ")", "{", "// Re-fetch everything, if subsampling changed", "if", "(", "xSub", "!=", "pXSub", "||", "ySub", "!=", "pYSub", ")", "{", "dispose", "(", ")", ";", "}", "if", "(", "pXSub", ">", "1", ")", "{", "xSub", "=", "pXSub", ";", "}", "if", "(", "pYSub", ">", "1", ")", "{", "ySub", "=", "pYSub", ";", "}", "}" ]

[ "Sets", "the", "source", "subsampling", "for", "the", "new", "image", "." ]

[ "public", "Dimension", "getMinDimension", "(", ")", "{", "long", "effWithMin", "=", "getEffectiveMinWidth", "(", ")", ";", "long", "effHeightMin", "=", "getEffectiveMinHeight", "(", ")", ";", "double", "effRatio", "=", "getRatio", "(", ")", ";", "if", "(", "effWithMin", "==", "0", "&&", "effHeightMin", ">", "0", "&&", "effRatio", ">", "0", ")", "{", "effWithMin", "=", "Math", ".", "round", "(", "effHeightMin", "*", "effRatio", ")", ";", "}", "if", "(", "effWithMin", ">", "0", "&&", "effHeightMin", "==", "0", "&&", "effRatio", ">", "0", ")", "{", "effHeightMin", "=", "Math", ".", "round", "(", "effWithMin", "/", "effRatio", ")", ";", "}", "if", "(", "effWithMin", ">", "0", "||", "effHeightMin", ">", "0", ")", "{", "return", "new", "Dimension", "(", "effWithMin", ",", "effHeightMin", ")", ";", "}", "else", "{", "return", "null", ";", "}", "}" ]

[ "Get", "minimum", "dimensions", "for", "media", "format", ".", "If", "only", "with", "or", "height", "is", "defined", "the", "missing", "dimensions", "is", "calculated", "from", "the", "ratio", ".", "If", "no", "ratio", "defined", "either", "only", "width", "or", "height", "dimension", "is", "returned", ".", "If", "neither", "width", "or", "height", "are", "defined", "null", "is", "returned", "." ]

[ "public", "static", "TableEntry", "unversioned", "(", "@", "NonNull", "ArrayView", "key", ",", "@", "NonNull", "ArrayView", "value", ")", "{", "return", "new", "TableEntry", "(", "TableKey", ".", "unversioned", "(", "key", ")", ",", "value", ")", ";", "}" ]

[ "Creates", "a", "new", "instance", "of", "the", "TableEntry", "class", "with", "no", "desired", "version", "." ]

[ "public", "static", "ImmutableSet", "<", "ExecutableElement", ">", "getLocalAndInheritedMethods", "(", "TypeElement", "type", ",", "Types", "typeUtils", ",", "Elements", "elementUtils", ")", "{", "return", "getLocalAndInheritedMethods", "(", "type", ",", "new", "ExplicitOverrides", "(", "typeUtils", ")", ")", ";", "}" ]

[ "Returns", "the", "set", "of", "all", "non", "-", "private", "methods", "from", "{", "@code", "type", "}", "including", "methods", "that", "it", "inherits", "from", "its", "ancestors", ".", "Inherited", "methods", "that", "are", "overridden", "are", "not", "included", "in", "the", "result", ".", "So", "if", "{", "@code", "type", "}", "defines", "{", "@code", "public", "String", "toString", "()", "}", "the", "returned", "set", "will", "contain", "that", "method", "but", "not", "the", "{", "@code", "toString", "()", "}", "method", "defined", "by", "{", "@code", "Object", "}", "." ]

[ "public", "String", "addSymbol", "(", "String", "symbol", ")", "{", "// search for identical symbol", "int", "bucket", "=", "hash", "(", "symbol", ")", "%", "fTableSize", ";", "int", "length", "=", "symbol", ".", "length", "(", ")", ";", "OUTER", ":", "for", "(", "Entry", "entry", "=", "fBuckets", "[", "bucket", "]", ";", "entry", "!=", "null", ";", "entry", "=", "entry", ".", "next", ")", "{", "if", "(", "length", "==", "entry", ".", "characters", ".", "length", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "length", ";", "i", "++", ")", "{", "if", "(", "symbol", ".", "charAt", "(", "i", ")", "!=", "entry", ".", "characters", "[", "i", "]", ")", "{", "continue", "OUTER", ";", "}", "}", "return", "entry", ".", "symbol", ";", "}", "}", "// create new entry", "Entry", "entry", "=", "new", "Entry", "(", "symbol", ",", "fBuckets", "[", "bucket", "]", ")", ";", "fBuckets", "[", "bucket", "]", "=", "entry", ";", "return", "entry", ".", "symbol", ";", "}" ]

[ "Adds", "the", "specified", "symbol", "to", "the", "symbol", "table", "and", "returns", "a", "reference", "to", "the", "unique", "symbol", ".", "If", "the", "symbol", "already", "exists", "the", "previous", "symbol", "reference", "is", "returned", "instead", "in", "order", "guarantee", "that", "symbol", "references", "remain", "unique", "." ]

[ "public", "Closure", "getBody", "(", ")", "{", "return", "new", "Closure", "(", "this", ".", "parent", ",", "this", ")", "{", "public", "void", "doCall", "(", "Object", "[", "]", "args", ")", "{", "final", "GroovyObject", "delegate", "=", "(", "GroovyObject", ")", "getDelegate", "(", ")", ";", "final", "GPathResult", "thisObject", "=", "(", "GPathResult", ")", "getThisObject", "(", ")", ";", "Node", "node", "=", "(", "Node", ")", "thisObject", ".", "getAt", "(", "0", ")", ";", "List", "children", "=", "node", ".", "children", "(", ")", ";", "for", "(", "Object", "child", ":", "children", ")", "{", "delegate", ".", "getProperty", "(", "\"mkp\"", ")", ";", "if", "(", "child", "instanceof", "Node", ")", "{", "delegate", ".", "invokeMethod", "(", "\"yield\"", ",", "new", "Object", "[", "]", "{", "new", "NodeChild", "(", "(", "Node", ")", "child", ",", "thisObject", ",", "\"*\"", ",", "null", ")", "}", ")", ";", "}", "else", "{", "delegate", ".", "invokeMethod", "(", "\"yield\"", ",", "new", "Object", "[", "]", "{", "child", "}", ")", ";", "}", "}", "}", "}", ";", "}" ]

[ "Creates", "a", "Closure", "representing", "the", "body", "of", "this", "GPathResult", "." ]

[ "protected", "Statement", "createGetterStatement", "(", "PropertyNode", "fxProperty", ")", "{", "String", "fxPropertyGetter", "=", "getFXPropertyGetterName", "(", "fxProperty", ")", ";", "VariableExpression", "thisExpression", "=", "VariableExpression", ".", "THIS_EXPRESSION", ";", "ArgumentListExpression", "emptyArguments", "=", "ArgumentListExpression", ".", "EMPTY_ARGUMENTS", ";", "// We're relying on the *Property() method to provide the return value - is this still needed??", "// Expression defaultReturn = defaultReturnMap.get(originalProperty.getType());", "// if (defaultReturn == null)", "// defaultReturn = ConstantExpression.NULL;", "MethodCallExpression", "getProperty", "=", "new", "MethodCallExpression", "(", "thisExpression", ",", "fxPropertyGetter", ",", "emptyArguments", ")", ";", "MethodCallExpression", "getValue", "=", "new", "MethodCallExpression", "(", "getProperty", ",", "\"getValue\"", ",", "emptyArguments", ")", ";", "return", "new", "ReturnStatement", "(", "new", "ExpressionStatement", "(", "getValue", ")", ")", ";", "}" ]

[ "Creates", "the", "body", "of", "a", "getter", "method", "for", "the", "original", "property", "that", "is", "actually", "backed", "by", "a", "JavaFX", "*", "Property", "instance", ":", "<p", ">", "Object", "$property", "=", "this", ".", "someProperty", "()", "return", "$property", ".", "getValue", "()" ]

[ "public", "RpcInternalContext", "setAttachment", "(", "String", "key", ",", "Object", "value", ")", "{", "if", "(", "key", "==", "null", ")", "{", "return", "this", ";", "}", "if", "(", "!", "ATTACHMENT_ENABLE", ")", "{", "// 未开启附件传递功能，只能传递隐藏key(\".\" 开头的Key）", "if", "(", "!", "isHiddenParamKey", "(", "key", ")", ")", "{", "return", "this", ";", "}", "}", "else", "{", "if", "(", "!", "isValidInternalParamKey", "(", "key", ")", ")", "{", "// 打开附件传递功能，只能传 \"_\" 和 \".\" 开头的Key", "throw", "new", "IllegalArgumentException", "(", "\"key must start with\"", "+", "RpcConstants", ".", "INTERNAL_KEY_PREFIX", "+", "\" or \"", "+", "RpcConstants", ".", "HIDE_KEY_PREFIX", ")", ";", "}", "}", "if", "(", "value", "==", "null", ")", "{", "attachments", ".", "remove", "(", "key", ")", ";", "}", "else", "{", "attachments", ".", "put", "(", "key", ",", "value", ")", ";", "}", "return", "this", ";", "}" ]

[ "set", "attachment", "." ]

[ "public", "static", "boolean", "executeModifyOperation", "(", "final", "String", "currentDn", ",", "final", "ConnectionFactory", "connectionFactory", ",", "final", "Map", "<", "String", ",", "Set", "<", "String", ">", ">", "attributes", ")", "{", "try", "(", "val", "modifyConnection", "=", "createConnection", "(", "connectionFactory", ")", ")", "{", "val", "operation", "=", "new", "ModifyOperation", "(", "modifyConnection", ")", ";", "val", "mods", "=", "attributes", ".", "entrySet", "(", ")", ".", "stream", "(", ")", ".", "map", "(", "entry", "->", "{", "val", "values", "=", "entry", ".", "getValue", "(", ")", ".", "toArray", "(", "ArrayUtils", ".", "EMPTY_STRING_ARRAY", ")", ";", "val", "attr", "=", "new", "LdapAttribute", "(", "entry", ".", "getKey", "(", ")", ",", "values", ")", ";", "return", "new", "AttributeModification", "(", "AttributeModificationType", ".", "REPLACE", ",", "attr", ")", ";", "}", ")", ".", "toArray", "(", "value", "->", "new", "AttributeModification", "[", "attributes", ".", "size", "(", ")", "]", ")", ";", "val", "request", "=", "new", "ModifyRequest", "(", "currentDn", ",", "mods", ")", ";", "request", ".", "setReferralHandler", "(", "new", "ModifyReferralHandler", "(", ")", ")", ";", "operation", ".", "execute", "(", "request", ")", ";", "return", "true", ";", "}", "catch", "(", "final", "LdapException", "e", ")", "{", "LOGGER", ".", "error", "(", "e", ".", "getMessage", "(", ")", ",", "e", ")", ";", "}", "return", "false", ";", "}" ]

[ "Execute", "modify", "operation", "boolean", "." ]

[ "public", "B", "camundaOutputParameter", "(", "String", "name", ",", "String", "value", ")", "{", "CamundaInputOutput", "camundaInputOutput", "=", "getCreateSingleExtensionElement", "(", "CamundaInputOutput", ".", "class", ")", ";", "CamundaOutputParameter", "camundaOutputParameter", "=", "createChild", "(", "camundaInputOutput", ",", "CamundaOutputParameter", ".", "class", ")", ";", "camundaOutputParameter", ".", "setCamundaName", "(", "name", ")", ";", "camundaOutputParameter", ".", "setTextContent", "(", "value", ")", ";", "return", "myself", ";", "}" ]

[ "Creates", "a", "new", "camunda", "output", "parameter", "extension", "element", "with", "the", "given", "name", "and", "value", "." ]

[ "public", "BoxRequestsBookmark", ".", "CopyBookmark", "getCopyRequest", "(", "String", "id", ",", "String", "parentId", ")", "{", "BoxRequestsBookmark", ".", "CopyBookmark", "request", "=", "new", "BoxRequestsBookmark", ".", "CopyBookmark", "(", "id", ",", "parentId", ",", "getBookmarkCopyUrl", "(", "id", ")", ",", "mSession", ")", ";", "return", "request", ";", "}" ]

[ "Gets", "a", "request", "that", "copies", "a", "bookmark" ]

[ "public", "static", "<", "T", ">", "Position", ".", "Readable", "<", "T", ">", "readOnly", "(", "final", "Typed", "<", "T", ">", "typed", ",", "final", "Supplier", "<", "T", ">", "supplier", ")", "{", "return", "readOnly", "(", "Validate", ".", "notNull", "(", "typed", ",", "\"type\"", ")", ".", "getType", "(", ")", ",", "supplier", ")", ";", "}" ]

[ "Get", "a", "read", "-", "only", "position", "of", "type", "{", "@code", "typed", ".", "type", "}", "obtaining", "its", "value", "from", "{", "@code", "supplier", "}", "." ]

[ "public", "static", "List", "<", "PartitionIDRange", ">", "getGlobalRange", "(", "final", "int", "partitionBits", ")", "{", "Preconditions", ".", "checkArgument", "(", "partitionBits", ">=", "0", "&&", "partitionBits", "<", "(", "Integer", ".", "SIZE", "-", "1", ")", ",", "\"Invalid partition bits: %s\"", ",", "partitionBits", ")", ";", "final", "int", "partitionIdBound", "=", "(", "1", "<<", "(", "partitionBits", ")", ")", ";", "return", "ImmutableList", ".", "of", "(", "new", "PartitionIDRange", "(", "0", ",", "partitionIdBound", ",", "partitionIdBound", ")", ")", ";", "}" ]

[ "/", "*", "===========", "Helper", "methods", "to", "generate", "PartitionIDRanges", "============" ]

[ "private", "void", "scheduleSpecsFromCatalog", "(", ")", "{", "Iterator", "<", "URI", ">", "specUris", "=", "null", ";", "long", "startTime", "=", "System", ".", "currentTimeMillis", "(", ")", ";", "try", "{", "specUris", "=", "this", ".", "flowCatalog", ".", "get", "(", ")", ".", "getSpecURIs", "(", ")", ";", "}", "catch", "(", "SpecSerDeException", "ssde", ")", "{", "throw", "new", "RuntimeException", "(", "\"Failed to get the iterator of all Spec URIS\"", ",", "ssde", ")", ";", "}", "try", "{", "while", "(", "specUris", ".", "hasNext", "(", ")", ")", "{", "Spec", "spec", "=", "null", ";", "try", "{", "spec", "=", "this", ".", "flowCatalog", ".", "get", "(", ")", ".", "getSpec", "(", "specUris", ".", "next", "(", ")", ")", ";", "}", "catch", "(", "SpecNotFoundException", "snfe", ")", "{", "_log", ".", "error", "(", "String", ".", "format", "(", "\"The URI %s discovered in SpecStore is missing in FlowCatlog\"", "+", "\", suspecting current modification on SpecStore\"", ",", "specUris", ".", "next", "(", ")", ")", ",", "snfe", ")", ";", "}", "//Disable FLOW_RUN_IMMEDIATELY on service startup or leadership change", "if", "(", "spec", "instanceof", "FlowSpec", ")", "{", "Spec", "modifiedSpec", "=", "disableFlowRunImmediatelyOnStart", "(", "(", "FlowSpec", ")", "spec", ")", ";", "onAddSpec", "(", "modifiedSpec", ")", ";", "}", "else", "{", "onAddSpec", "(", "spec", ")", ";", "}", "}", "}", "finally", "{", "this", ".", "flowCatalog", ".", "get", "(", ")", ".", "getMetrics", "(", ")", ".", "updateGetSpecTime", "(", "startTime", ")", ";", "}", "}" ]

[ "Load", "all", "{", "@link", "FlowSpec", "}", "s", "from", "{", "@link", "FlowCatalog", "}", "as", "one", "of", "the", "initialization", "step", "and", "make", "schedulers", "be", "aware", "of", "that", "." ]

[ "protected", "void", "applyInterceptors", "(", "ServiceContext", "<", "?", ">", "context", ",", "InterceptorProvider", "client", ",", "String", "serviceName", ")", "{", "client", ".", "getOutInterceptors", "(", ")", ".", "add", "(", "new", "PerformanceStartInterceptor", "(", ")", ")", ";", "client", ".", "getInInterceptors", "(", ")", ".", "add", "(", "new", "PerformanceStopInterceptor", "(", ")", ")", ";", "client", ".", "getInFaultInterceptors", "(", ")", ".", "add", "(", "new", "TechnicalExceptionInterceptor", "(", "serviceName", ")", ")", ";", "}" ]

[ "Applies", "CXF", "interceptors", "to", "the", "given", "{", "@code", "serviceClient", "}", "." ]

[ "public", "ArrayList", "<", "OvhDeviceAction", ">", "serviceName_device_restoreBackup_POST", "(", "String", "serviceName", ",", "String", "backupId", ")", "throws", "IOException", "{", "String", "qPath", "=", "\"/overTheBox/{serviceName}/device/restoreBackup\"", ";", "StringBuilder", "sb", "=", "path", "(", "qPath", ",", "serviceName", ")", ";", "HashMap", "<", "String", ",", "Object", ">", "o", "=", "new", "HashMap", "<", "String", ",", "Object", ">", "(", ")", ";", "addBody", "(", "o", ",", "\"backupId\"", ",", "backupId", ")", ";", "String", "resp", "=", "exec", "(", "qPath", ",", "\"POST\"", ",", "sb", ".", "toString", "(", ")", ",", "o", ")", ";", "return", "convertTo", "(", "resp", ",", "t4", ")", ";", "}" ]

[ "Create", "a", "group", "of", "actions", "to", "restore", "a", "given", "backup" ]

[ "public", "Components", "getComponents", "(", ")", "{", "if", "(", "this", ".", "components", "==", "null", ")", "{", "// This is idempotent, so no need to synchronize ...", "// Calculate how many seconds, and don't lose any information ...", "BigDecimal", "bigSeconds", "=", "new", "BigDecimal", "(", "this", ".", "durationInNanos", ")", ".", "divide", "(", "new", "BigDecimal", "(", "1000000000", ")", ")", ";", "// Calculate the minutes, and round to lose the seconds", "int", "minutes", "=", "bigSeconds", ".", "intValue", "(", ")", "/", "60", ";", "// Remove the minutes from the seconds, to just have the remainder of seconds", "double", "dMinutes", "=", "minutes", ";", "double", "seconds", "=", "bigSeconds", ".", "doubleValue", "(", ")", "-", "dMinutes", "*", "60", ";", "// Now compute the number of full hours, and change 'minutes' to hold the remainding minutes", "int", "hours", "=", "minutes", "/", "60", ";", "minutes", "=", "minutes", "-", "(", "hours", "*", "60", ")", ";", "this", ".", "components", "=", "new", "Components", "(", "hours", ",", "minutes", ",", "seconds", ")", ";", "}", "return", "this", ".", "components", ";", "}" ]

[ "Return", "the", "duration", "components", "." ]

[ "public", "static", "int", "typeCompareTo", "(", "Writable", "one", ",", "Writable", "other", ")", "{", "PrimitiveObject", "noOne", "=", "hadoop2Primitive", "(", "one", ")", ";", "PrimitiveObject", "noOther", "=", "hadoop2Primitive", "(", "other", ")", ";", "if", "(", "noOne", ".", "getType", "(", ")", "!=", "noOther", ".", "getType", "(", ")", ")", "{", "return", "-", "1", ";", "}", "return", "0", ";", "}" ]

[ "Compare", "the", "type", "Writable", "." ]

[ "static", "ZoneOffsetTransitionRule", "readExternal", "(", "DataInput", "in", ")", "throws", "IOException", "{", "int", "data", "=", "in", ".", "readInt", "(", ")", ";", "Month", "month", "=", "Month", ".", "of", "(", "data", ">>>", "28", ")", ";", "int", "dom", "=", "(", "(", "data", "&", "(", "63", "<<", "22", ")", ")", ">>>", "22", ")", "-", "32", ";", "int", "dowByte", "=", "(", "data", "&", "(", "7", "<<", "19", ")", ")", ">>>", "19", ";", "DayOfWeek", "dow", "=", "dowByte", "==", "0", "?", "null", ":", "DayOfWeek", ".", "of", "(", "dowByte", ")", ";", "int", "timeByte", "=", "(", "data", "&", "(", "31", "<<", "14", ")", ")", ">>>", "14", ";", "TimeDefinition", "defn", "=", "TimeDefinition", ".", "values", "(", ")", "[", "(", "data", "&", "(", "3", "<<", "12", ")", ")", ">>>", "12", "]", ";", "int", "stdByte", "=", "(", "data", "&", "(", "255", "<<", "4", ")", ")", ">>>", "4", ";", "int", "beforeByte", "=", "(", "data", "&", "(", "3", "<<", "2", ")", ")", ">>>", "2", ";", "int", "afterByte", "=", "(", "data", "&", "3", ")", ";", "int", "timeOfDaysSecs", "=", "(", "timeByte", "==", "31", "?", "in", ".", "readInt", "(", ")", ":", "timeByte", "*", "3600", ")", ";", "ZoneOffset", "std", "=", "(", "stdByte", "==", "255", "?", "ZoneOffset", ".", "ofTotalSeconds", "(", "in", ".", "readInt", "(", ")", ")", ":", "ZoneOffset", ".", "ofTotalSeconds", "(", "(", "stdByte", "-", "128", ")", "*", "900", ")", ")", ";", "ZoneOffset", "before", "=", "(", "beforeByte", "==", "3", "?", "ZoneOffset", ".", "ofTotalSeconds", "(", "in", ".", "readInt", "(", ")", ")", ":", "ZoneOffset", ".", "ofTotalSeconds", "(", "std", ".", "getTotalSeconds", "(", ")", "+", "beforeByte", "*", "1800", ")", ")", ";", "ZoneOffset", "after", "=", "(", "afterByte", "==", "3", "?", "ZoneOffset", ".", "ofTotalSeconds", "(", "in", ".", "readInt", "(", ")", ")", ":", "ZoneOffset", ".", "ofTotalSeconds", "(", "std", ".", "getTotalSeconds", "(", ")", "+", "afterByte", "*", "1800", ")", ")", ";", "// only bit of validation that we need to copy from public of() method", "if", "(", "dom", "<", "-", "28", "||", "dom", ">", "31", "||", "dom", "==", "0", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Day of month indicator must be between -28 and 31 inclusive excluding zero\"", ")", ";", "}", "LocalTime", "time", "=", "LocalTime", ".", "ofSecondOfDay", "(", "Jdk8Methods", ".", "floorMod", "(", "timeOfDaysSecs", ",", "SECS_PER_DAY", ")", ")", ";", "int", "adjustDays", "=", "Jdk8Methods", ".", "floorDiv", "(", "timeOfDaysSecs", ",", "SECS_PER_DAY", ")", ";", "return", "new", "ZoneOffsetTransitionRule", "(", "month", ",", "dom", ",", "dow", ",", "time", ",", "adjustDays", ",", "defn", ",", "std", ",", "before", ",", "after", ")", ";", "}" ]

[ "Reads", "the", "state", "from", "the", "stream", "." ]

[ "public", "void", "startRecording", "(", ")", "{", "if", "(", "currentAudioState", ".", "get", "(", ")", "==", "PREPARED_STATE", ")", "{", "currentAudioRecordingThread", "=", "new", "AudioRecorderThread", "(", "audioFile", ".", "replace", "(", "\".wav\"", ",", "\".temp\"", ")", ",", "MediaRecorder", ".", "AudioSource", ".", "MIC", ",", "sampleRateInHertz", ",", "channelConfig", ",", "audioEncoding", ",", "maxFileSizeInBytes", ")", ";", "currentAudioState", ".", "set", "(", "RECORDING_STATE", ")", ";", "currentAudioRecordingThread", ".", "start", "(", ")", ";", "onTimeCompletedTimer", "=", "new", "Timer", "(", "true", ")", ";", "onTimeCompletionTimerTask", "=", "new", "MaxTimeTimerTask", "(", ")", ";", "onTimeCompletedTimer", ".", "schedule", "(", "onTimeCompletionTimerTask", ",", "maxTimeInMillis", ")", ";", "remainingMaxTimeInMillis", "=", "maxTimeInMillis", ";", "recordingStartTimeMillis", "=", "System", ".", "currentTimeMillis", "(", ")", ";", "}", "else", "{", "Log", ".", "w", "(", "TAG", ",", "\"Audio recorder is not in prepared state. Ignoring call.\"", ")", ";", "}", "}" ]

[ "Starts", "the", "recording", "if", "the", "recorder", "is", "in", "a", "prepared", "state", ".", "At", "this", "time", "the", "complete", "file", "path", "should", "not", "have", ".", "temp", "file", "(", "as", "that", "is", "where", "the", "writing", "is", "taking", "place", ")", "and", "the", "specified", ".", "wav", "file", "should", "not", "exist", "as", "well", "(", "as", "that", "is", "where", "the", ".", "temp", "file", "will", "be", "converted", "to", ")", ".", "Does", "nothing", "if", "it", "is", "recorder", "is", "not", "in", "a", "prepared", "state", "." ]

[ "public", "void", "setHonorsVisibility", "(", "Component", "component", ",", "Boolean", "b", ")", "{", "CellConstraints", "constraints", "=", "getConstraints0", "(", "component", ")", ";", "if", "(", "Objects", ".", "equals", "(", "b", ",", "constraints", ".", "honorsVisibility", ")", ")", "{", "return", ";", "}", "constraints", ".", "honorsVisibility", "=", "b", ";", "invalidateAndRepaint", "(", "component", ".", "getParent", "(", ")", ")", ";", "}" ]

[ "Specifies", "whether", "the", "given", "component", "shall", "be", "taken", "into", "account", "for", "sizing", "and", "positioning", ".", "This", "setting", "overrides", "the", "container", "-", "wide", "default", ".", "See", "{", "@link", "#setHonorsVisibility", "(", "boolean", ")", "}", "for", "details", "." ]

[ "protected", "String", "getTitle", "(", "final", "String", "input", ",", "final", "char", "startDelim", ")", "{", "if", "(", "isStringNullOrEmpty", "(", "input", ")", ")", "{", "return", "null", ";", "}", "else", "{", "return", "ProcessorUtilities", ".", "cleanXMLCharacterReferences", "(", "StringUtilities", ".", "split", "(", "input", ",", "startDelim", ")", "[", "0", "]", ".", "trim", "(", ")", ")", ";", "}", "}" ]

[ "Gets", "the", "title", "of", "a", "chapter", "/", "section", "/", "appendix", "/", "topic", "by", "returning", "everything", "before", "the", "start", "delimiter", "." ]

[ "public", "boolean", "computeShiftInvert", "(", "DMatrixRMaj", "A", ",", "double", "alpha", ")", "{", "initPower", "(", "A", ")", ";", "LinearSolverDense", "solver", "=", "LinearSolverFactory_DDRM", ".", "linear", "(", "A", ".", "numCols", ")", ";", "SpecializedOps_DDRM", ".", "addIdentity", "(", "A", ",", "B", ",", "-", "alpha", ")", ";", "solver", ".", "setA", "(", "B", ")", ";", "boolean", "converged", "=", "false", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "maxIterations", "&&", "!", "converged", ";", "i", "++", ")", "{", "solver", ".", "solve", "(", "q0", ",", "q1", ")", ";", "double", "s", "=", "NormOps_DDRM", ".", "normPInf", "(", "q1", ")", ";", "CommonOps_DDRM", ".", "divide", "(", "q1", ",", "s", ",", "q2", ")", ";", "converged", "=", "checkConverged", "(", "A", ")", ";", "}", "return", "converged", ";", "}" ]

[ "Computes", "the", "most", "dominant", "eigen", "vector", "of", "A", "using", "an", "inverted", "shifted", "matrix", ".", "The", "inverted", "shifted", "matrix", "is", "defined", "as", "<b", ">", "B", "=", "(", "A", "-", "&alpha", ";", "I", ")", "<sup", ">", "-", "1<", "/", "sup", ">", "<", "/", "b", ">", "and", "can", "converge", "faster", "if", "&alpha", ";", "is", "chosen", "wisely", "." ]

[ "private", "void", "writeZeroString", "(", "String", "outString", ",", "OutputStream", "outStream", ")", "throws", "IOException", "{", "simpleWriteString", "(", "outString", ",", "outStream", ")", ";", "outStream", ".", "write", "(", "0", ")", ";", "outStream", ".", "write", "(", "0", ")", ";", "}" ]

[ "Writes", "zero", "-", "string", "into", "stream", "." ]

[ "double", "computeAngle", "(", "int", "index1", ")", "{", "int", "index0", "=", "CircularIndex", ".", "addOffset", "(", "index1", ",", "-", "1", ",", "histogramMag", ".", "length", ")", ";", "int", "index2", "=", "CircularIndex", ".", "addOffset", "(", "index1", ",", "1", ",", "histogramMag", ".", "length", ")", ";", "// compute the peak location using a second order polygon", "double", "v0", "=", "histogramMag", "[", "index0", "]", ";", "double", "v1", "=", "histogramMag", "[", "index1", "]", ";", "double", "v2", "=", "histogramMag", "[", "index2", "]", ";", "double", "offset", "=", "FastHessianFeatureDetector", ".", "polyPeak", "(", "v0", ",", "v1", ",", "v2", ")", ";", "// interpolate using the index offset and angle of its neighbor", "return", "interpolateAngle", "(", "index0", ",", "index1", ",", "index2", ",", "offset", ")", ";", "}" ]

[ "Compute", "the", "angle", ".", "The", "angle", "for", "each", "neighbor", "bin", "is", "found", "using", "the", "weighted", "sum", "of", "the", "derivative", ".", "Then", "the", "peak", "index", "is", "found", "by", "2nd", "order", "polygon", "interpolation", ".", "These", "two", "bits", "of", "information", "are", "combined", "and", "used", "to", "return", "the", "final", "angle", "output", "." ]

[ "@", "SuppressWarnings", "(", "{", "\"rawtypes\"", ",", "\"unchecked\"", "}", ")", "protected", "String", "getCommonSuperClass", "(", "final", "String", "type1", ",", "final", "String", "type2", ")", "{", "Class", "c", ",", "d", ";", "try", "{", "c", "=", "Class", ".", "forName", "(", "type1", ".", "replace", "(", "'", "'", ",", "'", "'", ")", ")", ";", "d", "=", "Class", ".", "forName", "(", "type2", ".", "replace", "(", "'", "'", ",", "'", "'", ")", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "RuntimeException", "(", "e", ".", "toString", "(", ")", ")", ";", "}", "if", "(", "c", ".", "isAssignableFrom", "(", "d", ")", ")", "{", "return", "type1", ";", "}", "if", "(", "d", ".", "isAssignableFrom", "(", "c", ")", ")", "{", "return", "type2", ";", "}", "if", "(", "c", ".", "isInterface", "(", ")", "||", "d", ".", "isInterface", "(", ")", ")", "{", "return", "\"java/lang/Object\"", ";", "}", "else", "{", "do", "{", "c", "=", "c", ".", "getSuperclass", "(", ")", ";", "}", "while", "(", "!", "c", ".", "isAssignableFrom", "(", "d", ")", ")", ";", "return", "c", ".", "getName", "(", ")", ".", "replace", "(", "'", "'", ",", "'", "'", ")", ";", "}", "}" ]

[ "Returns", "the", "common", "super", "type", "of", "the", "two", "given", "types", ".", "The", "default", "implementation", "of", "this", "method", "<i", ">", "loads<i", ">", "the", "two", "given", "classes", "and", "uses", "the", "java", ".", "lang", ".", "Class", "methods", "to", "find", "the", "common", "super", "class", ".", "It", "can", "be", "overridden", "to", "compute", "this", "common", "super", "type", "in", "other", "ways", "in", "particular", "without", "actually", "loading", "any", "class", "or", "to", "take", "into", "account", "the", "class", "that", "is", "currently", "being", "generated", "by", "this", "ClassWriter", "which", "can", "of", "course", "not", "be", "loaded", "since", "it", "is", "under", "construction", "." ]

[ "String", "getQueryString", "(", "Map", "<", "String", ",", "String", ">", "params", ")", "{", "StringBuilder", "builder", "=", "new", "StringBuilder", "(", ")", ";", "try", "{", "boolean", "first", "=", "true", ";", "for", "(", "Map", ".", "Entry", "<", "String", ",", "String", ">", "entry", ":", "params", ".", "entrySet", "(", ")", ")", "{", "if", "(", "first", ")", "{", "first", "=", "false", ";", "}", "else", "{", "builder", ".", "append", "(", "\"&\"", ")", ";", "}", "builder", ".", "append", "(", "URLEncoder", ".", "encode", "(", "entry", ".", "getKey", "(", ")", ",", "\"UTF-8\"", ")", ")", ";", "builder", ".", "append", "(", "\"=\"", ")", ";", "builder", ".", "append", "(", "URLEncoder", ".", "encode", "(", "entry", ".", "getValue", "(", ")", ",", "\"UTF-8\"", ")", ")", ";", "}", "}", "catch", "(", "UnsupportedEncodingException", "e", ")", "{", "throw", "new", "RuntimeException", "(", "\"Your Java version does not support UTF-8 encoding.\"", ")", ";", "}", "return", "builder", ".", "toString", "(", ")", ";", "}" ]

[ "Returns", "the", "query", "string", "of", "a", "URL", "from", "a", "parameter", "list", "." ]

[ "private", "String", "getLogString", "(", "String", "message", ",", "String", "taskName", ")", "{", "return", "BatchTask", ".", "constructLogString", "(", "message", ",", "taskName", ",", "this", ")", ";", "}" ]

[ "Utility", "function", "that", "composes", "a", "string", "for", "logging", "purposes", ".", "The", "string", "includes", "the", "given", "message", "and", "the", "index", "of", "the", "task", "in", "its", "task", "group", "together", "with", "the", "number", "of", "tasks", "in", "the", "task", "group", "." ]

[ "public", "static", "<", "T", ">", "T", "withDataInputStream", "(", "File", "file", ",", "@", "ClosureParams", "(", "value", "=", "SimpleType", ".", "class", ",", "options", "=", "\"java.io.DataInputStream\"", ")", "Closure", "<", "T", ">", "closure", ")", "throws", "IOException", "{", "return", "IOGroovyMethods", ".", "withStream", "(", "newDataInputStream", "(", "file", ")", ",", "closure", ")", ";", "}" ]

[ "Create", "a", "new", "DataInputStream", "for", "this", "file", "and", "passes", "it", "into", "the", "closure", ".", "This", "method", "ensures", "the", "stream", "is", "closed", "after", "the", "closure", "returns", "." ]

[ "public", "BatchResult", "addBatch", "(", "ApplicationDefinition", "appDef", ",", "String", "shardName", ",", "OlapBatch", "batch", ")", "{", "return", "addBatch", "(", "appDef", ",", "shardName", ",", "batch", ",", "null", ")", ";", "}" ]

[ "Add", "a", "batch", "of", "updates", "for", "the", "given", "application", "to", "the", "given", "shard", ".", "Objects", "can", "new", "updated", "or", "deleted", "." ]

[ "private", "boolean", "containsType", "(", "Throwable", "exception", ",", "Class", "<", "?", "extends", "Exception", ">", "expectedType", ")", "{", "Throwable", "transformedException", "=", "transform", "(", "exception", ")", ";", "if", "(", "transformedException", "==", "null", ")", "{", "return", "false", ";", "}", "if", "(", "expectedType", ".", "isAssignableFrom", "(", "transformedException", ".", "getClass", "(", ")", ")", ")", "{", "return", "true", ";", "}", "return", "containsType", "(", "transformedException", ".", "getCause", "(", ")", ",", "expectedType", ")", ";", "}" ]

[ "/", "*", "public", "void", "verifyExpectedExceptionDuringUnDeploy", "(" ]

[ "private", "void", "processFile", "(", "final", "ResolveTask", "r", ")", "{", "final", "List", "<", "XMLFilter", ">", "filters", "=", "new", "ArrayList", "<>", "(", ")", ";", "final", "ConkeyrefFilter", "conkeyrefFilter", "=", "new", "ConkeyrefFilter", "(", ")", ";", "conkeyrefFilter", ".", "setLogger", "(", "logger", ")", ";", "conkeyrefFilter", ".", "setJob", "(", "job", ")", ";", "conkeyrefFilter", ".", "setKeyDefinitions", "(", "r", ".", "scope", ")", ";", "conkeyrefFilter", ".", "setCurrentFile", "(", "job", ".", "tempDirURI", ".", "resolve", "(", "r", ".", "in", ".", "uri", ")", ")", ";", "conkeyrefFilter", ".", "setDelayConrefUtils", "(", "delayConrefUtils", ")", ";", "filters", ".", "add", "(", "conkeyrefFilter", ")", ";", "filters", ".", "add", "(", "topicFragmentFilter", ")", ";", "final", "KeyrefPaser", "parser", "=", "new", "KeyrefPaser", "(", ")", ";", "parser", ".", "setLogger", "(", "logger", ")", ";", "parser", ".", "setJob", "(", "job", ")", ";", "parser", ".", "setKeyDefinition", "(", "r", ".", "scope", ")", ";", "parser", ".", "setCurrentFile", "(", "job", ".", "tempDirURI", ".", "resolve", "(", "r", ".", "in", ".", "uri", ")", ")", ";", "filters", ".", "add", "(", "parser", ")", ";", "try", "{", "logger", ".", "debug", "(", "\"Using \"", "+", "(", "r", ".", "scope", ".", "name", "!=", "null", "?", "r", ".", "scope", ".", "name", "+", "\" scope\"", ":", "\"root scope\"", ")", ")", ";", "if", "(", "r", ".", "out", "!=", "null", ")", "{", "logger", ".", "info", "(", "\"Processing \"", "+", "job", ".", "tempDirURI", ".", "resolve", "(", "r", ".", "in", ".", "uri", ")", "+", "\" to \"", "+", "job", ".", "tempDirURI", ".", "resolve", "(", "r", ".", "out", ".", "uri", ")", ")", ";", "xmlUtils", ".", "transform", "(", "new", "File", "(", "job", ".", "tempDir", ",", "r", ".", "in", ".", "file", ".", "getPath", "(", ")", ")", ",", "new", "File", "(", "job", ".", "tempDir", ",", "r", ".", "out", ".", "file", ".", "getPath", "(", ")", ")", ",", "filters", ")", ";", "}", "else", "{", "logger", ".", "info", "(", "\"Processing \"", "+", "job", ".", "tempDirURI", ".", "resolve", "(", "r", ".", "in", ".", "uri", ")", ")", ";", "xmlUtils", ".", "transform", "(", "new", "File", "(", "job", ".", "tempDir", ",", "r", ".", "in", ".", "file", ".", "getPath", "(", ")", ")", ",", "filters", ")", ";", "}", "// validate resource-only list", "normalProcessingRole", ".", "addAll", "(", "parser", ".", "getNormalProcessingRoleTargets", "(", ")", ")", ";", "}", "catch", "(", "final", "DITAOTException", "e", ")", "{", "logger", ".", "error", "(", "\"Failed to process key references: \"", "+", "e", ".", "getMessage", "(", ")", ",", "e", ")", ";", "}", "}" ]

[ "Process", "key", "references", "in", "a", "topic", ".", "Topic", "is", "stored", "with", "a", "new", "name", "if", "it", "s", "been", "processed", "before", "." ]

[ "private", "void", "loadLibraryFromStream", "(", "String", "libname", ",", "InputStream", "is", ")", "{", "try", "{", "File", "tempfile", "=", "createTempFile", "(", "libname", ")", ";", "OutputStream", "os", "=", "new", "FileOutputStream", "(", "tempfile", ")", ";", "logger", ".", "debug", "(", "\"tempfile.getPath() = \"", "+", "tempfile", ".", "getPath", "(", ")", ")", ";", "long", "savedTime", "=", "System", ".", "currentTimeMillis", "(", ")", ";", "// Leo says 8k block size is STANDARD ;)\r", "byte", "buf", "[", "]", "=", "new", "byte", "[", "8192", "]", ";", "int", "len", ";", "while", "(", "(", "len", "=", "is", ".", "read", "(", "buf", ")", ")", ">", "0", ")", "{", "os", ".", "write", "(", "buf", ",", "0", ",", "len", ")", ";", "}", "os", ".", "flush", "(", ")", ";", "InputStream", "lock", "=", "new", "FileInputStream", "(", "tempfile", ")", ";", "os", ".", "close", "(", ")", ";", "double", "seconds", "=", "(", "double", ")", "(", "System", ".", "currentTimeMillis", "(", ")", "-", "savedTime", ")", "/", "1e3", ";", "logger", ".", "debug", "(", "\"Copying took \"", "+", "seconds", "+", "\" seconds.\"", ")", ";", "logger", ".", "debug", "(", "\"Loading library from \"", "+", "tempfile", ".", "getPath", "(", ")", "+", "\".\"", ")", ";", "System", ".", "load", "(", "tempfile", ".", "getPath", "(", ")", ")", ";", "lock", ".", "close", "(", ")", ";", "}", "catch", "(", "IOException", "io", ")", "{", "logger", ".", "error", "(", "\"Could not create the temp file: \"", "+", "io", ".", "toString", "(", ")", "+", "\".\\n\"", ")", ";", "}", "catch", "(", "UnsatisfiedLinkError", "ule", ")", "{", "logger", ".", "error", "(", "\"Couldn't load copied link file: \"", "+", "ule", ".", "toString", "(", ")", "+", "\".\\n\"", ")", ";", "throw", "ule", ";", "}", "}" ]

[ "Load", "a", "system", "library", "from", "a", "stream", ".", "Copies", "the", "library", "to", "a", "temp", "file", "and", "loads", "from", "there", "." ]

[ "public", "Observable", "<", "NetworkInterfaceTapConfigurationInner", ">", "createOrUpdateAsync", "(", "String", "resourceGroupName", ",", "String", "networkInterfaceName", ",", "String", "tapConfigurationName", ",", "NetworkInterfaceTapConfigurationInner", "tapConfigurationParameters", ")", "{", "return", "createOrUpdateWithServiceResponseAsync", "(", "resourceGroupName", ",", "networkInterfaceName", ",", "tapConfigurationName", ",", "tapConfigurationParameters", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "NetworkInterfaceTapConfigurationInner", ">", ",", "NetworkInterfaceTapConfigurationInner", ">", "(", ")", "{", "@", "Override", "public", "NetworkInterfaceTapConfigurationInner", "call", "(", "ServiceResponse", "<", "NetworkInterfaceTapConfigurationInner", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Creates", "or", "updates", "a", "Tap", "configuration", "in", "the", "specified", "NetworkInterface", "." ]

[ "public", "void", "initXPath", "(", "Compiler", "compiler", ",", "String", "expression", ",", "PrefixResolver", "namespaceContext", ")", "throws", "javax", ".", "xml", ".", "transform", ".", "TransformerException", "{", "m_ops", "=", "compiler", ";", "m_namespaceContext", "=", "namespaceContext", ";", "m_functionTable", "=", "compiler", ".", "getFunctionTable", "(", ")", ";", "Lexer", "lexer", "=", "new", "Lexer", "(", "compiler", ",", "namespaceContext", ",", "this", ")", ";", "lexer", ".", "tokenize", "(", "expression", ")", ";", "m_ops", ".", "setOp", "(", "0", ",", "OpCodes", ".", "OP_XPATH", ")", ";", "m_ops", ".", "setOp", "(", "OpMap", ".", "MAPINDEX_LENGTH", ",", "2", ")", ";", "// Patch for Christine's gripe. She wants her errorHandler to return from", "// a fatal error and continue trying to parse, rather than throwing an exception.", "// Without the patch, that put us into an endless loop.", "//", "// %REVIEW% Is there a better way of doing this?", "// %REVIEW% Are there any other cases which need the safety net?", "// \t(and if so do we care right now, or should we rewrite the XPath", "//\tgrammar engine and can fix it at that time?)", "try", "{", "nextToken", "(", ")", ";", "Expr", "(", ")", ";", "if", "(", "null", "!=", "m_token", ")", "{", "String", "extraTokens", "=", "\"\"", ";", "while", "(", "null", "!=", "m_token", ")", "{", "extraTokens", "+=", "\"'\"", "+", "m_token", "+", "\"'\"", ";", "nextToken", "(", ")", ";", "if", "(", "null", "!=", "m_token", ")", "extraTokens", "+=", "\", \"", ";", "}", "error", "(", "XPATHErrorResources", ".", "ER_EXTRA_ILLEGAL_TOKENS", ",", "new", "Object", "[", "]", "{", "extraTokens", "}", ")", ";", "//\"Extra illegal tokens: \"+extraTokens);", "}", "}", "catch", "(", "org", ".", "apache", ".", "xpath", ".", "XPathProcessorException", "e", ")", "{", "if", "(", "CONTINUE_AFTER_FATAL_ERROR", ".", "equals", "(", "e", ".", "getMessage", "(", ")", ")", ")", "{", "// What I _want_ to do is null out this XPath.", "// I doubt this has the desired effect, but I'm not sure what else to do.", "// %REVIEW%!!!", "initXPath", "(", "compiler", ",", "\"/..\"", ",", "namespaceContext", ")", ";", "}", "else", "throw", "e", ";", "}", "compiler", ".", "shrink", "(", ")", ";", "}" ]

[ "Given", "an", "string", "init", "an", "XPath", "object", "for", "selections", "in", "order", "that", "a", "parse", "doesn", "t", "have", "to", "be", "done", "each", "time", "the", "expression", "is", "evaluated", "." ]

[ "public", "OrganizationModel", "attachLink", "(", "OrganizationModel", "organizationModel", ",", "LinkModel", "linkModel", ")", "{", "// check for duplicates", "for", "(", "LinkModel", "existing", ":", "organizationModel", ".", "getLinks", "(", ")", ")", "{", "if", "(", "existing", ".", "equals", "(", "linkModel", ")", ")", "{", "return", "organizationModel", ";", "}", "}", "organizationModel", ".", "addLink", "(", "linkModel", ")", ";", "return", "organizationModel", ";", "}" ]

[ "This", "method", "just", "attaches", "the", "{" ]

[ "public", "static", "String", "eachMatch", "(", "String", "self", ",", "String", "regex", ",", "@", "ClosureParams", "(", "value", "=", "FromString", ".", "class", ",", "options", "=", "{", "\"List<String>\"", ",", "\"String[]\"", "}", ")", "Closure", "closure", ")", "{", "return", "eachMatch", "(", "self", ",", "Pattern", ".", "compile", "(", "regex", ")", ",", "closure", ")", ";", "}" ]

[ "Process", "each", "regex", "group", "matched", "substring", "of", "the", "given", "string", ".", "If", "the", "closure", "parameter", "takes", "one", "argument", "an", "array", "with", "all", "match", "groups", "is", "passed", "to", "it", ".", "If", "the", "closure", "takes", "as", "many", "arguments", "as", "there", "are", "match", "groups", "then", "each", "parameter", "will", "be", "one", "match", "group", "." ]

[ "private", "BufferedImage", "create_POI_Image", "(", "final", "int", "WIDTH", ")", "{", "if", "(", "WIDTH", "<=", "0", ")", "{", "return", "null", ";", "}", "final", "java", ".", "awt", ".", "image", ".", "BufferedImage", "IMAGE", "=", "UTIL", ".", "createImage", "(", "WIDTH", ",", "WIDTH", ",", "java", ".", "awt", ".", "Transparency", ".", "TRANSLUCENT", ")", ";", "final", "java", ".", "awt", ".", "Graphics2D", "G2", "=", "IMAGE", ".", "createGraphics", "(", ")", ";", "G2", ".", "setRenderingHint", "(", "java", ".", "awt", ".", "RenderingHints", ".", "KEY_ANTIALIASING", ",", "java", ".", "awt", ".", "RenderingHints", ".", "VALUE_ANTIALIAS_ON", ")", ";", "//G2.setRenderingHint(java.awt.RenderingHints.KEY_RENDERING, java.awt.RenderingHints.VALUE_RENDER_QUALITY);", "//G2.setRenderingHint(java.awt.RenderingHints.KEY_DITHERING, java.awt.RenderingHints.VALUE_DITHER_ENABLE);", "//G2.setRenderingHint(java.awt.RenderingHints.KEY_ALPHA_INTERPOLATION, java.awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);", "//G2.setRenderingHint(java.awt.RenderingHints.KEY_COLOR_RENDERING, java.awt.RenderingHints.VALUE_COLOR_RENDER_QUALITY);", "G2", ".", "setRenderingHint", "(", "java", ".", "awt", ".", "RenderingHints", ".", "KEY_STROKE_CONTROL", ",", "java", ".", "awt", ".", "RenderingHints", ".", "VALUE_STROKE_NORMALIZE", ")", ";", "//G2.setRenderingHint(java.awt.RenderingHints.KEY_TEXT_ANTIALIASING, java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_ON);", "final", "java", ".", "awt", ".", "geom", ".", "Ellipse2D", "BLIP", "=", "new", "java", ".", "awt", ".", "geom", ".", "Ellipse2D", ".", "Double", "(", "0", ",", "0", ",", "WIDTH", ",", "WIDTH", ")", ";", "final", "java", ".", "awt", ".", "geom", ".", "Point2D", "CENTER", "=", "new", "java", ".", "awt", ".", "geom", ".", "Point2D", ".", "Double", "(", "BLIP", ".", "getCenterX", "(", ")", ",", "BLIP", ".", "getCenterY", "(", ")", ")", ";", "final", "float", "[", "]", "FRACTIONS", "=", "{", "0.0f", ",", "1.0f", "}", ";", "final", "Color", "[", "]", "COLORS", "=", "{", "new", "Color", "(", "1.0f", ",", "1.0f", ",", "1.0f", ",", "0.9f", ")", ",", "new", "Color", "(", "1.0f", ",", "1.0f", ",", "1.0f", ",", "0.0f", ")", "}", ";", "final", "java", ".", "awt", ".", "RadialGradientPaint", "GRADIENT", "=", "new", "java", ".", "awt", ".", "RadialGradientPaint", "(", "CENTER", ",", "(", "int", ")", "(", "WIDTH", "/", "2.0", ")", ",", "FRACTIONS", ",", "COLORS", ")", ";", "G2", ".", "setPaint", "(", "GRADIENT", ")", ";", "G2", ".", "fill", "(", "BLIP", ")", ";", "G2", ".", "dispose", "(", ")", ";", "return", "IMAGE", ";", "}" ]

[ "Creates", "the", "image", "of", "the", "poi" ]

[ "public", "DateTimeFormatter", "withResolverStyle", "(", "ResolverStyle", "resolverStyle", ")", "{", "Jdk8Methods", ".", "requireNonNull", "(", "resolverStyle", ",", "\"resolverStyle\"", ")", ";", "if", "(", "Jdk8Methods", ".", "equals", "(", "this", ".", "resolverStyle", ",", "resolverStyle", ")", ")", "{", "return", "this", ";", "}", "return", "new", "DateTimeFormatter", "(", "printerParser", ",", "locale", ",", "decimalStyle", ",", "resolverStyle", ",", "resolverFields", ",", "chrono", ",", "zone", ")", ";", "}" ]

[ "Returns", "a", "copy", "of", "this", "formatter", "with", "a", "new", "resolver", "style", ".", "<p", ">", "This", "returns", "a", "formatter", "with", "similar", "state", "to", "this", "formatter", "but", "with", "the", "resolver", "style", "set", ".", "By", "default", "a", "formatter", "has", "the", "{", "@link", "ResolverStyle#SMART", "SMART", "}", "resolver", "style", ".", "<p", ">", "Changing", "the", "resolver", "style", "only", "has", "an", "effect", "during", "parsing", ".", "Parsing", "a", "text", "string", "occurs", "in", "two", "phases", ".", "Phase", "1", "is", "a", "basic", "text", "parse", "according", "to", "the", "fields", "added", "to", "the", "builder", ".", "Phase", "2", "resolves", "the", "parsed", "field", "-", "value", "pairs", "into", "date", "and", "/", "or", "time", "objects", ".", "The", "resolver", "style", "is", "used", "to", "control", "how", "phase", "2", "resolving", "happens", ".", "See", "{", "@code", "ResolverStyle", "}", "for", "more", "information", "on", "the", "options", "available", ".", "<p", ">", "This", "instance", "is", "immutable", "and", "unaffected", "by", "this", "method", "call", "." ]

[ "public", "static", "boolean", "isClassAvailable", "(", "String", "pClassName", ",", "Class", "pFromClass", ")", "{", "ClassLoader", "loader", "=", "pFromClass", "!=", "null", "?", "pFromClass", ".", "getClassLoader", "(", ")", ":", "null", ";", "return", "isClassAvailable", "(", "pClassName", ",", "loader", ")", ";", "}" ]

[ "Tests", "if", "a", "named", "class", "is", "available", "from", "another", "class", ".", "If", "a", "class", "is", "considered", "available", "a", "call", "to", "{", "@code", "Class", ".", "forName", "(", "pClassName", "true", "pFromClass", ".", "getClassLoader", "()", ")", "}", "will", "not", "result", "in", "an", "exception", "." ]

[ "public", "void", "loadProperties", "(", "File", "contentDir", ")", "{", "String", "resourceFile", "=", "null", ";", "if", "(", "contentDir", ".", "exists", "(", ")", "&&", "contentDir", ".", "isDirectory", "(", ")", ")", "{", "File", "propFile", "=", "new", "File", "(", "contentDir", ",", "REALM_FILE_NAME", ")", ";", "if", "(", "propFile", ".", "exists", "(", ")", "&&", "propFile", ".", "canRead", "(", ")", ")", "{", "resourceFile", "=", "propFile", ".", "getAbsoluteFile", "(", ")", ".", "getAbsolutePath", "(", ")", ";", "}", "}", "else", "if", "(", "contentDir", ".", "exists", "(", ")", "&&", "contentDir", ".", "isFile", "(", ")", "&&", "contentDir", ".", "canRead", "(", ")", ")", "{", "resourceFile", "=", "contentDir", ".", "getAbsoluteFile", "(", ")", ".", "getAbsolutePath", "(", ")", ";", "}", "if", "(", "StringUtils", ".", "isNotBlank", "(", "resourceFile", ")", ")", "{", "this", ".", "setResourcePath", "(", "\"file:\"", "+", "resourceFile", ")", ";", "this", ".", "destroy", "(", ")", ";", "this", ".", "init", "(", ")", ";", "}", "}" ]

[ "loads", "a", "properties", "file", "named", "{" ]

[ "private", "void", "addPrincipalPermissionsToForm", "(", "IPortletDefinition", "def", ",", "PortletDefinitionForm", "form", ")", "{", "final", "String", "portletTargetId", "=", "PermissionHelper", ".", "permissionTargetIdForPortletDefinition", "(", "def", ")", ";", "final", "Set", "<", "JsonEntityBean", ">", "principalBeans", "=", "new", "HashSet", "<>", "(", ")", ";", "Map", "<", "String", ",", "IPermissionManager", ">", "permManagers", "=", "new", "HashMap", "<>", "(", ")", ";", "for", "(", "PortletPermissionsOnForm", "perm", ":", "PortletPermissionsOnForm", ".", "values", "(", ")", ")", "{", "if", "(", "!", "permManagers", ".", "containsKey", "(", "perm", ".", "getOwner", "(", ")", ")", ")", "{", "permManagers", ".", "put", "(", "perm", ".", "getOwner", "(", ")", ",", "authorizationService", ".", "newPermissionManager", "(", "perm", ".", "getOwner", "(", ")", ")", ")", ";", "}", "final", "IPermissionManager", "pm", "=", "permManagers", ".", "get", "(", "perm", ".", "getOwner", "(", ")", ")", ";", "/* Obtain the principals that have permission for the activity on this portlet */", "final", "IAuthorizationPrincipal", "[", "]", "principals", "=", "pm", ".", "getAuthorizedPrincipals", "(", "perm", ".", "getActivity", "(", ")", ",", "portletTargetId", ")", ";", "for", "(", "IAuthorizationPrincipal", "principal", ":", "principals", ")", "{", "JsonEntityBean", "principalBean", ";", "// first assume this is a group", "final", "IEntityGroup", "group", "=", "GroupService", ".", "findGroup", "(", "principal", ".", "getKey", "(", ")", ")", ";", "if", "(", "group", "!=", "null", ")", "{", "// principal is a group", "principalBean", "=", "new", "JsonEntityBean", "(", "group", ",", "EntityEnum", ".", "GROUP", ")", ";", "}", "else", "{", "// not a group, so it must be a person", "final", "IGroupMember", "member", "=", "authorizationService", ".", "getGroupMember", "(", "principal", ")", ";", "principalBean", "=", "new", "JsonEntityBean", "(", "member", ",", "EntityEnum", ".", "PERSON", ")", ";", "// set the name", "final", "String", "name", "=", "groupListHelper", ".", "lookupEntityName", "(", "principalBean", ")", ";", "principalBean", ".", "setName", "(", "name", ")", ";", "}", "principalBeans", ".", "add", "(", "principalBean", ")", ";", "form", ".", "addPermission", "(", "principalBean", ".", "getTypeAndIdHash", "(", ")", "+", "\"_\"", "+", "perm", ".", "getActivity", "(", ")", ")", ";", "}", "}", "form", ".", "setPrincipals", "(", "principalBeans", ",", "false", ")", ";", "}" ]

[ "/", "*", "Add", "to", "the", "form", "SUBSCRIBE", "BROWSE", "and", "CONFIGURE", "activity", "permissions", "along", "with", "their", "principals", "assigned", "to", "the", "portlet", "." ]

[ "protected", "void", "onSourceErrorOccurred", "(", "TransformerSourceErrorEvent", "event", ")", "{", "for", "(", "TransformerSourceEventListener", "listener", ":", "transformerSourceEventListeners", ")", "fireErrorEvent", "(", "listener", ",", "event", ")", ";", "}", "/**\n * Fires the given event on the given listener.\n * @param listener The listener to fire the event to.\n * @param event The event to fire.\n */", "private", "void", "fireErrorEvent", "(", "TransformerSourceEventListener", "listener", ",", "TransformerSourceErrorEvent", "event", ")", "{", "try", "{", "listener", ".", "ErrorOccurred", "(", "event", ")", ";", "}", "catch", "(", "RuntimeException", "e", ")", "{", "// Log this somehow", "System", ".", "err", ".", "println", "(", "\"Exception thrown while trying to invoke event listener, removing bed behaved listener.\"", ")", ";", "e", ".", "printStackTrace", "(", ")", ";", "removeTransformerSourceEventListener", "(", "listener", ")", ";", "}", "}", "}" ]

[ "(", "Re", ")", "-", "fires", "a", "preconstructed", "event", "." ]

[ "@", "Override", "public", "OUTPUT", "newInstance", "(", "INPUT", "input", ",", "INPUT", "...", "inputs", ")", "throws", "FAILURE", "{", "StringBuilder", "builder", "=", "new", "StringBuilder", "(", ")", ".", "append", "(", "getClass", "(", ")", ".", "getName", "(", ")", ")", ".", "append", "(", "\".newInstance(Input, Input...) is unsupported.\"", ")", ";", "throw", "new", "UnsupportedOperationException", "(", "builder", ".", "toString", "(", ")", ")", ";", "}" ]

[ "<p", ">", "<b", ">", "Unsupported<", "/", "b", ">", ".", "Override", "to", "provide", "an", "implementation", ".", "<", "/", "p", ">" ]

[ "public", "final", "String", "getDisplayName", "(", "boolean", "daylight", ",", "int", "style", ")", "{", "return", "getDisplayName", "(", "daylight", ",", "style", ",", "Locale", ".", "getDefault", "(", "Locale", ".", "Category", ".", "DISPLAY", ")", ")", ";", "}" ]

[ "Returns", "a", "name", "in", "the", "specified", "{", "@code", "style", "}", "of", "this", "{", "@code", "TimeZone", "}", "suitable", "for", "presentation", "to", "the", "user", "in", "the", "default", "locale", ".", "If", "the", "specified", "{", "@code", "daylight", "}", "is", "{", "@code", "true", "}", "a", "Daylight", "Saving", "Time", "name", "is", "returned", "(", "even", "if", "this", "{", "@code", "TimeZone", "}", "doesn", "t", "observe", "Daylight", "Saving", "Time", ")", ".", "Otherwise", "a", "Standard", "Time", "name", "is", "returned", "." ]

[ "public", "void", "setDocumentExpiration", "(", "@", "NonNull", "String", "id", ",", "Date", "expiration", ")", "throws", "CouchbaseLiteException", "{", "if", "(", "id", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"document id cannot be null.\"", ")", ";", "}", "synchronized", "(", "lock", ")", "{", "try", "{", "if", "(", "expiration", "==", "null", ")", "{", "getC4Database", "(", ")", ".", "setExpiration", "(", "id", ",", "0", ")", ";", "}", "else", "{", "getC4Database", "(", ")", ".", "setExpiration", "(", "id", ",", "expiration", ".", "getTime", "(", ")", ")", ";", "}", "scheduleDocumentExpiration", "(", "0", ")", ";", "}", "catch", "(", "LiteCoreException", "e", ")", "{", "throw", "CBLStatus", ".", "convertException", "(", "e", ")", ";", "}", "}", "}" ]

[ "Sets", "an", "expiration", "date", "on", "a", "document", ".", "After", "this", "time", "the", "document", "will", "be", "purged", "from", "the", "database", "." ]

[ "public", "Blueprint", "fromDir", "(", "String", "programId", ",", "String", "description", ",", "File", "rootDir", ",", "File", "icon", ")", "{", "return", "new", "Blueprint", "(", "programId", ",", "description", ",", "processDir", "(", "rootDir", ")", ",", "processBlob", "(", "icon", ")", ")", ";", "}" ]

[ "Erstellt", "einen", "Blueprint", "aus", "dem", "übergebenen", "RootDir", ".", "Blobs", "und", "Directorys", "werden", "sofort", "im", "übergebenen", "Repository", "gespeichert", ".", "Der", "Blueprint", "selbst", "wird", "<b", ">", "nicht<", "/", "b", ">", "von", "gepeichert", ".", "<br", "/", ">", "<br", "/", ">", "Alle", "Dateien", "werden", "GZIP", "komprimiert" ]

[ "private", "File", "generateJsonFromIndividualESAs", "(", "Path", "jsonDirectory", ",", "Map", "<", "String", ",", "String", ">", "shortNameMap", ")", "throws", "IOException", ",", "RepositoryException", ",", "InstallException", "{", "String", "dir", "=", "jsonDirectory", ".", "toString", "(", ")", ";", "List", "<", "File", ">", "esas", "=", "(", "List", "<", "File", ">", ")", "data", ".", "get", "(", "INDIVIDUAL_ESAS", ")", ";", "File", "singleJson", "=", "new", "File", "(", "dir", "+", "\"/SingleJson.json\"", ")", ";", "for", "(", "File", "esa", ":", "esas", ")", "{", "try", "{", "populateFeatureNameFromManifest", "(", "esa", ",", "shortNameMap", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "new", "InstallException", "(", "Messages", ".", "INSTALL_KERNEL_MESSAGES", ".", "getLogMessage", "(", "\"ERROR_ESA_NOT_FOUND\"", ",", "esa", ".", "getAbsolutePath", "(", ")", ")", ")", ";", "}", "SingleFileRepositoryConnection", "mySingleFileRepo", "=", "null", ";", "if", "(", "singleJson", ".", "exists", "(", ")", ")", "{", "mySingleFileRepo", "=", "new", "SingleFileRepositoryConnection", "(", "singleJson", ")", ";", "}", "else", "{", "try", "{", "mySingleFileRepo", "=", "SingleFileRepositoryConnection", ".", "createEmptyRepository", "(", "singleJson", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "new", "InstallException", "(", "Messages", ".", "INSTALL_KERNEL_MESSAGES", ".", "getLogMessage", "(", "\"ERROR_SINGLE_REPO_CONNECTION_FAILED\"", ",", "dir", ",", "esa", ".", "getAbsolutePath", "(", ")", ")", ")", ";", "}", "}", "Parser", "<", "?", "extends", "RepositoryResourceWritable", ">", "parser", "=", "new", "EsaParser", "(", "true", ")", ";", "RepositoryResourceWritable", "resource", "=", "parser", ".", "parseFileToResource", "(", "esa", ",", "null", ",", "null", ")", ";", "resource", ".", "updateGeneratedFields", "(", "true", ")", ";", "resource", ".", "setRepositoryConnection", "(", "mySingleFileRepo", ")", ";", "// Overload the Maven coordinates field with the file path, since the ESA should be installed from that path", "resource", ".", "setMavenCoordinates", "(", "esa", ".", "getAbsolutePath", "(", ")", ")", ";", "resource", ".", "uploadToMassive", "(", "new", "AddThenDeleteStrategy", "(", ")", ")", ";", "}", "return", "singleJson", ";", "}" ]

[ "generate", "a", "JSON", "from", "provided", "individual", "ESA", "files" ]

[ "public", "TableInput", "withParameters", "(", "java", ".", "util", ".", "Map", "<", "String", ",", "String", ">", "parameters", ")", "{", "setParameters", "(", "parameters", ")", ";", "return", "this", ";", "}" ]

[ "<p", ">", "These", "key", "-", "value", "pairs", "define", "properties", "associated", "with", "the", "table", ".", "<", "/", "p", ">" ]

[ "public", "void", "deleteCertificate", "(", "String", "thumbprintAlgorithm", ",", "String", "thumbprint", ",", "Iterable", "<", "BatchClientBehavior", ">", "additionalBehaviors", ")", "throws", "BatchErrorException", ",", "IOException", "{", "CertificateDeleteOptions", "options", "=", "new", "CertificateDeleteOptions", "(", ")", ";", "BehaviorManager", "bhMgr", "=", "new", "BehaviorManager", "(", "this", ".", "customBehaviors", "(", ")", ",", "additionalBehaviors", ")", ";", "bhMgr", ".", "applyRequestBehaviors", "(", "options", ")", ";", "this", ".", "parentBatchClient", ".", "protocolLayer", "(", ")", ".", "certificates", "(", ")", ".", "delete", "(", "thumbprintAlgorithm", ",", "thumbprint", ",", "options", ")", ";", "}" ]

[ "Deletes", "the", "certificate", "from", "the", "Batch", "account", ".", "<p", ">", "The", "delete", "operation", "requests", "that", "the", "certificate", "be", "deleted", ".", "The", "request", "puts", "the", "certificate", "in", "the", "{", "@link", "com", ".", "microsoft", ".", "azure", ".", "batch", ".", "protocol", ".", "models", ".", "CertificateState#DELETING", "Deleting", "}", "state", ".", "The", "Batch", "service", "will", "perform", "the", "actual", "certificate", "deletion", "without", "any", "further", "client", "action", ".", "<", "/", "p", ">", "<p", ">", "You", "cannot", "delete", "a", "certificate", "if", "a", "resource", "(", "pool", "or", "compute", "node", ")", "is", "using", "it", ".", "Before", "you", "can", "delete", "a", "certificate", "you", "must", "therefore", "make", "sure", "that", ":", "<", "/", "p", ">", "<ul", ">", "<li", ">", "The", "certificate", "is", "not", "associated", "with", "any", "pools", ".", "<", "/", "li", ">", "<li", ">", "The", "certificate", "is", "not", "installed", "on", "any", "compute", "nodes", ".", "(", "Even", "if", "you", "remove", "a", "certificate", "from", "a", "pool", "it", "is", "not", "removed", "from", "existing", "compute", "nodes", "in", "that", "pool", "until", "they", "restart", ".", ")", "<", "/", "li", ">", "<", "/", "ul", ">", "<p", ">", "If", "you", "try", "to", "delete", "a", "certificate", "that", "is", "in", "use", "the", "deletion", "fails", ".", "The", "certificate", "state", "changes", "to", "{", "@link", "com", ".", "microsoft", ".", "azure", ".", "batch", ".", "protocol", ".", "models", ".", "CertificateState#DELETE_FAILED", "Delete", "Failed", "}", "." ]

[ "public", "GitlabProjectMember", "addProjectMember", "(", "Integer", "projectId", ",", "Integer", "userId", ",", "GitlabAccessLevel", "accessLevel", ")", "throws", "IOException", "{", "Query", "query", "=", "new", "Query", "(", ")", ".", "appendIf", "(", "\"id\"", ",", "projectId", ")", ".", "appendIf", "(", "\"user_id\"", ",", "userId", ")", ".", "appendIf", "(", "\"access_level\"", ",", "accessLevel", ")", ";", "String", "tailUrl", "=", "GitlabProject", ".", "URL", "+", "\"/\"", "+", "projectId", "+", "GitlabProjectMember", ".", "URL", "+", "query", ".", "toString", "(", ")", ";", "return", "dispatch", "(", ")", ".", "to", "(", "tailUrl", ",", "GitlabProjectMember", ".", "class", ")", ";", "}" ]

[ "Add", "a", "project", "member", "." ]

[ "final", "int", "writeToPreallocated", "(", "StorageChannelOutput", "out", ",", "Map", "<", "AbstractIndexPage", ",", "Integer", ">", "map", ")", "{", "return", "getRoot", "(", ")", ".", "writeToPreallocated", "(", "out", ",", "map", ")", ";", "}" ]

[ "Special", "write", "method", "that", "uses", "only", "pre", "-", "allocated", "pages", "." ]

[ "protected", "void", "updateSolution", "(", "double", "[", "]", "[", "]", "sol", ",", "double", "[", "]", "meta", ",", "int", "it", ")", "{", "final", "double", "mom", "=", "(", "it", "<", "momentumSwitch", "&&", "initialMomentum", "<", "finalMomentum", ")", "?", "initialMomentum", ":", "finalMomentum", ";", "final", "int", "dim3", "=", "dim", "*", "3", ";", "for", "(", "int", "i", "=", "0", ",", "off", "=", "0", ";", "i", "<", "sol", ".", "length", ";", "i", "++", ",", "off", "+=", "dim3", ")", "{", "final", "double", "[", "]", "sol_i", "=", "sol", "[", "i", "]", ";", "for", "(", "int", "k", "=", "0", ";", "k", "<", "dim", ";", "k", "++", ")", "{", "// Indexes in meta array", "final", "int", "gradk", "=", "off", "+", "k", ",", "movk", "=", "gradk", "+", "dim", ",", "gaink", "=", "movk", "+", "dim", ";", "// Adjust learning rate:", "meta", "[", "gaink", "]", "=", "MathUtil", ".", "max", "(", "(", "(", "meta", "[", "gradk", "]", ">", "0", ")", "!=", "(", "meta", "[", "movk", "]", ">", "0", ")", ")", "?", "(", "meta", "[", "gaink", "]", "+", "0.2", ")", ":", "(", "meta", "[", "gaink", "]", "*", "0.8", ")", ",", "MIN_GAIN", ")", ";", "meta", "[", "movk", "]", "*=", "mom", ";", "// Dampening the previous momentum", "meta", "[", "movk", "]", "-=", "learningRate", "*", "meta", "[", "gradk", "]", "*", "meta", "[", "gaink", "]", ";", "// Learn", "sol_i", "[", "k", "]", "+=", "meta", "[", "movk", "]", ";", "}", "}", "}" ]

[ "Update", "the", "current", "solution", "on", "iteration", "." ]

[ "public", "LocalQueueStats", "createLocalQueueStats", "(", "String", "name", ",", "int", "partitionId", ")", "{", "LocalQueueStatsImpl", "stats", "=", "getLocalQueueStatsImpl", "(", "name", ")", ";", "stats", ".", "setOwnedItemCount", "(", "0", ")", ";", "stats", ".", "setBackupItemCount", "(", "0", ")", ";", "QueueContainer", "container", "=", "containerMap", ".", "get", "(", "name", ")", ";", "if", "(", "container", "==", "null", ")", "{", "return", "stats", ";", "}", "Address", "thisAddress", "=", "nodeEngine", ".", "getClusterService", "(", ")", ".", "getThisAddress", "(", ")", ";", "IPartition", "partition", "=", "partitionService", ".", "getPartition", "(", "partitionId", ",", "false", ")", ";", "Address", "owner", "=", "partition", ".", "getOwnerOrNull", "(", ")", ";", "if", "(", "thisAddress", ".", "equals", "(", "owner", ")", ")", "{", "stats", ".", "setOwnedItemCount", "(", "container", ".", "size", "(", ")", ")", ";", "}", "else", "if", "(", "owner", "!=", "null", ")", "{", "stats", ".", "setBackupItemCount", "(", "container", ".", "backupSize", "(", ")", ")", ";", "}", "container", ".", "setStats", "(", "stats", ")", ";", "return", "stats", ";", "}" ]

[ "Returns", "the", "local", "queue", "statistics", "for", "the", "given", "name", "and", "partition", "ID", ".", "If", "this", "node", "is", "the", "owner", "for", "the", "partition", "returned", "stats", "contain", "{", "@link", "LocalQueueStats#getOwnedItemCount", "()", "}", "otherwise", "it", "contains", "{", "@link", "LocalQueueStats#getBackupItemCount", "()", "}", "." ]

[ "public", "static", "String", "getWorkerDataDirectory", "(", "String", "storageDir", ",", "AlluxioConfiguration", "conf", ")", "{", "return", "PathUtils", ".", "concatPath", "(", "storageDir", ".", "trim", "(", ")", ",", "conf", ".", "get", "(", "PropertyKey", ".", "WORKER_DATA_FOLDER", ")", ")", ";", "}" ]

[ "@param", "storageDir", "the", "root", "of", "a", "storage", "directory", "in", "tiered", "storage", "@param", "conf", "Alluxio", "s", "current", "configuration" ]

[ "private", "static", "boolean", "compareByteValues", "(", "byte", "[", "]", "network", ",", "byte", "[", "]", "subnet", ",", "byte", "[", "]", "ipAddress", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "network", ".", "length", ";", "i", "++", ")", "if", "(", "(", "network", "[", "i", "]", "&", "subnet", "[", "i", "]", ")", "!=", "(", "ipAddress", "[", "i", "]", "&", "subnet", "[", "i", "]", ")", ")", "return", "false", ";", "return", "true", ";", "}" ]

[ "Checks", "whether", "ipAddress", "is", "in", "network", "with", "specified", "subnet", "by", "comparing", "byte", "logical", "end", "values" ]

[ "public", "void", "setColorGradient", "(", "ColorRgba", "color1", ",", "ColorRgba", "color2", ")", "{", "setColorGradient", "(", "x", ",", "y", ",", "color1", ",", "x", "+", "maxWidth", ",", "y", "+", "maxHeight", ",", "color2", ")", ";", "}" ]

[ "Set", "a", "gradient", "color", "from", "point", "1", "with", "color", "1", "to", "point2", "with", "color", "2", "." ]

[ "public", "TagAttribute", "get", "(", "String", "ns", ",", "String", "localName", ")", "{", "if", "(", "ns", "!=", "null", "&&", "localName", "!=", "null", ")", "{", "int", "idx", "=", "Arrays", ".", "binarySearch", "(", "_namespaces", ",", "ns", ")", ";", "if", "(", "idx", ">=", "0", ")", "{", "for", "(", "TagAttribute", "attribute", ":", "_nsattrs", ".", "get", "(", "idx", ")", ")", "{", "if", "(", "localName", ".", "equals", "(", "attribute", ".", "getLocalName", "(", ")", ")", ")", "{", "return", "attribute", ";", "}", "}", "}", "}", "return", "null", ";", "}" ]

[ "Find", "a", "TagAttribute", "that", "matches", "the", "passed", "namespace", "and", "local", "name", "." ]

[ "public", "void", "setNewFilterTree", "(", "BaseMessageFilter", "messageFilter", ",", "Object", "[", "]", "[", "]", "propKeys", ")", "{", "if", "(", "propKeys", "!=", "null", ")", "if", "(", "!", "propKeys", ".", "equals", "(", "messageFilter", ".", "getNameValueTree", "(", ")", ")", ")", "{", "// This moves the filter to the new leaf", "this", ".", "getRegistry", "(", ")", ".", "removeMessageFilter", "(", "messageFilter", ")", ";", "super", ".", "setNewFilterTree", "(", "messageFilter", ",", "propKeys", ")", ";", "this", ".", "getRegistry", "(", ")", ".", "addMessageFilter", "(", "messageFilter", ")", ";", "}", "}" ]

[ "Update", "this", "filter", "with", "this", "new", "information", "." ]

[ "protected", "void", "showSummary", "(", "MavenProject", "mp", ",", "Dependency", "[", "]", "dependencies", ")", "{", "if", "(", "showSummary", ")", "{", "DependencyCheckScanAgent", ".", "showSummary", "(", "mp", ".", "getName", "(", ")", ",", "dependencies", ")", ";", "}", "}" ]

[ "Generates", "a", "warning", "message", "listing", "a", "summary", "of", "dependencies", "and", "their", "associated", "CPE", "and", "CVE", "entries", "." ]

[ "public", "void", "resizeTempBlockMeta", "(", "TempBlockMeta", "tempBlockMeta", ",", "long", "newSize", ")", "throws", "InvalidWorkerStateException", "{", "StorageDir", "dir", "=", "tempBlockMeta", ".", "getParentDir", "(", ")", ";", "dir", ".", "resizeTempBlockMeta", "(", "tempBlockMeta", ",", "newSize", ")", ";", "}" ]

[ "Modifies", "the", "size", "of", "a", "temp", "block", "." ]

[ "public", "static", "Path", "validateAndNormalizeUri", "(", "URI", "archiveDirUri", ")", "{", "final", "String", "scheme", "=", "archiveDirUri", ".", "getScheme", "(", ")", ";", "final", "String", "path", "=", "archiveDirUri", ".", "getPath", "(", ")", ";", "// some validity checks", "if", "(", "scheme", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"The scheme (hdfs://, file://, etc) is null. \"", "+", "\"Please specify the file system scheme explicitly in the URI.\"", ")", ";", "}", "if", "(", "path", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"The path to store the job archive data in is null. \"", "+", "\"Please specify a directory path for the archiving the job data.\"", ")", ";", "}", "return", "new", "Path", "(", "archiveDirUri", ")", ";", "}" ]

[ "Checks", "and", "normalizes", "the", "given", "URI", ".", "This", "method", "first", "checks", "the", "validity", "of", "the", "URI", "(", "scheme", "and", "path", "are", "not", "null", ")", "and", "then", "normalizes", "the", "URI", "to", "a", "path", "." ]

[ "public", "static", "int", "floor", "(", "int", "n", ",", "int", "m", ")", "{", "return", "n", ">=", "0", "?", "(", "n", "/", "m", ")", "*", "m", ":", "(", "(", "n", "-", "m", "+", "1", ")", "/", "m", ")", "*", "m", ";", "}" ]

[ "Rounds", "n", "down", "to", "the", "nearest", "multiple", "of", "m" ]

[ "<", "K", ",", "V", ">", "ConnectionFuture", "<", "StatefulRedisConnection", "<", "K", ",", "V", ">", ">", "connectToNodeAsync", "(", "RedisCodec", "<", "K", ",", "V", ">", "codec", ",", "String", "nodeId", ",", "RedisChannelWriter", "clusterWriter", ",", "Mono", "<", "SocketAddress", ">", "socketAddressSupplier", ")", "{", "assertNotNull", "(", "codec", ")", ";", "assertNotEmpty", "(", "initialUris", ")", ";", "LettuceAssert", ".", "notNull", "(", "socketAddressSupplier", ",", "\"SocketAddressSupplier must not be null\"", ")", ";", "ClusterNodeEndpoint", "endpoint", "=", "new", "ClusterNodeEndpoint", "(", "clientOptions", ",", "getResources", "(", ")", ",", "clusterWriter", ")", ";", "RedisChannelWriter", "writer", "=", "endpoint", ";", "if", "(", "CommandExpiryWriter", ".", "isSupported", "(", "clientOptions", ")", ")", "{", "writer", "=", "new", "CommandExpiryWriter", "(", "writer", ",", "clientOptions", ",", "clientResources", ")", ";", "}", "StatefulRedisConnectionImpl", "<", "K", ",", "V", ">", "connection", "=", "new", "StatefulRedisConnectionImpl", "<", "K", ",", "V", ">", "(", "writer", ",", "codec", ",", "timeout", ")", ";", "ConnectionFuture", "<", "StatefulRedisConnection", "<", "K", ",", "V", ">", ">", "connectionFuture", "=", "connectStatefulAsync", "(", "connection", ",", "codec", ",", "endpoint", ",", "getFirstUri", "(", ")", ",", "socketAddressSupplier", ",", "(", ")", "->", "new", "CommandHandler", "(", "clientOptions", ",", "clientResources", ",", "endpoint", ")", ")", ";", "return", "connectionFuture", ".", "whenComplete", "(", "(", "conn", ",", "throwable", ")", "->", "{", "if", "(", "throwable", "!=", "null", ")", "{", "connection", ".", "close", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Create", "a", "connection", "to", "a", "redis", "socket", "address", "." ]

[ "public", "Observable", "<", "LabInner", ">", "createOrUpdateAsync", "(", "String", "resourceGroupName", ",", "String", "labAccountName", ",", "String", "labName", ",", "LabInner", "lab", ")", "{", "return", "createOrUpdateWithServiceResponseAsync", "(", "resourceGroupName", ",", "labAccountName", ",", "labName", ",", "lab", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "LabInner", ">", ",", "LabInner", ">", "(", ")", "{", "@", "Override", "public", "LabInner", "call", "(", "ServiceResponse", "<", "LabInner", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Create", "or", "replace", "an", "existing", "Lab", "." ]

[ "public", "int", "bookmarkToIndex", "(", "Object", "bookmark", ",", "int", "iHandleType", ")", "{", "DataRecord", "thisBookmark", "=", "null", ";", "if", "(", "bookmark", "==", "null", ")", "return", "-", "1", ";", "for", "(", "int", "iTargetPosition", "=", "m_iCurrentRecordStart", ";", "iTargetPosition", "<", "m_iCurrentRecordEnd", ";", "iTargetPosition", "++", ")", "{", "thisBookmark", "=", "(", "DataRecord", ")", "this", ".", "elementAt", "(", "iTargetPosition", ")", ";", "if", "(", "thisBookmark", "!=", "null", ")", "if", "(", "bookmark", ".", "equals", "(", "thisBookmark", ".", "getHandle", "(", "iHandleType", ")", ")", ")", "return", "iTargetPosition", ";", "}", "//+ Still not found, do a binary search through the recordlist for a matching key", "return", "-", "1", ";", "// Not found", "}" ]

[ "This", "method", "was", "created", "by", "a", "SmartGuide", "." ]

[ "public", "static", "boolean", "isAbout", "(", "double", "expected", ",", "double", "value", ",", "double", "tolerance", ")", "{", "double", "delta", "=", "expected", "*", "tolerance", "/", "100.0", ";", "return", "value", ">", "expected", "-", "delta", "&&", "value", "<", "expected", "+", "delta", ";", "}" ]

[ "Returns", "true", "if", "value", "differs", "only", "tolerance", "percent", "." ]

[ "public", "<", "D", ">", "D", "oneToManyWithoutControl", "(", "D", "destination", ",", "final", "T", "source", ")", "{", "try", "{", "return", "this", ".", "<", "D", ",", "T", ">", "getJMapper", "(", "relationalOneToManyMapper", ",", "destination", ".", "getClass", "(", ")", ")", ".", "getDestinationWithoutControl", "(", "destination", ",", "source", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "return", "this", ".", "logAndReturnNull", "(", "e", ")", ";", "}", "}" ]

[ "This", "Method", "returns", "the", "destination", "given", "in", "input", "enriched", "with", "data", "contained", "in", "source", "given", "in", "input<br", ">", "with", "this", "setting", ":", "<table", "summary", "=", ">", "<tr", ">", "<td", ">", "<code", ">", "NullPointerControl<", "/", "code", ">", "<", "/", "td", ">", "<td", ">", "<code", ">", "NOT_ANY<", "/", "code", ">", "<", "/", "td", ">", "<", "/", "tr", ">", "<tr", ">", "<td", ">", "<code", ">", "MappingType<", "/", "code", ">", "of", "Destination<", "/", "td", ">", "<td", ">", "<code", ">", "ALL_FIELDS<", "/", "code", ">", "<", "/", "td", ">", "<", "/", "tr", ">", "<tr", ">", "<td", ">", "<code", ">", "MappingType<", "/", "code", ">", "of", "Source<", "/", "td", ">", "<td", ">", "<code", ">", "ALL_FIELDS<", "/", "code", ">", "<", "/", "td", ">", "<", "/", "tr", ">", "<", "/", "table", ">" ]

[ "public", "Observable", "<", "RecordSetInner", ">", "getAsync", "(", "String", "resourceGroupName", ",", "String", "privateZoneName", ",", "RecordType", "recordType", ",", "String", "relativeRecordSetName", ")", "{", "return", "getWithServiceResponseAsync", "(", "resourceGroupName", ",", "privateZoneName", ",", "recordType", ",", "relativeRecordSetName", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "RecordSetInner", ">", ",", "RecordSetInner", ">", "(", ")", "{", "@", "Override", "public", "RecordSetInner", "call", "(", "ServiceResponse", "<", "RecordSetInner", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Gets", "a", "record", "set", "." ]

[ "public", "RestHandlerExceptionResolverBuilder", "addErrorMessageHandler", "(", "Class", "<", "?", "extends", "Exception", ">", "exceptionClass", ",", "HttpStatus", "status", ")", "{", "return", "addHandler", "(", "new", "ErrorMessageRestExceptionHandler", "<>", "(", "exceptionClass", ",", "status", ")", ")", ";", "}" ]

[ "Registers", "{", "@link", "ErrorMessageRestExceptionHandler", "}", "for", "the", "specified", "exception", "type", ".", "This", "handler", "will", "be", "also", "used", "for", "all", "the", "exception", "subtypes", "when", "no", "more", "specific", "mapping", "is", "found", "." ]

[ "public", "void", "registerJsonBeanProcessor", "(", "Class", "target", ",", "JsonBeanProcessor", "jsonBeanProcessor", ")", "{", "if", "(", "target", "!=", "null", "&&", "jsonBeanProcessor", "!=", "null", ")", "{", "beanProcessorMap", ".", "put", "(", "target", ",", "jsonBeanProcessor", ")", ";", "}", "}" ]

[ "Registers", "a", "JsonBeanProcessor", ".", "<br", ">", "[", "Java", "-", "&gt", ";", "JSON", "]" ]

[ "public", "static", "File", "extractFileGzip", "(", "String", "_compressedFile", ",", "String", "_outputFileName", ")", "{", "return", "decompress", "(", "CompressionMethod", ".", "GZIP", ",", "_compressedFile", ",", "_outputFileName", ")", ";", "}" ]

[ "Extracts", "a", "GZIP", "compressed", "file", "to", "the", "given", "outputfile", "." ]

[ "public", "static", "String", "extractMulti", "(", "Pattern", "pattern", ",", "CharSequence", "content", ",", "String", "template", ")", "{", "if", "(", "null", "==", "content", "||", "null", "==", "pattern", "||", "null", "==", "template", ")", "{", "return", "null", ";", "}", "//提取模板中的编号\r", "final", "TreeSet", "<", "Integer", ">", "varNums", "=", "new", "TreeSet", "<>", "(", "new", "Comparator", "<", "Integer", ">", "(", ")", "{", "@", "Override", "public", "int", "compare", "(", "Integer", "o1", ",", "Integer", "o2", ")", "{", "return", "ObjectUtil", ".", "compare", "(", "o2", ",", "o1", ")", ";", "}", "}", ")", ";", "final", "Matcher", "matcherForTemplate", "=", "PatternPool", ".", "GROUP_VAR", ".", "matcher", "(", "template", ")", ";", "while", "(", "matcherForTemplate", ".", "find", "(", ")", ")", "{", "varNums", ".", "add", "(", "Integer", ".", "parseInt", "(", "matcherForTemplate", ".", "group", "(", "1", ")", ")", ")", ";", "}", "final", "Matcher", "matcher", "=", "pattern", ".", "matcher", "(", "content", ")", ";", "if", "(", "matcher", ".", "find", "(", ")", ")", "{", "for", "(", "Integer", "group", ":", "varNums", ")", "{", "template", "=", "template", ".", "replace", "(", "\"$\"", "+", "group", ",", "matcher", ".", "group", "(", "group", ")", ")", ";", "}", "return", "template", ";", "}", "return", "null", ";", "}" ]

[ "从content中匹配出多个值并根据template生成新的字符串<br", ">", "例如：<br", ">", "content", "2013年5月", "pattern", "(", ".", "*", "?", ")", "年", "(", ".", "*", "?", ")", "月", "template：", "$1", "-", "$2", "return", "2013", "-", "5" ]

[ "@", "FFDCIgnore", "(", "Throwable", ".", "class", ")", "void", "introspectMBeanAttributes", "(", "MBeanServer", "mbeanServer", ",", "ObjectName", "mbean", ",", "PrintWriter", "writer", ")", "{", "try", "{", "// Dump the description and the canonical form of the object name", "writer", ".", "println", "(", ")", ";", "writer", ".", "print", "(", "mbeanServer", ".", "getMBeanInfo", "(", "mbean", ")", ".", "getDescription", "(", ")", ")", ";", "writer", ".", "println", "(", "\" (\"", "+", "mbean", ".", "getCanonicalName", "(", ")", "+", "\")\"", ")", ";", "// Iterate over the attributes of the mbean. For each, capture the name", "// and then attempt format the attribute.", "String", "indent", "=", "INDENT", ";", "MBeanAttributeInfo", "[", "]", "attrs", "=", "mbeanServer", ".", "getMBeanInfo", "(", "mbean", ")", ".", "getAttributes", "(", ")", ";", "for", "(", "MBeanAttributeInfo", "attr", ":", "attrs", ")", "{", "StringBuilder", "sb", "=", "new", "StringBuilder", "(", ")", ";", "sb", ".", "append", "(", "indent", ")", ".", "append", "(", "attr", ".", "getName", "(", ")", ")", ".", "append", "(", "\": \"", ")", ";", "sb", ".", "append", "(", "getFormattedAttribute", "(", "mbeanServer", ",", "mbean", ",", "attr", ",", "indent", ")", ")", ";", "writer", ".", "println", "(", "sb", ".", "toString", "(", ")", ")", ";", "}", "}", "catch", "(", "Throwable", "t", ")", "{", "Throwable", "rootCause", "=", "t", ";", "while", "(", "rootCause", ".", "getCause", "(", ")", "!=", "null", ")", "{", "rootCause", "=", "rootCause", ".", "getCause", "(", ")", ";", "}", "StringBuilder", "sb", "=", "new", "StringBuilder", "(", ")", ";", "sb", ".", "append", "(", "\"<<Introspection failed: \"", ")", ";", "sb", ".", "append", "(", "rootCause", ".", "getMessage", "(", ")", "!=", "null", "?", "rootCause", ".", "getMessage", "(", ")", ":", "rootCause", ")", ";", "sb", ".", "append", "(", "\">>\"", ")", ";", "writer", ".", "println", "(", "sb", ".", "toString", "(", ")", ")", ";", "}", "}" ]

[ "Introspect", "an", "MBean", "s", "attributes", ".", "Introspection", "will", "capture", "the", "MBean", "s", "description", "its", "canonical", "object", "name", "and", "its", "attributes", ".", "When", "attributes", "are", "a", "complex", "{", "@link", "OpenType", "}", "an", "attempt", "will", "be", "made", "to", "format", "the", "complex", "type", ".", "Primitives", "and", "types", "that", "do", "not", "have", "metadata", "will", "be", "formatted", "with", "{", "@linkplain", "String#valueOf", "}", "." ]

[ "private", "static", "int", "purgeTree", "(", "final", "TSDB", "tsdb", ",", "final", "int", "tree_id", ",", "final", "boolean", "delete_definition", ")", "throws", "Exception", "{", "final", "TreeSync", "sync", "=", "new", "TreeSync", "(", "tsdb", ",", "0", ",", "1", ",", "0", ")", ";", "return", "sync", ".", "purgeTree", "(", "tree_id", ",", "delete_definition", ")", ";", "}" ]

[ "Attempts", "to", "delete", "the", "branches", "leaves", "collisions", "and", "not", "-", "matched", "entries", "for", "a", "given", "tree", ".", "Optionally", "removes", "the", "tree", "definition", "itself" ]

[ "public", "TextArea", "addTextArea", "(", "String", "tag", ",", "String", "label", ",", "int", "width", ",", "int", "height", ",", "String", "value", ")", "{", "TextArea", "ta", "=", "new", "TextArea", "(", "tag", ",", "value", ")", ";", "ta", ".", "setSize", "(", "width", ",", "height", ")", ";", "addField", "(", "label", ",", "ta", ")", ";", "return", "ta", ";", "}" ]

[ "Add", "a", "Text", "Area", "." ]

[ "public", "Observable", "<", "TopicInner", ">", "beginCreateOrUpdateAsync", "(", "String", "resourceGroupName", ",", "String", "topicName", ",", "TopicInner", "topicInfo", ")", "{", "return", "beginCreateOrUpdateWithServiceResponseAsync", "(", "resourceGroupName", ",", "topicName", ",", "topicInfo", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "TopicInner", ">", ",", "TopicInner", ">", "(", ")", "{", "@", "Override", "public", "TopicInner", "call", "(", "ServiceResponse", "<", "TopicInner", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Create", "a", "topic", ".", "Asynchronously", "creates", "a", "new", "topic", "with", "the", "specified", "parameters", "." ]

[ "public", "static", "double", "distanceFromCenter", "(", "Point", "center", ",", "double", "x", ",", "double", "y", ")", "{", "return", "Math", ".", "hypot", "(", "x", "-", "center", ".", "getX", "(", ")", ",", "y", "-", "center", ".", "getY", "(", ")", ")", ";", "}" ]

[ "Returns", "point", "(", "x", "y", ")", "distance", "from", "circles", "center", "." ]

[ "public", "static", "ParseException", "atPosition", "(", "String", "errorMessage", ",", "String", "logMessage", ",", "int", "position", ")", "{", "return", "new", "ParseException", "(", "msg", "(", "errorMessage", ",", "logMessage", ",", "position", ",", "position", "+", "1", ")", ",", "logMessage", ")", ";", "}" ]

[ "Creates", "a", "new", "parse", "exception", "for", "situations", "in", "which", "the", "position", "of", "the", "error", "is", "known", "." ]

[ "@", "GwtIncompatible", "(", "\"incompatible method\"", ")", "public", "static", "boolean", "reflectionEquals", "(", "final", "Object", "lhs", ",", "final", "Object", "rhs", ",", "final", "boolean", "testTransients", ",", "final", "Class", "<", "?", ">", "reflectUpToClass", ",", "final", "String", "...", "excludeFields", ")", "{", "return", "reflectionEquals", "(", "lhs", ",", "rhs", ",", "testTransients", ",", "reflectUpToClass", ",", "false", ",", "excludeFields", ")", ";", "}" ]

[ "<p", ">", "This", "method", "uses", "reflection", "to", "determine", "if", "the", "two", "<code", ">", "Object<", "/", "code", ">", "s", "are", "equal", ".", "<", "/", "p", ">" ]

[ "public", "double", "query", "(", "int", "targetClass", ",", "int", "targetValue", ",", "int", "[", "]", "cord", ")", "{", "double", "sumVal", "=", "0", ";", "double", "targetVal", "=", "0", ";", "int", "realTargetIndex", "=", "catIndexToRealIndex", "[", "targetClass", "]", ";", "CategoricalData", "queryData", "=", "valid", ".", "get", "(", "targetClass", ")", ";", "//Now do all other target class posibilty querys ", "for", "(", "int", "i", "=", "0", ";", "i", "<", "queryData", ".", "getNumOfCategories", "(", ")", ";", "i", "++", ")", "{", "cord", "[", "realTargetIndex", "]", "=", "i", ";", "double", "tmp", "=", "countArray", "[", "cordToIndex", "(", "cord", ")", "]", ";", "sumVal", "+=", "tmp", ";", "if", "(", "i", "==", "targetValue", ")", "targetVal", "=", "tmp", ";", "}", "return", "targetVal", "/", "sumVal", ";", "}" ]

[ "Queries", "the", "CPT", "for", "the", "probability", "of", "the", "target", "class", "occurring", "with", "the", "specified", "value", "given", "the", "class", "values", "of", "the", "other", "attributes" ]

[ "private", "static", "void", "buildMutateRowSettings", "(", "Builder", "builder", ",", "BigtableOptions", "options", ")", "{", "RetrySettings", "retrySettings", "=", "buildIdempotentRetrySettings", "(", "builder", ".", "mutateRowSettings", "(", ")", ".", "getRetrySettings", "(", ")", ",", "options", ")", ";", "builder", ".", "mutateRowSettings", "(", ")", ".", "setRetrySettings", "(", "retrySettings", ")", ".", "setRetryableCodes", "(", "buildRetryCodes", "(", "options", ".", "getRetryOptions", "(", ")", ")", ")", ";", "}" ]

[ "To", "build", "BigtableDataSettings#mutateRowSettings", "with", "default", "Retry", "settings", "." ]

[ "public", "<", "T", "extends", "R", ">", "CompletableFuture", "<", "T", ">", "getStageAsync", "(", "CheckedSupplier", "<", "?", "extends", "CompletionStage", "<", "T", ">", ">", "supplier", ")", "{", "return", "callAsync", "(", "execution", "->", "Functions", ".", "promiseOfStage", "(", "supplier", ",", "execution", ")", ",", "false", ")", ";", "}" ]

[ "Executes", "the", "{", "@code", "supplier", "}", "asynchronously", "until", "the", "resulting", "future", "is", "successfully", "completed", "or", "the", "configured", "policies", "are", "exceeded", ".", "<p", ">", "If", "a", "configured", "circuit", "breaker", "is", "open", "the", "resulting", "future", "is", "completed", "exceptionally", "with", "{", "@link", "CircuitBreakerOpenException", "}", "." ]

[ "public", "static", "HostPort", "parseHostPort", "(", "String", "string", ")", "{", "String", "[", "]", "strings", "=", "string", ".", "split", "(", "\"_\"", ")", ";", "return", "new", "HostPort", "(", "strings", "[", "0", "]", ",", "Integer", ".", "parseInt", "(", "strings", "[", "1", "]", ")", ")", ";", "}" ]

[ "Parse", "a", "host_port", "string", "to", "construct", "the", "HostPost", "object", "." ]

[ "public", "FrameworkProject", "getFrameworkProject", "(", "final", "String", "name", ")", "{", "FrameworkProject", "frameworkProject", "=", "loadChild", "(", "name", ")", ";", "if", "(", "null", "!=", "frameworkProject", ")", "{", "return", "frameworkProject", ";", "}", "throw", "new", "NoSuchResourceException", "(", "\"Project does not exist: \"", "+", "name", ",", "this", ")", ";", "}" ]

[ "@return", "an", "existing", "Project", "object", "and", "returns", "it" ]

[ "public", "boolean", "isZeroVATAllowed", "(", "@", "Nonnull", "final", "Locale", "aCountry", ",", "final", "boolean", "bUndefinedValue", ")", "{", "ValueEnforcer", ".", "notNull", "(", "aCountry", ",", "\"Country\"", ")", ";", "// first get locale specific VAT types", "final", "VATCountryData", "aVATCountryData", "=", "getVATCountryData", "(", "aCountry", ")", ";", "return", "aVATCountryData", "!=", "null", "?", "aVATCountryData", ".", "isZeroVATAllowed", "(", ")", ":", "bUndefinedValue", ";", "}" ]

[ "Check", "if", "zero", "VAT", "is", "allowed", "for", "the", "passed", "country" ]

[ "public", "BaseField", "getField", "(", "String", "strTableName", ",", "int", "iFieldSeq", ")", "// Lookup this field", "{", "Record", "record", "=", "this", ".", "getRecord", "(", "strTableName", ")", ";", "if", "(", "record", "!=", "null", ")", "return", "record", ".", "getField", "(", "iFieldSeq", ")", ";", "return", "null", ";", "// Not found", "}" ]

[ "Get", "this", "field", "in", "the", "record", ".", "This", "is", "a", "little", "different", "for", "a", "query", "record", "because", "I", "have", "to", "look", "through", "multiple", "records", "." ]

[ "public", "JsonSchemaInner", "getSchemaJson", "(", "String", "resourceGroupName", ",", "String", "workflowName", ",", "String", "triggerName", ")", "{", "return", "getSchemaJsonWithServiceResponseAsync", "(", "resourceGroupName", ",", "workflowName", ",", "triggerName", ")", ".", "toBlocking", "(", ")", ".", "single", "(", ")", ".", "body", "(", ")", ";", "}" ]

[ "Get", "the", "trigger", "schema", "as", "JSON", "." ]

[ "private", "static", "Configuration", "enableClusteringHashGroups", "(", "String", "cacheName", ",", "Configuration", "configuration", ")", "{", "if", "(", "configuration", ".", "clustering", "(", ")", ".", "hash", "(", ")", ".", "groups", "(", ")", ".", "enabled", "(", ")", ")", "{", "return", "configuration", ";", "}", "LOG", ".", "clusteringHashGroupsMustBeEnabled", "(", "cacheName", ")", ";", "ConfigurationBuilder", "builder", "=", "new", "ConfigurationBuilder", "(", ")", ".", "read", "(", "configuration", ")", ";", "builder", ".", "clustering", "(", ")", ".", "hash", "(", ")", ".", "groups", "(", ")", ".", "enabled", "(", ")", ";", "return", "builder", ".", "build", "(", ")", ";", "}" ]

[ "Enable", "the", "clustering", ".", "hash", ".", "groups", "configuration", "if", "it", "s", "not", "already", "enabled", ".", "<p", ">", "Infinispan", "requires", "this", "option", "enabled", "because", "we", "are", "using", "fine", "grained", "maps", ".", "The", "function", "will", "log", "a", "warning", "if", "the", "property", "is", "disabled", "." ]

[ "@", "SuppressWarnings", "(", "\"boxing\"", ")", "public", "static", "void", "inclusiveBetween", "(", "final", "double", "start", ",", "final", "double", "end", ",", "final", "double", "value", ")", "{", "// TODO when breaking BC, consider returning value", "if", "(", "value", "<", "start", "||", "value", ">", "end", ")", "{", "throw", "new", "IllegalArgumentException", "(", "StringUtils", ".", "simpleFormat", "(", "DEFAULT_INCLUSIVE_BETWEEN_EX_MESSAGE", ",", "value", ",", "start", ",", "end", ")", ")", ";", "}", "}" ]

[ "Validate", "that", "the", "specified", "primitive", "value", "falls", "between", "the", "two", "inclusive", "values", "specified", ";", "otherwise", "throws", "an", "exception", "." ]

[ "public", "AVQuery", "<", "T", ">", "whereMatchesKeyInQuery", "(", "String", "key", ",", "String", "keyInQuery", ",", "AVQuery", "<", "?", ">", "query", ")", "{", "Map", "<", "String", ",", "Object", ">", "inner", "=", "new", "HashMap", "<", "String", ",", "Object", ">", "(", ")", ";", "inner", ".", "put", "(", "\"className\"", ",", "query", ".", "getClassName", "(", ")", ")", ";", "inner", ".", "put", "(", "\"where\"", ",", "query", ".", "conditions", ".", "compileWhereOperationMap", "(", ")", ")", ";", "if", "(", "query", ".", "conditions", ".", "getSkip", "(", ")", ">", "0", ")", "inner", ".", "put", "(", "\"skip\"", ",", "query", ".", "conditions", ".", "getSkip", "(", ")", ")", ";", "if", "(", "query", ".", "conditions", ".", "getLimit", "(", ")", ">", "0", ")", "inner", ".", "put", "(", "\"limit\"", ",", "query", ".", "conditions", ".", "getLimit", "(", ")", ")", ";", "if", "(", "!", "StringUtil", ".", "isEmpty", "(", "query", ".", "getOrder", "(", ")", ")", ")", "inner", ".", "put", "(", "\"order\"", ",", "query", ".", "getOrder", "(", ")", ")", ";", "Map", "<", "String", ",", "Object", ">", "queryMap", "=", "new", "HashMap", "<", "String", ",", "Object", ">", "(", ")", ";", "queryMap", ".", "put", "(", "\"query\"", ",", "inner", ")", ";", "queryMap", ".", "put", "(", "\"key\"", ",", "keyInQuery", ")", ";", "return", "addWhereItem", "(", "key", ",", "\"$select\"", ",", "queryMap", ")", ";", "}" ]

[ "Add", "a", "constraint", "to", "the", "query", "that", "requires", "a", "particular", "key", "s", "value", "matches", "a", "value", "for", "a", "key", "in", "the", "results", "of", "another", "AVQuery" ]

[ "public", "static", "void", "doWithStopwatch", "(", "String", "name", ",", "Runnable", "runnable", ")", "{", "try", "(", "Split", "split", "=", "SimonManager", ".", "getStopwatch", "(", "name", ")", ".", "start", "(", ")", ")", "{", "runnable", ".", "run", "(", ")", ";", "}", "}" ]

[ "Calls", "a", "block", "of", "code", "with", "stopwatch", "around", "can", "not", "return", "any", "result", "or", "throw", "an", "exception", "(", "use", "{", "@link", "#doWithStopwatch", "(", "String", "java", ".", "util", ".", "concurrent", ".", "Callable", ")", "}", "instead", ")", "." ]

[ "public", "static", "int", "cudaMemcpyFromArray", "(", "Pointer", "dst", ",", "cudaArray", "src", ",", "long", "wOffset", ",", "long", "hOffset", ",", "long", "count", ",", "int", "cudaMemcpyKind_kind", ")", "{", "return", "checkResult", "(", "cudaMemcpyFromArrayNative", "(", "dst", ",", "src", ",", "wOffset", ",", "hOffset", ",", "count", ",", "cudaMemcpyKind_kind", ")", ")", ";", "}" ]

[ "Copies", "data", "between", "host", "and", "device", "." ]

[ "@", "Override", "public", "ForkChannel", "disconnect", "(", ")", "{", "if", "(", "state", "!=", "State", ".", "CONNECTED", ")", "return", "this", ";", "prot_stack", ".", "down", "(", "new", "Event", "(", "Event", ".", "DISCONNECT", ",", "local_addr", ")", ")", ";", "// will be discarded by ForkProtocol", "prot_stack", ".", "stopStack", "(", "cluster_name", ")", ";", "(", "(", "ForkProtocolStack", ")", "prot_stack", ")", ".", "remove", "(", "fork_channel_id", ")", ";", "nullFields", "(", ")", ";", "state", "=", "State", ".", "OPEN", ";", "notifyChannelDisconnected", "(", "this", ")", ";", "return", "this", ";", "}" ]

[ "Removes", "the", "fork", "-", "channel", "from", "the", "fork", "-", "stack", "s", "hashmap", "and", "resets", "its", "state", ".", "Does", "<em", ">", "not<", "/", "em", ">", "affect", "the", "main", "-", "channel" ]

[ "public", "static", "Fixture", "parseFrom", "(", "String", "fileName", ",", "Parser", "parser", ")", "{", "if", "(", "fileName", "==", "null", ")", "{", "throw", "new", "NullPointerException", "(", "\"File name should not be null\"", ")", ";", "}", "String", "path", "=", "\"fixtures/\"", "+", "fileName", "+", "\".yaml\"", ";", "InputStream", "inputStream", "=", "openPathAsStream", "(", "path", ")", ";", "Fixture", "result", "=", "parser", ".", "parse", "(", "inputStream", ")", ";", "if", "(", "result", ".", "body", "!=", "null", "&&", "!", "result", ".", "body", ".", "startsWith", "(", "\"{\"", ")", ")", "{", "String", "bodyPath", "=", "\"fixtures/\"", "+", "result", ".", "body", ";", "try", "{", "result", ".", "body", "=", "readPathIntoString", "(", "bodyPath", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "new", "IllegalStateException", "(", "\"Error reading body: \"", "+", "bodyPath", ",", "e", ")", ";", "}", "}", "return", "result", ";", "}" ]

[ "Parse", "the", "given", "filename", "and", "returns", "the", "Fixture", "object", "." ]

[ "private", "ILockableEntityGroup", "ifindLockableGroup", "(", "String", "key", ",", "String", "lockOwner", ")", "throws", "GroupsException", "{", "return", "compositeGroupService", ".", "findGroupWithLock", "(", "key", ",", "lockOwner", ")", ";", "}" ]

[ "Returns", "a", "pre", "-", "existing", "<code", ">", "ILockableEntityGroup<", "/", "code", ">", "or", "null", "if", "the", "group", "is", "not", "found", "." ]

[ "protected", "String", "getErrorCodeFrom", "(", "final", "Map", "<", "String", ",", "Object", ">", "model", ")", "{", "return", "model", ".", "get", "(", "CasViewConstants", ".", "MODEL_ATTRIBUTE_NAME_ERROR_CODE", ")", ".", "toString", "(", ")", ";", "}" ]

[ "Gets", "error", "code", "from", "." ]

[ "private", "static", "void", "radixPass", "(", "int", "[", "]", "src", ",", "int", "[", "]", "dst", ",", "int", "[", "]", "v", ",", "int", "vi", ",", "final", "int", "n", ",", "final", "int", "K", ",", "int", "start", ",", "int", "[", "]", "cnt", ")", "{", "// check counter array's size.", "assert", "cnt", ".", "length", ">=", "K", "+", "1", ";", "Arrays", ".", "fill", "(", "cnt", ",", "0", ",", "K", "+", "1", ",", "0", ")", ";", "// count occurrences", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "cnt", "[", "v", "[", "start", "+", "vi", "+", "src", "[", "i", "]", "]", "]", "++", ";", "// exclusive prefix sums", "for", "(", "int", "i", "=", "0", ",", "sum", "=", "0", ";", "i", "<=", "K", ";", "i", "++", ")", "{", "final", "int", "t", "=", "cnt", "[", "i", "]", ";", "cnt", "[", "i", "]", "=", "sum", ";", "sum", "+=", "t", ";", "}", "// sort", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "dst", "[", "cnt", "[", "v", "[", "start", "+", "vi", "+", "src", "[", "i", "]", "]", "]", "++", "]", "=", "src", "[", "i", "]", ";", "}" ]

[ "Stably", "sort", "indexes", "from", "src", "[", "0", "..", "n", "-", "1", "]", "to", "dst", "[", "0", "..", "n", "-", "1", "]", "with", "values", "in", "0", "..", "K", "from", "v", ".", "A", "constant", "offset", "of", "<code", ">", "vi<", "/", "code", ">", "is", "added", "to", "indexes", "from", "src", "." ]