Datasets:

---

stojchet

/

base_prediction_dataset

like 0

[ "protected", "Response", "getResponse", "(", "HttpEntity", "entity", ",", "RequestBuilder", "req", ")", "{", "CloseableHttpClient", "client", "=", "getClient", "(", ")", ";", "initHeaders", "(", "req", ")", ";", "req", ".", "setEntity", "(", "entity", ")", ";", "CloseableHttpResponse", "resp", "=", "null", ";", "Response", "response", "=", "null", ";", "try", "{", "final", "HttpUriRequest", "uriRequest", "=", "req", ".", "build", "(", ")", ";", "resp", "=", "client", ".", "execute", "(", "uriRequest", ")", ";", "response", "=", "new", "Response", "(", "resp", ")", ";", "response", ".", "setMethod", "(", "Methods", ".", "POST", ".", "getMethod", "(", ")", ")", ";", "response", ".", "setRequestLine", "(", "uriRequest", ".", "getRequestLine", "(", ")", ".", "toString", "(", ")", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "// TODO: log the error", "e", ".", "printStackTrace", "(", ")", ";", "}", "finally", "{", "try", "{", "client", ".", "close", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "e", ".", "printStackTrace", "(", ")", ";", "}", "}", "return", "response", ";", "}" ]

[ "get", "response", "from", "preconfigured", "http", "entity", "and", "request", "builder" ]

[ "public", "float", "get", "(", "String", "name", ",", "float", "defaultValue", ")", "throws", "IllegalArgumentException", "{", "ObjectSlot", "slot", "=", "findMandatorySlot", "(", "name", ",", "float", ".", "class", ")", ";", "return", "slot", ".", "defaulted", "?", "defaultValue", ":", "(", "(", "Float", ")", "slot", ".", "fieldValue", ")", ".", "floatValue", "(", ")", ";", "}" ]

[ "Finds", "and", "returns", "the", "float", "value", "of", "a", "given", "field", "named", "{", "@code", "name", "}", "in", "the", "receiver", ".", "If", "the", "field", "has", "not", "been", "assigned", "any", "value", "yet", "the", "default", "value", "{", "@code", "defaultValue", "}", "is", "returned", "instead", "." ]

[ "public", "static", "byte", "[", "]", "padTail", "(", "final", "byte", "[", "]", "a", ",", "final", "int", "length", ")", "{", "byte", "[", "]", "padding", "=", "new", "byte", "[", "length", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "length", ";", "i", "++", ")", "{", "padding", "[", "i", "]", "=", "0", ";", "}", "return", "add", "(", "a", ",", "padding", ")", ";", "}" ]

[ "Return", "a", "byte", "array", "with", "value", "in", "<code", ">", "a<", "/", "code", ">", "plus", "<code", ">", "length<", "/", "code", ">", "appended", "0", "bytes", "." ]

[ "private", "static", "void", "addBoxesWithDiffContent", "(", "final", "WPanel", "panel", ",", "final", "int", "amount", ")", "{", "for", "(", "int", "i", "=", "1", ";", "i", "<=", "amount", ";", "i", "++", ")", "{", "WPanel", "content", "=", "new", "WPanel", "(", "WPanel", ".", "Type", ".", "BOX", ")", ";", "content", ".", "setLayout", "(", "new", "FlowLayout", "(", "FlowLayout", ".", "VERTICAL", ",", "3", ")", ")", ";", "for", "(", "int", "j", "=", "1", ";", "j", "<=", "i", ";", "j", "++", ")", "{", "content", ".", "add", "(", "new", "WText", "(", "Integer", ".", "toString", "(", "i", ")", ")", ")", ";", "}", "panel", ".", "add", "(", "content", ")", ";", "}", "}" ]

[ "Adds", "a", "set", "of", "boxes", "to", "the", "given", "panel", "." ]

[ "public", "static", "TileGrid", "getTileGridWGS84", "(", "BoundingBox", "boundingBox", ",", "int", "zoom", ")", "{", "int", "tilesPerLat", "=", "tilesPerWGS84LatSide", "(", "zoom", ")", ";", "int", "tilesPerLon", "=", "tilesPerWGS84LonSide", "(", "zoom", ")", ";", "double", "tileSizeLat", "=", "tileSizeLatPerWGS84Side", "(", "tilesPerLat", ")", ";", "double", "tileSizeLon", "=", "tileSizeLonPerWGS84Side", "(", "tilesPerLon", ")", ";", "int", "minX", "=", "(", "int", ")", "(", "(", "boundingBox", ".", "getMinLongitude", "(", ")", "+", "ProjectionConstants", ".", "WGS84_HALF_WORLD_LON_WIDTH", ")", "/", "tileSizeLon", ")", ";", "double", "tempMaxX", "=", "(", "boundingBox", ".", "getMaxLongitude", "(", ")", "+", "ProjectionConstants", ".", "WGS84_HALF_WORLD_LON_WIDTH", ")", "/", "tileSizeLon", ";", "int", "maxX", "=", "(", "int", ")", "tempMaxX", ";", "if", "(", "tempMaxX", "%", "1", "==", "0", ")", "{", "maxX", "--", ";", "}", "maxX", "=", "Math", ".", "min", "(", "maxX", ",", "tilesPerLon", "-", "1", ")", ";", "int", "minY", "=", "(", "int", ")", "(", "(", "(", "boundingBox", ".", "getMaxLatitude", "(", ")", "-", "ProjectionConstants", ".", "WGS84_HALF_WORLD_LAT_HEIGHT", ")", "*", "-", "1", ")", "/", "tileSizeLat", ")", ";", "double", "tempMaxY", "=", "(", "(", "boundingBox", ".", "getMinLatitude", "(", ")", "-", "ProjectionConstants", ".", "WGS84_HALF_WORLD_LAT_HEIGHT", ")", "*", "-", "1", ")", "/", "tileSizeLat", ";", "int", "maxY", "=", "(", "int", ")", "tempMaxY", ";", "if", "(", "tempMaxY", "%", "1", "==", "0", ")", "{", "maxY", "--", ";", "}", "maxY", "=", "Math", ".", "min", "(", "maxY", ",", "tilesPerLat", "-", "1", ")", ";", "TileGrid", "grid", "=", "new", "TileGrid", "(", "minX", ",", "minY", ",", "maxX", ",", "maxY", ")", ";", "return", "grid", ";", "}" ]

[ "Get", "the", "tile", "grid", "that", "includes", "the", "entire", "tile", "bounding", "box" ]

[ "private", "Object", "setObjectValue", "(", "Object", "pInner", ",", "String", "pAttribute", ",", "Object", "pValue", ")", "throws", "IllegalAccessException", ",", "InvocationTargetException", "{", "// Call various handlers depending on the type of the inner object, as is extract Object", "Class", "clazz", "=", "pInner", ".", "getClass", "(", ")", ";", "if", "(", "clazz", ".", "isArray", "(", ")", ")", "{", "return", "arrayExtractor", ".", "setObjectValue", "(", "stringToObjectConverter", ",", "pInner", ",", "pAttribute", ",", "pValue", ")", ";", "}", "Extractor", "handler", "=", "getExtractor", "(", "clazz", ")", ";", "if", "(", "handler", "!=", "null", ")", "{", "return", "handler", ".", "setObjectValue", "(", "stringToObjectConverter", ",", "pInner", ",", "pAttribute", ",", "pValue", ")", ";", "}", "else", "{", "throw", "new", "IllegalStateException", "(", "\"Internal error: No handler found for class \"", "+", "clazz", "+", "\" for setting object value.\"", "+", "\" (object: \"", "+", "pInner", "+", "\", attribute: \"", "+", "pAttribute", "+", "\", value: \"", "+", "pValue", "+", "\")\"", ")", ";", "}", "}" ]

[ "Set", "an", "value", "of", "an", "inner", "object" ]

[ "public", "WebFacesPartialResponseDescriptor", "addNamespace", "(", "String", "name", ",", "String", "value", ")", "{", "model", ".", "attribute", "(", "name", ",", "value", ")", ";", "return", "this", ";", "}" ]

[ "Adds", "a", "new", "namespace" ]

[ "public", "Coordinate", "getIntersection", "(", "LineSegment", "lineSegment", ")", "{", "// may not be on either one of the line segments.", "// http://local.wasp.uwa.edu.au/~pbourke/geometry/lineline2d/", "double", "x1", "=", "this", ".", "x1", "(", ")", ";", "double", "y1", "=", "this", ".", "y1", "(", ")", ";", "double", "x2", "=", "this", ".", "x2", "(", ")", ";", "double", "y2", "=", "this", ".", "y2", "(", ")", ";", "double", "x3", "=", "lineSegment", ".", "x1", "(", ")", ";", "double", "y3", "=", "lineSegment", ".", "y1", "(", ")", ";", "double", "x4", "=", "lineSegment", ".", "x2", "(", ")", ";", "double", "y4", "=", "lineSegment", ".", "y2", "(", ")", ";", "double", "denom", "=", "(", "y4", "-", "y3", ")", "*", "(", "x2", "-", "x1", ")", "-", "(", "x4", "-", "x3", ")", "*", "(", "y2", "-", "y1", ")", ";", "double", "u1", "=", "(", "(", "x4", "-", "x3", ")", "*", "(", "y1", "-", "y3", ")", "-", "(", "y4", "-", "y3", ")", "*", "(", "x1", "-", "x3", ")", ")", "/", "denom", ";", "double", "x", "=", "x1", "+", "u1", "*", "(", "x2", "-", "x1", ")", ";", "double", "y", "=", "y1", "+", "u1", "*", "(", "y2", "-", "y1", ")", ";", "return", "new", "Coordinate", "(", "x", ",", "y", ")", ";", "}" ]

[ "Return", "the", "intersection", "point", "of", "2", "lines", ".", "Yes", "you", "are", "reading", "this", "correctly!", "For", "this", "function", "the", "LineSegments", "are", "treated", "as", "lines", ".", "This", "means", "that", "the", "intersection", "point", "does", "not", "necessarily", "lie", "on", "the", "LineSegment", "(", "in", "that", "case", "the", "{", "@link", "#intersects", "}", "function", "would", "return", "false", ")", "." ]

[ "public", "static", "int", "parseLineComment", "(", "final", "char", "[", "]", "query", ",", "int", "offset", ")", "{", "if", "(", "offset", "+", "1", "<", "query", ".", "length", "&&", "query", "[", "offset", "+", "1", "]", "==", "'", "'", ")", "{", "while", "(", "offset", "+", "1", "<", "query", ".", "length", ")", "{", "offset", "++", ";", "if", "(", "query", "[", "offset", "]", "==", "'", "'", "||", "query", "[", "offset", "]", "==", "'", "'", ")", "{", "break", ";", "}", "}", "}", "return", "offset", ";", "}" ]

[ "Test", "if", "the", "<tt", ">", "-", "<", "/", "tt", ">", "character", "at", "<tt", ">", "offset<", "/", "tt", ">", "starts", "a", "<tt", ">", "--", "<", "/", "tt", ">", "style", "line", "comment", "and", "return", "the", "position", "of", "the", "first", "<tt", ">", "\\", "r<", "/", "tt", ">", "or", "<tt", ">", "\\", "n<", "/", "tt", ">", "character", "." ]

[ "public", "static", "TemporaryWriteException", "indexOverlap", "(", "Vertex", "vertex", ",", "Exception", "e", ")", "{", "return", "new", "TemporaryWriteException", "(", "String", ".", "format", "(", "\"Index overlap has led to the accidental sharing of a partially complete vertex {%s}\"", ",", "vertex", ")", ",", "e", ")", ";", "}" ]

[ "Thrown", "when", "multiple", "transactions", "overlap", "in", "using", "an", "index", ".", "This", "results", "in", "incomplete", "vertices", "being", "shared", "between", "transactions", "." ]

[ "public", "boolean", "markSlotInactive", "(", "AllocationID", "allocationId", ",", "Time", "slotTimeout", ")", "throws", "SlotNotFoundException", "{", "checkInit", "(", ")", ";", "TaskSlot", "taskSlot", "=", "getTaskSlot", "(", "allocationId", ")", ";", "if", "(", "taskSlot", "!=", "null", ")", "{", "if", "(", "taskSlot", ".", "markInactive", "(", ")", ")", "{", "// register a timeout to free the slot", "timerService", ".", "registerTimeout", "(", "allocationId", ",", "slotTimeout", ".", "getSize", "(", ")", ",", "slotTimeout", ".", "getUnit", "(", ")", ")", ";", "return", "true", ";", "}", "else", "{", "return", "false", ";", "}", "}", "else", "{", "throw", "new", "SlotNotFoundException", "(", "allocationId", ")", ";", "}", "}" ]

[ "Marks", "the", "slot", "under", "the", "given", "allocation", "id", "as", "inactive", ".", "If", "the", "slot", "could", "not", "be", "found", "then", "a", "{", "@link", "SlotNotFoundException", "}", "is", "thrown", "." ]

[ "public", "MethodDoc", "[", "]", "serializationMethods", "(", ")", "{", "if", "(", "serializedForm", "==", "null", ")", "{", "serializedForm", "=", "new", "SerializedForm", "(", "env", ",", "tsym", ",", "this", ")", ";", "}", "//### Clone this?", "return", "serializedForm", ".", "methods", "(", ")", ";", "}" ]

[ "Return", "the", "serialization", "methods", "for", "this", "class", "." ]

[ "public", "String", "renderInline", "(", "String", "text", ",", "GlobalScope", "...", "extraGlobalScopes", ")", "throws", "IOException", ",", "ParseException", "{", "return", "render", "(", "loadInline", "(", "text", ")", ",", "extraGlobalScopes", ")", ";", "}" ]

[ "Renders", "given", "text", "and", "returns", "rendered", "text", "." ]

[ "public", "static", "void", "assertEquals", "(", "String", "message", ",", "String", "expectedStr", ",", "String", "actualStr", ",", "JSONCompareMode", "compareMode", ")", "throws", "JSONException", "{", "if", "(", "expectedStr", "==", "actualStr", ")", "return", ";", "if", "(", "expectedStr", "==", "null", ")", "{", "throw", "new", "AssertionError", "(", "\"Expected string is null.\"", ")", ";", "}", "else", "if", "(", "actualStr", "==", "null", ")", "{", "throw", "new", "AssertionError", "(", "\"Actual string is null.\"", ")", ";", "}", "JSONCompareResult", "result", "=", "JSONCompare", ".", "compareJSON", "(", "expectedStr", ",", "actualStr", ",", "compareMode", ")", ";", "if", "(", "result", ".", "failed", "(", ")", ")", "{", "throw", "new", "AssertionError", "(", "getCombinedMessage", "(", "message", ",", "result", ".", "getMessage", "(", ")", ")", ")", ";", "}", "}" ]

[ "Asserts", "that", "the", "JSONArray", "provided", "matches", "the", "expected", "string", ".", "If", "it", "isn", "t", "it", "throws", "an", "{", "@link", "AssertionError", "}", "." ]

[ "protected", "OntologyBuilder", "getOntologyBuilder", "(", "VersionRows", "vr", ",", "String", "rootModuleId", ",", "String", "rootModuleVersion", ",", "Map", "<", "String", ",", "String", ">", "metadata", ")", "{", "return", "new", "OntologyBuilder", "(", "vr", ",", "rootModuleId", ",", "rootModuleVersion", ",", "metadata", ")", ";", "}" ]

[ "Hook", "method", "for", "subclasses", "to", "override", "." ]

[ "public", "DynaFormControl", "addControl", "(", "final", "Object", "data", ",", "final", "int", "colspan", ",", "final", "int", "rowspan", ")", "{", "return", "addControl", "(", "data", ",", "DynaFormControl", ".", "DEFAULT_TYPE", ",", "colspan", ",", "rowspan", ")", ";", "}" ]

[ "Adds", "control", "with", "given", "data", "default", "type", "colspan", "and", "rowspan", "." ]

[ "public", "Response", "deleteMember", "(", "String", "roomName", ",", "String", "jid", ")", "{", "return", "restClient", ".", "delete", "(", "\"chatrooms/\"", "+", "roomName", "+", "\"/members/\"", "+", "jid", ",", "new", "HashMap", "<", "String", ",", "String", ">", "(", ")", ")", ";", "}" ]

[ "Delete", "member", "from", "chatroom", "." ]

[ "public", "static", "void", "scaleDownToFit", "(", "Rectangle2D", "rectToFitIn", ",", "Rectangle2D", "toScale", ")", "{", "double", "fitWidth", "=", "rectToFitIn", ".", "getWidth", "(", ")", ";", "double", "fitHeight", "=", "rectToFitIn", ".", "getHeight", "(", ")", ";", "double", "toScaleWidth", "=", "toScale", ".", "getWidth", "(", ")", ";", "double", "toScaleHeight", "=", "toScale", ".", "getHeight", "(", ")", ";", "if", "(", "toScaleWidth", ">", "fitWidth", ")", "{", "double", "factor", "=", "toScaleWidth", "/", "fitWidth", ";", "toScaleWidth", "=", "fitWidth", ";", "toScaleHeight", "=", "toScaleHeight", "/", "factor", ";", "}", "if", "(", "toScaleHeight", ">", "fitHeight", ")", "{", "double", "factor", "=", "toScaleHeight", "/", "fitHeight", ";", "toScaleHeight", "=", "fitHeight", ";", "toScaleWidth", "=", "toScaleWidth", "/", "factor", ";", "}", "toScale", ".", "setRect", "(", "0", ",", "0", ",", "toScaleWidth", ",", "toScaleHeight", ")", ";", "}" ]

[ "Scales", "a", "rectangle", "down", "to", "fit", "inside", "the", "given", "one", "keeping", "the", "ratio", "." ]

[ "public", "static", "Method", "createMethod", "(", "Class", "<", "?", ">", "clazz", ",", "String", "methodName", ",", "Class", "<", "?", ">", "...", "params", ")", "{", "try", "{", "return", "clazz", ".", "getMethod", "(", "methodName", ",", "params", ")", ";", "}", "catch", "(", "NoSuchMethodException", "|", "SecurityException", "e", ")", "{", "throw", "new", "IllegalArgumentException", "(", "e", ")", ";", "}", "}" ]

[ "Convenience", "method", "for", "retrieving", "a", "{", "@link", "Method", "}", "from", "a", "class", "." ]

[ "public", "Observable", "<", "Page", "<", "DatabaseInner", ">", ">", "listByServerAsync", "(", "final", "String", "resourceGroupName", ",", "final", "String", "serverName", ")", "{", "return", "listByServerWithServiceResponseAsync", "(", "resourceGroupName", ",", "serverName", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "Page", "<", "DatabaseInner", ">", ">", ",", "Page", "<", "DatabaseInner", ">", ">", "(", ")", "{", "@", "Override", "public", "Page", "<", "DatabaseInner", ">", "call", "(", "ServiceResponse", "<", "Page", "<", "DatabaseInner", ">", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Gets", "a", "list", "of", "databases", "." ]

[ "public", "<", "T", ">", "T", "flickrUpload", "(", "Map", "<", "String", ",", "String", ">", "params", ",", "byte", "[", "]", "photoData", ",", "Class", "<", "T", ">", "tClass", ")", "throws", "JinxException", "{", "if", "(", "this", ".", "oAuthAccessToken", "==", "null", ")", "{", "throw", "new", "JinxException", "(", "\"Jinx has not been configured with an OAuth Access Token.\"", ")", ";", "}", "params", ".", "put", "(", "\"api_key\"", ",", "getApiKey", "(", ")", ")", ";", "return", "uploadOrReplace", "(", "params", ",", "photoData", ",", "tClass", ",", "new", "OAuthRequest", "(", "Verb", ".", "POST", ",", "FLICKR_PHOTO_UPLOAD_URL", ")", ")", ";", "}" ]

[ "Upload", "a", "photo", "or", "video", "to", "Flickr", ".", "<br", ">", "Do", "not", "call", "this", "directly", ".", "Use", "the", "{", "@link", "net", ".", "jeremybrooks", ".", "jinx", ".", "api", ".", "PhotosUploadApi", "}", "class", "." ]

[ "@", "Override", "public", "Page", "<", "Entity", ">", "previousPage", "(", "final", "Page", "<", "Entity", ">", "page", ",", "final", "TwilioRestClient", "client", ")", "{", "Request", "request", "=", "new", "Request", "(", "HttpMethod", ".", "GET", ",", "page", ".", "getPreviousPageUrl", "(", "Domains", ".", "AUTHY", ".", "toString", "(", ")", ",", "client", ".", "getRegion", "(", ")", ")", ")", ";", "return", "pageForRequest", "(", "client", ",", "request", ")", ";", "}" ]

[ "Retrieve", "the", "previous", "page", "from", "the", "Twilio", "API", "." ]

[ "public", "boolean", "pollResource", "(", ")", "throws", "AmazonServiceException", ",", "WaiterTimedOutException", ",", "WaiterUnrecoverableException", "{", "int", "retriesAttempted", "=", "0", ";", "while", "(", "true", ")", "{", "switch", "(", "getCurrentState", "(", ")", ")", "{", "case", "SUCCESS", ":", "return", "true", ";", "case", "FAILURE", ":", "throw", "new", "WaiterUnrecoverableException", "(", "\"Resource never entered the desired state as it failed.\"", ")", ";", "case", "RETRY", ":", "PollingStrategyContext", "pollingStrategyContext", "=", "new", "PollingStrategyContext", "(", "request", ",", "retriesAttempted", ")", ";", "if", "(", "pollingStrategy", ".", "getRetryStrategy", "(", ")", ".", "shouldRetry", "(", "pollingStrategyContext", ")", ")", "{", "safeCustomDelay", "(", "pollingStrategyContext", ")", ";", "retriesAttempted", "++", ";", "}", "else", "{", "throw", "new", "WaiterTimedOutException", "(", "\"Reached maximum attempts without transitioning to the desired state\"", ")", ";", "}", "break", ";", "}", "}", "}" ]

[ "Polls", "until", "a", "specified", "resource", "transitions", "into", "either", "success", "or", "failure", "state", "or", "until", "the", "specified", "number", "of", "retries", "has", "been", "made", "." ]

[ "public", "Cursor", "<", "DataPoint", ">", "readDataPoints", "(", "Filter", "filter", ",", "Interval", "interval", ",", "DateTimeZone", "timezone", ",", "Aggregation", "aggregation", ",", "Rollup", "rollup", ",", "Interpolation", "interpolation", ")", "{", "checkNotNull", "(", "filter", ")", ";", "checkNotNull", "(", "interval", ")", ";", "checkNotNull", "(", "aggregation", ")", ";", "checkNotNull", "(", "timezone", ")", ";", "URI", "uri", "=", "null", ";", "try", "{", "URIBuilder", "builder", "=", "new", "URIBuilder", "(", "String", ".", "format", "(", "\"/%s/segment/\"", ",", "API_VERSION", ")", ")", ";", "addFilterToURI", "(", "builder", ",", "filter", ")", ";", "addInterpolationToURI", "(", "builder", ",", "interpolation", ")", ";", "addIntervalToURI", "(", "builder", ",", "interval", ")", ";", "addAggregationToURI", "(", "builder", ",", "aggregation", ")", ";", "addRollupToURI", "(", "builder", ",", "rollup", ")", ";", "addTimeZoneToURI", "(", "builder", ",", "timezone", ")", ";", "uri", "=", "builder", ".", "build", "(", ")", ";", "}", "catch", "(", "URISyntaxException", "e", ")", "{", "String", "message", "=", "String", ".", "format", "(", "\"Could not build URI with inputs: filter: %s, interval: %s, aggregation: %s, rollup: %s, timezone: %s\"", ",", "filter", ",", "interval", ",", "aggregation", ",", "rollup", ",", "timezone", ")", ";", "throw", "new", "IllegalArgumentException", "(", "message", ",", "e", ")", ";", "}", "Cursor", "<", "DataPoint", ">", "cursor", "=", "new", "DataPointCursor", "(", "uri", ",", "this", ")", ";", "return", "cursor", ";", "}" ]

[ "Returns", "a", "cursor", "of", "datapoints", "specified", "by", "a", "series", "filter", "." ]

[ "public", "String", "processNested", "(", "Properties", "attributes", ")", "throws", "XDocletException", "{", "String", "name", "=", "OjbMemberTagsHandler", ".", "getMemberName", "(", ")", ";", "XClass", "type", "=", "OjbMemberTagsHandler", ".", "getMemberType", "(", ")", ";", "int", "dim", "=", "OjbMemberTagsHandler", ".", "getMemberDimension", "(", ")", ";", "NestedDef", "nestedDef", "=", "_curClassDef", ".", "getNested", "(", "name", ")", ";", "if", "(", "type", "==", "null", ")", "{", "throw", "new", "XDocletException", "(", "Translator", ".", "getString", "(", "XDocletModulesOjbMessages", ".", "class", ",", "XDocletModulesOjbMessages", ".", "COULD_NOT_DETERMINE_TYPE_OF_MEMBER", ",", "new", "String", "[", "]", "{", "name", "}", ")", ")", ";", "}", "if", "(", "dim", ">", "0", ")", "{", "throw", "new", "XDocletException", "(", "Translator", ".", "getString", "(", "XDocletModulesOjbMessages", ".", "class", ",", "XDocletModulesOjbMessages", ".", "MEMBER_CANNOT_BE_NESTED", ",", "new", "String", "[", "]", "{", "name", ",", "_curClassDef", ".", "getName", "(", ")", "}", ")", ")", ";", "}", "ClassDescriptorDef", "nestedTypeDef", "=", "_model", ".", "getClass", "(", "type", ".", "getQualifiedName", "(", ")", ")", ";", "if", "(", "nestedTypeDef", "==", "null", ")", "{", "throw", "new", "XDocletException", "(", "Translator", ".", "getString", "(", "XDocletModulesOjbMessages", ".", "class", ",", "XDocletModulesOjbMessages", ".", "COULD_NOT_DETERMINE_TYPE_OF_MEMBER", ",", "new", "String", "[", "]", "{", "name", "}", ")", ")", ";", "}", "if", "(", "nestedDef", "==", "null", ")", "{", "nestedDef", "=", "new", "NestedDef", "(", "name", ",", "nestedTypeDef", ")", ";", "_curClassDef", ".", "addNested", "(", "nestedDef", ")", ";", "}", "LogHelper", ".", "debug", "(", "false", ",", "OjbTagsHandler", ".", "class", ",", "\"processNested\"", ",", "\" Processing nested object \"", "+", "nestedDef", ".", "getName", "(", ")", "+", "\" of type \"", "+", "nestedTypeDef", ".", "getName", "(", ")", ")", ";", "String", "attrName", ";", "for", "(", "Enumeration", "attrNames", "=", "attributes", ".", "propertyNames", "(", ")", ";", "attrNames", ".", "hasMoreElements", "(", ")", ";", ")", "{", "attrName", "=", "(", "String", ")", "attrNames", ".", "nextElement", "(", ")", ";", "nestedDef", ".", "setProperty", "(", "attrName", ",", "attributes", ".", "getProperty", "(", "attrName", ")", ")", ";", "}", "return", "\"\"", ";", "}" ]

[ "Addes", "the", "current", "member", "as", "a", "nested", "object", "." ]

[ "public", "Map", "<", "String", ",", "INDArray", ">", "feedForward", "(", "INDArray", "[", "]", "input", ",", "boolean", "train", ")", "{", "return", "feedForward", "(", "input", ",", "train", ",", "true", ")", ";", "}" ]

[ "Conduct", "forward", "pass", "using", "an", "array", "of", "inputs" ]

[ "public", "Observable", "<", "SyncAgentInner", ">", "getAsync", "(", "String", "resourceGroupName", ",", "String", "serverName", ",", "String", "syncAgentName", ")", "{", "return", "getWithServiceResponseAsync", "(", "resourceGroupName", ",", "serverName", ",", "syncAgentName", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "SyncAgentInner", ">", ",", "SyncAgentInner", ">", "(", ")", "{", "@", "Override", "public", "SyncAgentInner", "call", "(", "ServiceResponse", "<", "SyncAgentInner", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Gets", "a", "sync", "agent", "." ]

[ "public", "static", "void", "addCol", "(", "Matrix", "A", ",", "int", "j", ",", "int", "start", ",", "int", "to", ",", "double", "c", ")", "{", "for", "(", "int", "i", "=", "start", ";", "i", "<", "to", ";", "i", "++", ")", "A", ".", "increment", "(", "i", ",", "j", ",", ")", ";", "}" ]

[ "Updates", "the", "values", "of", "column", "<tt", ">", "j<", "/", "tt", ">", "in", "the", "given", "matrix", "to", "be", "A", "[", ":", "j", "]", "=", "A", "[", ":", "j", "]", "+", "c" ]

[ "public", "WorkerPoolResourceInner", "beginCreateOrUpdateWorkerPool", "(", "String", "resourceGroupName", ",", "String", "name", ",", "String", "workerPoolName", ",", "WorkerPoolResourceInner", "workerPoolEnvelope", ")", "{", "return", "beginCreateOrUpdateWorkerPoolWithServiceResponseAsync", "(", "resourceGroupName", ",", "name", ",", "workerPoolName", ",", "workerPoolEnvelope", ")", ".", "toBlocking", "(", ")", ".", "single", "(", ")", ".", "body", "(", ")", ";", "}" ]

[ "Create", "or", "update", "a", "worker", "pool", ".", "Create", "or", "update", "a", "worker", "pool", "." ]

[ "public", "static", "Field", "getDeclaredFieldWithPath", "(", "Class", "<", "?", ">", "clazz", ",", "String", "path", ")", "{", "int", "lastDot", "=", "path", ".", "lastIndexOf", "(", "'", "'", ")", ";", "if", "(", "lastDot", ">", "-", "1", ")", "{", "String", "parentPath", "=", "path", ".", "substring", "(", "0", ",", "lastDot", ")", ";", "String", "fieldName", "=", "path", ".", "substring", "(", "lastDot", "+", "1", ")", ";", "Field", "parentField", "=", "getDeclaredFieldWithPath", "(", "clazz", ",", "parentPath", ")", ";", "return", "getDeclaredFieldInHierarchy", "(", "parentField", ".", "getType", "(", ")", ",", "fieldName", ")", ";", "}", "else", "{", "return", "getDeclaredFieldInHierarchy", "(", "clazz", ",", "path", ")", ";", "}", "}" ]

[ "Returns", "the", "Field", "for", "a", "given", "parent", "class", "and", "a", "dot", "-", "separated", "path", "of", "field", "names", "." ]

[ "public", "CQLSSTableWriter", "rawAddRow", "(", "List", "<", "ByteBuffer", ">", "values", ")", "throws", "InvalidRequestException", ",", "IOException", "{", "if", "(", "values", ".", "size", "(", ")", "!=", "boundNames", ".", "size", "(", ")", ")", "throw", "new", "InvalidRequestException", "(", "String", ".", "format", "(", "\"Invalid number of arguments, expecting %d values but got %d\"", ",", "boundNames", ".", "size", "(", ")", ",", "values", ".", "size", "(", ")", ")", ")", ";", "QueryOptions", "options", "=", "QueryOptions", ".", "forInternalCalls", "(", "null", ",", "values", ")", ";", "List", "<", "ByteBuffer", ">", "keys", "=", "insert", ".", "buildPartitionKeyNames", "(", "options", ")", ";", "Composite", "clusteringPrefix", "=", "insert", ".", "createClusteringPrefix", "(", "options", ")", ";", "long", "now", "=", "System", ".", "currentTimeMillis", "(", ")", "*", "1000", ";", "UpdateParameters", "params", "=", "new", "UpdateParameters", "(", "insert", ".", "cfm", ",", "options", ",", "insert", ".", "getTimestamp", "(", "now", ",", "options", ")", ",", "insert", ".", "getTimeToLive", "(", "options", ")", ",", "Collections", ".", "<", "ByteBuffer", ",", "CQL3Row", ">", "emptyMap", "(", ")", ")", ";", "try", "{", "for", "(", "ByteBuffer", "key", ":", "keys", ")", "{", "if", "(", "writer", ".", "shouldStartNewRow", "(", ")", "||", "!", "key", ".", "equals", "(", "writer", ".", "currentKey", "(", ")", ".", "getKey", "(", ")", ")", ")", "writer", ".", "newRow", "(", "key", ")", ";", "insert", ".", "addUpdateForKey", "(", "writer", ".", "currentColumnFamily", "(", ")", ",", "key", ",", "clusteringPrefix", ",", "params", ",", "false", ")", ";", "}", "return", "this", ";", "}", "catch", "(", "BufferedWriter", ".", "SyncException", "e", ")", "{", "// If we use a BufferedWriter and had a problem writing to disk, the IOException has been", "// wrapped in a SyncException (see BufferedWriter below). We want to extract that IOE.", "throw", "(", "IOException", ")", "e", ".", "getCause", "(", ")", ";", "}", "}" ]

[ "Adds", "a", "new", "row", "to", "the", "writer", "given", "already", "serialized", "values", ".", "<p", ">", "This", "is", "a", "shortcut", "for", "{", "@code", "rawAddRow", "(", "Arrays", ".", "asList", "(", "values", "))", "}", "." ]

[ "@", "Override", "// override with covariant return type", "public", "LocalDate", "dateYearDay", "(", "Era", "era", ",", "int", "yearOfEra", ",", "int", "dayOfYear", ")", "{", "return", "dateYearDay", "(", "prolepticYear", "(", "era", ",", "yearOfEra", ")", ",", "dayOfYear", ")", ";", "}" ]

[ "Obtains", "an", "ISO", "local", "date", "from", "the", "era", "year", "-", "of", "-", "era", "and", "day", "-", "of", "-", "year", "fields", "." ]

[ "public", "boolean", "validateCrumb", "(", "ServletRequest", "request", ",", "MultipartFormDataParser", "parser", ")", "{", "CrumbIssuerDescriptor", "<", "CrumbIssuer", ">", "desc", "=", "getDescriptor", "(", ")", ";", "String", "crumbField", "=", "desc", ".", "getCrumbRequestField", "(", ")", ";", "String", "crumbSalt", "=", "desc", ".", "getCrumbSalt", "(", ")", ";", "return", "validateCrumb", "(", "request", ",", "crumbSalt", ",", "parser", ".", "get", "(", "crumbField", ")", ")", ";", "}" ]

[ "Get", "a", "crumb", "from", "multipart", "form", "data", "and", "validate", "it", "against", "other", "data", "in", "the", "current", "request", ".", "The", "salt", "and", "request", "parameter", "that", "is", "used", "is", "defined", "by", "the", "current", "configuration", "." ]

[ "@", "Override", "public", "R", "visitCase", "(", "CaseTree", "node", ",", "P", "p", ")", "{", "R", "r", "=", "scan", "(", "node", ".", "getExpression", "(", ")", ",", "p", ")", ";", "r", "=", "scanAndReduce", "(", "node", ".", "getStatements", "(", ")", ",", "p", ",", "r", ")", ";", "return", "r", ";", "}" ]

[ "{", "@inheritDoc", "}", "This", "implementation", "scans", "the", "children", "in", "left", "to", "right", "order", "." ]

[ "public", "static", "void", "writeElementList", "(", "XMLOutput", "xmlOutput", ",", "String", "tagName", ",", "Iterator", "<", "String", ">", "listValueIterator", ")", "throws", "IOException", "{", "while", "(", "listValueIterator", ".", "hasNext", "(", ")", ")", "{", "xmlOutput", ".", "openTag", "(", "tagName", ")", ";", "xmlOutput", ".", "writeText", "(", "listValueIterator", ".", "next", "(", ")", ")", ";", "xmlOutput", ".", "closeTag", "(", "tagName", ")", ";", "}", "}" ]

[ "Write", "a", "list", "of", "Strings", "to", "document", "as", "elements", "with", "given", "tag", "name", "." ]

[ "public", "String", "registerSession", "(", "User", "user", ",", "int", "expireDays", ")", "throws", "PersistenceException", "{", "// look for an existing session for this user", "final", "String", "query", "=", "\"select authcode from sessions where userId = \"", "+", "user", ".", "userId", ";", "String", "authcode", "=", "execute", "(", "new", "Operation", "<", "String", ">", "(", ")", "{", "public", "String", "invoke", "(", "Connection", "conn", ",", "DatabaseLiaison", "liaison", ")", "throws", "PersistenceException", ",", "SQLException", "{", "Statement", "stmt", "=", "conn", ".", "createStatement", "(", ")", ";", "try", "{", "ResultSet", "rs", "=", "stmt", ".", "executeQuery", "(", "query", ")", ";", "while", "(", "rs", ".", "next", "(", ")", ")", "{", "return", "rs", ".", "getString", "(", "1", ")", ";", "}", "return", "null", ";", "}", "finally", "{", "JDBCUtil", ".", "close", "(", "stmt", ")", ";", "}", "}", "}", ")", ";", "// figure out when to expire the session", "Calendar", "cal", "=", "Calendar", ".", "getInstance", "(", ")", ";", "cal", ".", "add", "(", "Calendar", ".", "DATE", ",", "expireDays", ")", ";", "Date", "expires", "=", "new", "Date", "(", "cal", ".", "getTime", "(", ")", ".", "getTime", "(", ")", ")", ";", "// if we found one, update its expires time and reuse it", "if", "(", "authcode", "!=", "null", ")", "{", "update", "(", "\"update sessions set expires = '\"", "+", "expires", "+", "\"' where \"", "+", "\"authcode = '\"", "+", "authcode", "+", "\"'\"", ")", ";", "}", "else", "{", "// otherwise create a new one and insert it into the table", "authcode", "=", "UserUtil", ".", "genAuthCode", "(", "user", ")", ";", "update", "(", "\"insert into sessions (authcode, userId, expires) values('\"", "+", "authcode", "+", "\"', \"", "+", "user", ".", "userId", "+", "\", '\"", "+", "expires", "+", "\"')\"", ")", ";", "}", "return", "authcode", ";", "}" ]

[ "Creates", "a", "new", "session", "for", "the", "specified", "user", "and", "returns", "the", "randomly", "generated", "session", "identifier", "for", "that", "session", ".", "If", "a", "session", "entry", "already", "exists", "for", "the", "specified", "user", "it", "will", "be", "reused", "." ]

[ "public", "static", "void", "escapeJsonMinimal", "(", "final", "String", "text", ",", "final", "Writer", "writer", ")", "throws", "IOException", "{", "escapeJson", "(", "text", ",", "writer", ",", "JsonEscapeType", ".", "SINGLE_ESCAPE_CHARS_DEFAULT_TO_UHEXA", ",", "JsonEscapeLevel", ".", "LEVEL_1_BASIC_ESCAPE_SET", ")", ";", "}" ]

[ "<p", ">", "Perform", "a", "JSON", "level", "1", "(", "only", "basic", "set", ")", "<strong", ">", "escape<", "/", "strong", ">", "operation", "on", "a", "<tt", ">", "String<", "/", "tt", ">", "input", "writing", "results", "to", "a", "<tt", ">", "Writer<", "/", "tt", ">", ".", "<", "/", "p", ">", "<p", ">", "<em", ">", "Level", "1<", "/", "em", ">", "means", "this", "method", "will", "only", "escape", "the", "JSON", "basic", "escape", "set", ":", "<", "/", "p", ">", "<ul", ">", "<li", ">", "The", "<em", ">", "Single", "Escape", "Characters<", "/", "em", ">", ":", "<tt", ">", "&#92", ";", "b<", "/", "tt", ">", "(", "<tt", ">", "U", "+", "0008<", "/", "tt", ">", ")", "<tt", ">", "&#92", ";", "t<", "/", "tt", ">", "(", "<tt", ">", "U", "+", "0009<", "/", "tt", ">", ")", "<tt", ">", "&#92", ";", "n<", "/", "tt", ">", "(", "<tt", ">", "U", "+", "000A<", "/", "tt", ">", ")", "<tt", ">", "&#92", ";", "f<", "/", "tt", ">", "(", "<tt", ">", "U", "+", "000C<", "/", "tt", ">", ")", "<tt", ">", "&#92", ";", "r<", "/", "tt", ">", "(", "<tt", ">", "U", "+", "000D<", "/", "tt", ">", ")", "<tt", ">", "&#92", ";", "&quot", ";", "<", "/", "tt", ">", "(", "<tt", ">", "U", "+", "0022<", "/", "tt", ">", ")", "<tt", ">", "&#92", ";", "&#92", ";", "<", "/", "tt", ">", "(", "<tt", ">", "U", "+", "005C<", "/", "tt", ">", ")", "and", "<tt", ">", "&#92", ";", "&#47", ";", "<", "/", "tt", ">", "(", "<tt", ">", "U", "+", "002F<", "/", "tt", ">", ")", ".", "Note", "that", "<tt", ">", "&#92", ";", "&#47", ";", "<", "/", "tt", ">", "is", "optional", "and", "will", "only", "be", "used", "when", "the", "<tt", ">", "&#47", ";", "<", "/", "tt", ">", "symbol", "appears", "after", "<tt", ">", "&lt", ";", "<", "/", "tt", ">", "as", "in", "<tt", ">", "&lt", ";", "&#47", ";", "<", "/", "tt", ">", ".", "This", "is", "to", "avoid", "accidentally", "closing", "<tt", ">", "&lt", ";", "script&gt", ";", "<", "/", "tt", ">", "tags", "in", "HTML", ".", "<", "/", "li", ">", "<li", ">", "Two", "ranges", "of", "non", "-", "displayable", "control", "characters", "(", "some", "of", "which", "are", "already", "part", "of", "the", "<em", ">", "single", "escape", "characters<", "/", "em", ">", "list", ")", ":", "<tt", ">", "U", "+", "0000<", "/", "tt", ">", "to", "<tt", ">", "U", "+", "001F<", "/", "tt", ">", "(", "required", "by", "the", "JSON", "spec", ")", "and", "<tt", ">", "U", "+", "007F<", "/", "tt", ">", "to", "<tt", ">", "U", "+", "009F<", "/", "tt", ">", "(", "additional", ")", ".", "<", "/", "li", ">", "<", "/", "ul", ">", "<p", ">", "This", "method", "calls", "{", "@link", "#escapeJson", "(", "String", "Writer", "JsonEscapeType", "JsonEscapeLevel", ")", "}", "with", "the", "following", "preconfigured", "values", ":", "<", "/", "p", ">", "<ul", ">", "<li", ">", "<tt", ">", "type<", "/", "tt", ">", ":", "{", "@link", "JsonEscapeType#SINGLE_ESCAPE_CHARS_DEFAULT_TO_UHEXA", "}", "<", "/", "li", ">", "<li", ">", "<tt", ">", "level<", "/", "tt", ">", ":", "{", "@link", "JsonEscapeLevel#LEVEL_1_BASIC_ESCAPE_SET", "}", "<", "/", "li", ">", "<", "/", "ul", ">", "<p", ">", "This", "method", "is", "<strong", ">", "thread", "-", "safe<", "/", "strong", ">", ".", "<", "/", "p", ">" ]

[ "private", "boolean", "containsType", "(", "final", "Set", "<", "IPermission", ">", "permissions", ",", "final", "String", "soughtType", ")", "{", "// Assertions", "if", "(", "permissions", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Cannot check null set for contents.\"", ")", ";", "}", "if", "(", "soughtType", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Cannot search for type null.\"", ")", ";", "}", "boolean", "rslt", "=", "false", ";", "// default", "for", "(", "IPermission", "p", ":", "permissions", ")", "{", "if", "(", "soughtType", ".", "equals", "(", "p", ".", "getType", "(", ")", ")", ")", "{", "rslt", "=", "true", ";", "}", "}", "return", "rslt", ";", "}" ]

[ "Returns", "true", "if", "a", "set", "of", "IPermission", "instances", "contains", "a", "permission", "of", "the", "specified", "type", "otherwise", "false", ".", "Permissions", "passed", "to", "this", "method", "<em", ">", "must<", "/", "em", ">", "already", "be", "filtered", "of", "inactive", "(", "expired", ")", "instances", "." ]

[ "@", "Beta", "public", "static", "<", "T", ">", "T", "checkIsInstance", "(", "Class", "<", "T", ">", "class_", ",", "Object", "reference", ",", "@", "Nullable", "String", "errorMessage", ")", "{", "return", "checkIsInstance", "(", "class_", ",", "reference", ",", "errorMessage", ",", "EMPTY_ERROR_MESSAGE_ARGS", ")", ";", "}" ]

[ "Performs", "a", "runtime", "check", "if", "the", "reference", "is", "an", "instance", "of", "the", "provided", "class" ]

[ "public", "final", "boolean", "resetPassword", "(", "String", "token", ",", "String", "newpass", ")", "{", "if", "(", "StringUtils", ".", "isBlank", "(", "newpass", ")", "||", "StringUtils", ".", "isBlank", "(", "token", ")", "||", "newpass", ".", "length", "(", ")", "<", "Config", ".", "MIN_PASS_LENGTH", ")", "{", "return", "false", ";", "}", "Sysprop", "s", "=", "CoreUtils", ".", "getInstance", "(", ")", ".", "getDao", "(", ")", ".", "read", "(", "getAppid", "(", ")", ",", "identifier", ")", ";", "if", "(", "isValidToken", "(", "s", ",", "Config", ".", "_RESET_TOKEN", ",", "token", ")", ")", "{", "s", ".", "removeProperty", "(", "Config", ".", "_RESET_TOKEN", ")", ";", "String", "hashed", "=", "Utils", ".", "bcrypt", "(", "newpass", ")", ";", "s", ".", "addProperty", "(", "Config", ".", "_PASSWORD", ",", "hashed", ")", ";", "setPassword", "(", "hashed", ")", ";", "CoreUtils", ".", "getInstance", "(", ")", ".", "getDao", "(", ")", ".", "update", "(", "getAppid", "(", ")", ",", "s", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Changes", "the", "user", "password", "permanently", "." ]

[ "private", "void", "appendMap", "(", "MapTile", "other", ",", "int", "offsetX", ",", "int", "offsetY", ")", "{", "for", "(", "int", "v", "=", "0", ";", "v", "<", "other", ".", "getInTileHeight", "(", ")", ";", "v", "++", ")", "{", "final", "int", "ty", "=", "offsetY", "+", "v", ";", "for", "(", "int", "h", "=", "0", ";", "h", "<", "other", ".", "getInTileWidth", "(", ")", ";", "h", "++", ")", "{", "final", "int", "tx", "=", "offsetX", "+", "h", ";", "final", "Tile", "tile", "=", "other", ".", "getTile", "(", "h", ",", "v", ")", ";", "if", "(", "tile", "!=", "null", ")", "{", "final", "double", "x", "=", "tx", "*", "(", "double", ")", "map", ".", "getTileWidth", "(", ")", ";", "final", "double", "y", "=", "ty", "*", "(", "double", ")", "map", ".", "getTileHeight", "(", ")", ";", "map", ".", "setTile", "(", "map", ".", "createTile", "(", "tile", ".", "getSheet", "(", ")", ",", "tile", ".", "getNumber", "(", ")", ",", "x", ",", "y", ")", ")", ";", "}", "}", "}", "}" ]

[ "Append", "the", "map", "at", "specified", "offset", "." ]

[ "public", "void", "onAuthenticationFailure", "(", "BoxAuthenticationInfo", "infoOriginal", ",", "Exception", "ex", ")", "{", "String", "msg", "=", "\"failure:\"", ";", "if", "(", "getAuthStorage", "(", ")", "!=", "null", ")", "{", "msg", "+=", "\"auth storage :\"", "+", "getAuthStorage", "(", ")", ".", "toString", "(", ")", ";", "}", "BoxAuthenticationInfo", "info", "=", "BoxAuthenticationInfo", ".", "unmodifiableObject", "(", "infoOriginal", ")", ";", "if", "(", "info", "!=", "null", ")", "{", "msg", "+=", "info", ".", "getUser", "(", ")", "==", "null", "?", "\"null user\"", ":", "info", ".", "getUser", "(", ")", ".", "getId", "(", ")", "==", "null", "?", "\"null user id\"", ":", "info", ".", "getUser", "(", ")", ".", "getId", "(", ")", ".", "length", "(", ")", ";", "}", "BoxLogUtils", ".", "nonFatalE", "(", "\"BoxAuthfail\"", ",", "msg", ",", "ex", ")", ";", "Set", "<", "AuthListener", ">", "listeners", "=", "getListeners", "(", ")", ";", "for", "(", "AuthListener", "listener", ":", "listeners", ")", "{", "listener", ".", "onAuthFailure", "(", "info", ",", "ex", ")", ";", "}", "}" ]

[ "Callback", "method", "to", "be", "called", "if", "authentication", "process", "fails", "." ]

[ "public", "static", "void", "readFully", "(", "InputStream", "in", ",", "byte", "[", "]", "buf", ",", "int", "off", ",", "int", "len", ")", "throws", "IOException", "{", "int", "n", "=", "0", ";", "while", "(", "n", "<", "len", ")", "{", "int", "count", "=", "in", ".", "read", "(", "buf", ",", "off", "+", "n", ",", "len", "-", "n", ")", ";", "if", "(", "count", "<", "0", ")", "throw", "new", "EOFException", "(", ")", ";", "n", "+=", "count", ";", "}", "}" ]

[ "Reads", "some", "number", "of", "bytes", "from", "the", "input", "stream", ".", "This", "function", "blocks", "until", "all", "data", "is", "read", "or", "an", "I", "/", "O", "error", "occurs", "." ]

[ "public", "void", "deleteValue", "(", "String", "tagName", ",", "String", "tagValue", ")", "{", "deleteValueWithServiceResponseAsync", "(", "tagName", ",", "tagValue", ")", ".", "toBlocking", "(", ")", ".", "single", "(", ")", ".", "body", "(", ")", ";", "}" ]

[ "Deletes", "a", "tag", "value", "." ]

[ "protected", "long", "getDelta", "(", "long", "timeStamp", ",", "long", "maxValue", ")", "{", "boolean", "even", "=", "(", "evenBase", ">", "oddBase", ")", ";", "long", "base", "=", "even", "?", "evenBase", ":", "oddBase", ";", "long", "delta", "=", "timeStamp", "-", "base", ";", "// make sure this timestamp is not sufficiently old that we can't", "// generate a delta time with it", "if", "(", "delta", "<", "0", ")", "{", "String", "errmsg", "=", "\"Time stamp too old for conversion to delta time\"", ";", "throw", "new", "IllegalArgumentException", "(", "errmsg", ")", ";", "}", "// see if it's time to swap", "if", "(", "delta", ">", "maxValue", ")", "{", "if", "(", "even", ")", "{", "setOddBase", "(", "timeStamp", ")", ";", "}", "else", "{", "setEvenBase", "(", "timeStamp", ")", ";", "}", "delta", "=", "0", ";", "}", "// if we're odd, we need to mark the value as such", "if", "(", "!", "even", ")", "{", "delta", "=", "(", "-", "1", "-", "delta", ")", ";", "}", "return", "delta", ";", "}" ]

[ "Obtains", "a", "delta", "with", "the", "specified", "maximum", "value", "swapping", "from", "even", "to", "odd", "if", "necessary", "." ]

[ "@", "Deprecated", "@", "Override", "protected", "int", "write", "(", "int", "offset", ",", "int", "length", ")", "{", "int", "newLength", "=", "charsLength", "+", "length", ";", "ensureCapacity", "(", "newLength", ")", ";", "charsLength", "=", "newLength", ";", "int", "charsOffset", "=", "chars", ".", "length", "-", "charsLength", ";", "while", "(", "length", ">", "0", ")", "{", "chars", "[", "charsOffset", "++", "]", "=", "strings", ".", "charAt", "(", "offset", "++", ")", ";", "--", "length", ";", "}", "return", "charsLength", ";", "}" ]

[ "{" ]

[ "public", "static", "List", "<", "String", ">", "readLines", "(", "File", "file", ",", "Charset", "charset", ")", "throws", "IOException", "{", "InputStream", "in", "=", "null", ";", "try", "{", "in", "=", "new", "FileInputStream", "(", "file", ")", ";", "if", "(", "null", "==", "charset", ")", "{", "return", "IOs", ".", "readLines", "(", "new", "InputStreamReader", "(", "in", ")", ")", ";", "}", "else", "{", "InputStreamReader", "reader", "=", "new", "InputStreamReader", "(", "in", ",", "charset", ".", "name", "(", ")", ")", ";", "return", "IOs", ".", "readLines", "(", "reader", ")", ";", "}", "}", "finally", "{", "IOs", ".", "close", "(", "in", ")", ";", "}", "}" ]

[ "Reads", "the", "contents", "of", "a", "file", "line", "by", "line", "to", "a", "List", "of", "Strings", ".", "The", "file", "is", "always", "closed", "." ]

[ "public", "void", "doSubstitution", "(", "double", "number", ",", "StringBuilder", "toInsertInto", ",", "int", "position", ",", "int", "recursionCount", ")", "{", "if", "(", "!", "byDigits", ")", "{", "// if we're not in \"byDigits\" mode, just use the inherited", "// doSubstitution() routine", "super", ".", "doSubstitution", "(", "number", ",", "toInsertInto", ",", "position", ",", "recursionCount", ")", ";", "}", "else", "{", "// if we're in \"byDigits\" mode, transform the value into an integer", "// by moving the decimal point eight places to the right and", "// pulling digits off the right one at a time, formatting each digit", "// as an integer using this substitution's owning rule set", "// (this is slower, but more accurate, than doing it from the", "// other end)", "// just print to string and then use that", "DigitList", "dl", "=", "new", "DigitList", "(", ")", ";", "dl", ".", "set", "(", "number", ",", "20", ",", "true", ")", ";", "boolean", "pad", "=", "false", ";", "while", "(", "dl", ".", "count", ">", "Math", ".", "max", "(", "0", ",", "dl", ".", "decimalAt", ")", ")", "{", "if", "(", "pad", "&&", "useSpaces", ")", "{", "toInsertInto", ".", "insert", "(", "position", "+", "pos", ",", "'", "'", ")", ";", "}", "else", "{", "pad", "=", "true", ";", "}", "ruleSet", ".", "format", "(", "dl", ".", "digits", "[", "--", "dl", ".", "count", "]", "-", "'", "'", ",", "toInsertInto", ",", "position", "+", "pos", ",", "recursionCount", ")", ";", "}", "while", "(", "dl", ".", "decimalAt", "<", "0", ")", "{", "if", "(", "pad", "&&", "useSpaces", ")", "{", "toInsertInto", ".", "insert", "(", "position", "+", "pos", ",", "'", "'", ")", ";", "}", "else", "{", "pad", "=", "true", ";", "}", "ruleSet", ".", "format", "(", "0", ",", "toInsertInto", ",", "position", "+", "pos", ",", "recursionCount", ")", ";", "++", "dl", ".", "decimalAt", ";", "}", "}", "}" ]

[ "If", "in", "by", "digits", "mode", "fills", "in", "the", "substitution", "one", "decimal", "digit", "at", "a", "time", "using", "the", "rule", "set", "containing", "this", "substitution", ".", "Otherwise", "uses", "the", "superclass", "function", "." ]

[ "public", "Interval", "toInterval", "(", "DateTimeZone", "zone", ")", "{", "zone", "=", "DateTimeUtils", ".", "getZone", "(", "zone", ")", ";", "DateTime", "start", "=", "toDateTimeAtStartOfDay", "(", "zone", ")", ";", "DateTime", "end", "=", "plusDays", "(", "1", ")", ".", "toDateTimeAtStartOfDay", "(", "zone", ")", ";", "return", "new", "Interval", "(", "start", ",", "end", ")", ";", "}" ]

[ "Converts", "this", "object", "to", "an", "Interval", "representing", "the", "whole", "day", ".", "<p", ">", "The", "interval", "may", "have", "more", "or", "less", "than", "24", "hours", "if", "this", "is", "a", "daylight", "savings", "cutover", "date", ".", "<p", ">", "This", "instance", "is", "immutable", "and", "unaffected", "by", "this", "method", "call", "." ]

[ "public", "static", "Point2D_F32", "convertPixelToNorm", "(", "CameraModel", "param", ",", "Point2D_F32", "pixel", ",", "Point2D_F32", "norm", ")", "{", "return", "ImplPerspectiveOps_F32", ".", "convertPixelToNorm", "(", "param", ",", "pixel", ",", "norm", ")", ";", "}" ]

[ "<p", ">", "Convenient", "function", "for", "converting", "from", "distorted", "image", "pixel", "coordinate", "to", "undistorted", "normalized", "image", "coordinates", ".", "If", "speed", "is", "a", "concern", "then", "{", "@link", "PinholePtoN_F32", "}", "should", "be", "used", "instead", ".", "<", "/", "p", ">" ]

[ "@", "Deprecated", "public", "String", "stripFrom", "(", "CharSequence", "source", ",", "boolean", "matches", ")", "{", "StringBuilder", "result", "=", "new", "StringBuilder", "(", ")", ";", "for", "(", "int", "pos", "=", "0", ";", "pos", "<", "source", ".", "length", "(", ")", ";", ")", "{", "int", "inside", "=", "findIn", "(", "source", ",", "pos", ",", "!", "matches", ")", ";", "result", ".", "append", "(", "source", ".", "subSequence", "(", "pos", ",", "inside", ")", ")", ";", "pos", "=", "findIn", "(", "source", ",", "inside", ",", "matches", ")", ";", "// get next start", "}", "return", "result", ".", "toString", "(", ")", ";", "}" ]

[ "Strips", "code", "points", "from", "source", ".", "If", "matches", "is", "true", "script", "all", "that", "match", "<i", ">", "this<", "/", "i", ">", ".", "If", "matches", "is", "false", "then", "strip", "all", "that", "<i", ">", "don", "t<", "/", "i", ">", "match", "." ]

[ "public", "void", "setLicense", "(", "String", "photoId", ",", "int", "licenseId", ")", "throws", "FlickrException", "{", "Map", "<", "String", ",", "Object", ">", "parameters", "=", "new", "HashMap", "<", "String", ",", "Object", ">", "(", ")", ";", "parameters", ".", "put", "(", "\"method\"", ",", "METHOD_SET_LICENSE", ")", ";", "parameters", ".", "put", "(", "\"photo_id\"", ",", "photoId", ")", ";", "parameters", ".", "put", "(", "\"license_id\"", ",", "Integer", ".", "toString", "(", "licenseId", ")", ")", ";", "// Note: This method requires an HTTP POST request.\r", "Response", "response", "=", "transportAPI", ".", "post", "(", "transportAPI", ".", "getPath", "(", ")", ",", "parameters", ",", "apiKey", ",", "sharedSecret", ")", ";", "if", "(", "response", ".", "isError", "(", ")", ")", "{", "throw", "new", "FlickrException", "(", "response", ".", "getErrorCode", "(", ")", ",", "response", ".", "getErrorMessage", "(", ")", ")", ";", "}", "// This method has no specific response - It returns an empty sucess response if it completes without error.\r", "}" ]

[ "Sets", "the", "license", "for", "a", "photo", "." ]

[ "public", "static", "String", "getStartSiteRoot", "(", "CmsObject", "cms", ",", "CmsWorkplaceSettings", "settings", ")", "{", "return", "getStartSiteRoot", "(", "cms", ",", "settings", ".", "getUserSettings", "(", ")", ")", ";", "}" ]

[ "Returns", "the", "start", "site", "from", "the", "given", "workplace", "settings", ".", "<p", ">" ]

[ "private", "void", "updateInitSignature", "(", "int", "idx", ",", "State", "<", "O", ">", "succ", ")", "{", "StateSignature", "<", "O", ">", "sig", "=", "init", ".", "getSignature", "(", ")", ";", "State", "<", "O", ">", "oldSucc", "=", "sig", ".", "successors", ".", "array", "[", "idx", "]", ";", "if", "(", "oldSucc", "==", "succ", ")", "{", "return", ";", "}", "if", "(", "oldSucc", "!=", "null", ")", "{", "oldSucc", ".", "decreaseIncoming", "(", ")", ";", "}", "sig", ".", "successors", ".", "array", "[", "idx", "]", "=", "succ", ";", "succ", ".", "increaseIncoming", "(", ")", ";", "}" ]

[ "Update", "the", "signature", "of", "the", "initial", "state", ".", "This", "requires", "special", "handling", "as", "the", "initial", "state", "is", "not", "stored", "in", "the", "register", "(", "since", "it", "can", "never", "legally", "act", "as", "a", "predecessor", ")", "." ]

[ "public", "PageSource", "getPageSource", "(", "String", "key", ",", "boolean", "updateAccesTime", ")", "{", "// DO NOT CHANGE INTERFACE (used by Argus Monitor)", "PageSource", "ps", "=", "pageSources", ".", "get", "(", "key", ".", "toLowerCase", "(", ")", ")", ";", "if", "(", "ps", "==", "null", ")", "return", "null", ";", "if", "(", "updateAccesTime", ")", "ps", ".", "setLastAccessTime", "(", ")", ";", "return", "ps", ";", "}" ]

[ "return", "pages", "matching", "to", "key" ]

[ "public", "static", "Inet6Address", "getByAddress", "(", "String", "host", ",", "byte", "[", "]", "addr", ",", "NetworkInterface", "nif", ")", "throws", "UnknownHostException", "{", "if", "(", "host", "!=", "null", "&&", "host", ".", "length", "(", ")", ">", "0", "&&", "host", ".", "charAt", "(", "0", ")", "==", "'", "'", ")", "{", "if", "(", "host", ".", "charAt", "(", "host", ".", "length", "(", ")", "-", "1", ")", "==", "'", "'", ")", "{", "host", "=", "host", ".", "substring", "(", "1", ",", "host", ".", "length", "(", ")", "-", "1", ")", ";", "}", "}", "if", "(", "addr", "!=", "null", ")", "{", "if", "(", "addr", ".", "length", "==", "Inet6Address", ".", "INADDRSZ", ")", "{", "return", "new", "Inet6Address", "(", "host", ",", "addr", ",", "nif", ")", ";", "}", "}", "throw", "new", "UnknownHostException", "(", "\"addr is of illegal length\"", ")", ";", "}" ]

[ "Create", "an", "Inet6Address", "in", "the", "exact", "manner", "of", "{", "@link", "InetAddress#getByAddress", "(", "String", "byte", "[]", ")", "}", "except", "that", "the", "IPv6", "scope_id", "is", "set", "to", "the", "value", "corresponding", "to", "the", "given", "interface", "for", "the", "address", "type", "specified", "in", "<code", ">", "addr<", "/", "code", ">", ".", "The", "call", "will", "fail", "with", "an", "UnknownHostException", "if", "the", "given", "interface", "does", "not", "have", "a", "numeric", "scope_id", "assigned", "for", "the", "given", "address", "type", "(", "eg", ".", "link", "-", "local", "or", "site", "-", "local", ")", ".", "See", "<a", "href", "=", "Inet6Address", ".", "html#scoped", ">", "here<", "/", "a", ">", "for", "a", "description", "of", "IPv6", "scoped", "addresses", "." ]

[ "@", "NotNull", "public", "DoubleStream", "scan", "(", "@", "NotNull", "final", "DoubleBinaryOperator", "accumulator", ")", "{", "Objects", ".", "requireNonNull", "(", "accumulator", ")", ";", "return", "new", "DoubleStream", "(", "params", ",", "new", "DoubleScan", "(", "iterator", ",", "accumulator", ")", ")", ";", "}" ]

[ "Returns", "a", "{", "@code", "DoubleStream", "}", "produced", "by", "iterative", "application", "of", "a", "accumulation", "function", "to", "reduction", "value", "and", "next", "element", "of", "the", "current", "stream", ".", "Produces", "a", "{", "@code", "DoubleStream", "}", "consisting", "of", "{", "@code", "value1", "}", "{", "@code", "acc", "(", "value1", "value2", ")", "}", "{", "@code", "acc", "(", "acc", "(", "value1", "value2", ")", "value3", ")", "}", "etc", "." ]

[ "public", "String", "get", "(", "String", "key", ",", "Object", "...", "args", ")", "{", "// First make the key for GWT-friendly", "return", "fetch", "(", "key", ".", "replace", "(", "'", "'", ",", "'", "'", ")", ",", "args", ")", ";", "}" ]

[ "Translate", "a", "key", "with", "any", "number", "of", "arguments", "backed", "by", "the", "Lookup", "." ]

[ "private", "void", "checkNewlySharded", "(", "DBObject", "dbObj", ",", "Map", "<", "String", ",", "String", ">", "currScalarMap", ")", "{", "if", "(", "!", "m_tableDef", ".", "isSharded", "(", ")", ")", "{", "return", ";", "}", "String", "shardingFieldName", "=", "m_tableDef", ".", "getShardingField", "(", ")", ".", "getName", "(", ")", ";", "if", "(", "!", "currScalarMap", ".", "containsKey", "(", "shardingFieldName", ")", ")", "{", "m_dbTran", ".", "addAllObjectsColumn", "(", "m_tableDef", ",", "dbObj", ".", "getObjectID", "(", ")", ",", "m_tableDef", ".", "getShardNumber", "(", "dbObj", ")", ")", ";", "}", "}" ]

[ "previously", "undetermined", "but", "is", "not", "being", "assigned", "to", "a", "shard", "." ]

[ "public", "void", "grantPermission", "(", "Grantee", "grantee", ",", "Permission", "permission", ")", "{", "getGrantsAsList", "(", ")", ".", "add", "(", "new", "Grant", "(", "grantee", ",", "permission", ")", ")", ";", "}" ]

[ "Adds", "a", "grantee", "to", "the", "access", "control", "list", "(", "ACL", ")", "with", "the", "given", "permission", ".", "If", "this", "access", "control", "list", "already", "contains", "the", "grantee", "(", "i", ".", "e", ".", "the", "same", "grantee", "object", ")", "the", "permission", "for", "the", "grantee", "will", "be", "updated", "." ]

[ "public", "static", "URI", "buildNewURI", "(", "URI", "referenceUri", ",", "String", "uriSuffix", ")", "throws", "URISyntaxException", "{", "if", "(", "uriSuffix", "==", "null", ")", "throw", "new", "IllegalArgumentException", "(", "\"The URI suffix cannot be null.\"", ")", ";", "uriSuffix", "=", "uriSuffix", ".", "replaceAll", "(", "\"\\\\\\\\\"", ",", "\"/\"", ")", ";", "URI", "importUri", "=", "null", ";", "try", "{", "// Absolute URL ?", "importUri", "=", "urlToUri", "(", "new", "URL", "(", "uriSuffix", ")", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "try", "{", "// Relative URL ?", "if", "(", "!", "referenceUri", ".", "toString", "(", ")", ".", "endsWith", "(", "\"/\"", ")", "&&", "!", "uriSuffix", ".", "startsWith", "(", "\"/\"", ")", ")", "referenceUri", "=", "new", "URI", "(", "referenceUri", ".", "toString", "(", ")", "+", "\"/\"", ")", ";", "importUri", "=", "referenceUri", ".", "resolve", "(", "new", "URI", "(", "null", ",", "uriSuffix", ",", "null", ")", ")", ";", "}", "catch", "(", "Exception", "e2", ")", "{", "String", "msg", "=", "\"An URI could not be built from the URI \"", "+", "referenceUri", ".", "toString", "(", ")", "+", "\" and the suffix \"", "+", "uriSuffix", "+", "\".\"", ";", "throw", "new", "URISyntaxException", "(", "msg", ",", "e2", ".", "getMessage", "(", ")", ")", ";", "}", "}", "return", "importUri", ".", "normalize", "(", ")", ";", "}" ]

[ "Builds", "an", "URI", "from", "an", "URI", "and", "a", "suffix", "." ]

[ "public", "void", "removeNodeFromPool", "(", "String", "poolId", ",", "String", "computeNodeId", ")", "throws", "BatchErrorException", ",", "IOException", "{", "removeNodeFromPool", "(", "poolId", ",", "computeNodeId", ",", "null", ",", "null", ",", "null", ")", ";", "}" ]

[ "Removes", "the", "specified", "compute", "node", "from", "the", "specified", "pool", "." ]

[ "public", "static", "String", "stream", "(", "InputStream", "in", ",", "long", "len", ")", "throws", "IOException", "{", "if", "(", "len", "==", "0", ")", "{", "return", "\"Fto5o-5ea0sNMlW_75VgGJCv2AcJ\"", ";", "}", "byte", "[", "]", "buffer", "=", "new", "byte", "[", "64", "*", "1024", "]", ";", "byte", "[", "]", "[", "]", "blocks", "=", "new", "byte", "[", "(", "int", ")", "(", "(", "len", "+", "Configuration", ".", "BLOCK_SIZE", "-", "1", ")", "/", "Configuration", ".", "BLOCK_SIZE", ")", "]", "[", "", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "blocks", ".", "length", ";", "i", "++", ")", "{", "long", "left", "=", "len", "-", "(", "long", ")", "Configuration", ".", "BLOCK_SIZE", "*", "i", ";", "long", "read", "=", "left", ">", "Configuration", ".", "BLOCK_SIZE", "?", "Configuration", ".", "BLOCK_SIZE", ":", "left", ";", "blocks", "[", "i", "]", "=", "oneBlock", "(", "buffer", ",", "in", ",", "(", "int", ")", "read", ")", ";", "}", "return", "resultEncode", "(", "blocks", ")", ";", "}" ]

[ "计算输入流的etag" ]

[ "private", "boolean", "verifyHostname", "(", "String", "hostname", ",", "X509Certificate", "certificate", ")", "{", "hostname", "=", "hostname", ".", "toLowerCase", "(", "Locale", ".", "US", ")", ";", "boolean", "hasDns", "=", "false", ";", "List", "<", "String", ">", "altNames", "=", "getSubjectAltNames", "(", "certificate", ",", "ALT_DNS_NAME", ")", ";", "for", "(", "int", "i", "=", "0", ",", "size", "=", "altNames", ".", "size", "(", ")", ";", "i", "<", "size", ";", "i", "++", ")", "{", "hasDns", "=", "true", ";", "if", "(", "verifyHostname", "(", "hostname", ",", "altNames", ".", "get", "(", "i", ")", ")", ")", "{", "return", "true", ";", "}", "}", "if", "(", "!", "hasDns", ")", "{", "X500Principal", "principal", "=", "certificate", ".", "getSubjectX500Principal", "(", ")", ";", "// RFC 2818 advises using the most specific name for matching.", "String", "cn", "=", "new", "DistinguishedNameParser", "(", "principal", ")", ".", "findMostSpecific", "(", "\"cn\"", ")", ";", "if", "(", "cn", "!=", "null", ")", "{", "return", "verifyHostname", "(", "hostname", ",", "cn", ")", ";", "}", "else", "{", "// NOTE: In case of empty Common Name (CN), not checking", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Returns", "true", "if", "{" ]

[ "private", "UnaryCallable", "<", "String", ",", "List", "<", "KeyOffset", ">", ">", "createSampleRowKeysCallable", "(", ")", "{", "UnaryCallable", "<", "SampleRowKeysRequest", ",", "List", "<", "SampleRowKeysResponse", ">", ">", "spoolable", "=", "stub", ".", "sampleRowKeysCallable", "(", ")", ".", "all", "(", ")", ";", "UnaryCallable", "<", "SampleRowKeysRequest", ",", "List", "<", "SampleRowKeysResponse", ">", ">", "retryable", "=", "Callables", ".", "retrying", "(", "spoolable", ",", "settings", ".", "sampleRowKeysSettings", "(", ")", ",", "clientContext", ")", ";", "return", "createUserFacingUnaryCallable", "(", "\"SampleRowKeys\"", ",", "new", "SampleRowKeysCallable", "(", "retryable", ",", "requestContext", ")", ")", ";", "}" ]

[ "Creates", "a", "callable", "chain", "to", "handle", "SampleRowKeys", "RPcs", ".", "The", "chain", "will", ":" ]

[ "public", "static", "long", "bytesToLong", "(", "byte", "[", "]", "bytes", ",", "int", "offset", ")", "{", "long", "result", "=", "0x0", ";", "for", "(", "int", "i", "=", "offset", ";", "i", "<", "offset", "+", "8", ";", "++", "i", ")", "{", "result", "=", "result", "<<", "8", ";", "result", "|=", "(", "bytes", "[", "i", "]", "&", "0x00000000000000FF", "l", ")", ";", "}", "return", "result", ";", "}" ]

[ "A", "utility", "method", "to", "convert", "the", "long", "from", "the", "byte", "array", "to", "a", "long", "." ]

[ "public", "void", "deleteUser", "(", "CmsRequestContext", "context", ",", "String", "username", ")", "throws", "CmsException", "{", "CmsUser", "user", "=", "readUser", "(", "context", ",", "username", ")", ";", "deleteUser", "(", "context", ",", "user", ",", "null", ")", ";", "}" ]

[ "Deletes", "a", "user", ".", "<p", ">" ]

[ "protected", "static", "Object", "primitiveArrayPut", "(", "Object", "self", ",", "int", "idx", ",", "Object", "newValue", ")", "{", "Array", ".", "set", "(", "self", ",", "normaliseIndex", "(", "idx", ",", "Array", ".", "getLength", "(", "self", ")", ")", ",", "newValue", ")", ";", "return", "newValue", ";", "}" ]

[ "Implements", "the", "setAt", "(", "int", "idx", ")", "method", "for", "primitive", "type", "arrays", "." ]

[ "public", "void", "addBodyFileUpload", "(", "String", "name", ",", "String", "filename", ",", "File", "file", ",", "String", "contentType", ",", "boolean", "isText", ")", "throws", "ErrorDataEncoderException", "{", "checkNotNull", "(", "name", ",", "\"name\"", ")", ";", "checkNotNull", "(", "file", ",", "\"file\"", ")", ";", "if", "(", "filename", "==", "null", ")", "{", "filename", "=", "StringUtil", ".", "EMPTY_STRING", ";", "}", "String", "scontentType", "=", "contentType", ";", "String", "contentTransferEncoding", "=", "null", ";", "if", "(", "contentType", "==", "null", ")", "{", "if", "(", "isText", ")", "{", "scontentType", "=", "HttpPostBodyUtil", ".", "DEFAULT_TEXT_CONTENT_TYPE", ";", "}", "else", "{", "scontentType", "=", "HttpPostBodyUtil", ".", "DEFAULT_BINARY_CONTENT_TYPE", ";", "}", "}", "if", "(", "!", "isText", ")", "{", "contentTransferEncoding", "=", "HttpPostBodyUtil", ".", "TransferEncodingMechanism", ".", "BINARY", ".", "value", "(", ")", ";", "}", "FileUpload", "fileUpload", "=", "factory", ".", "createFileUpload", "(", "request", ",", "name", ",", "filename", ",", "scontentType", ",", "contentTransferEncoding", ",", "null", ",", "file", ".", "length", "(", ")", ")", ";", "try", "{", "fileUpload", ".", "setContent", "(", "file", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "new", "ErrorDataEncoderException", "(", "e", ")", ";", "}", "addBodyHttpData", "(", "fileUpload", ")", ";", "}" ]

[ "Add", "a", "file", "as", "a", "FileUpload" ]

[ "public", "Pixel", "setRGB_fromDouble", "(", "double", "r", ",", "double", "g", ",", "double", "b", ")", "{", "return", "setValue", "(", "Pixel", ".", "rgb_fromNormalized", "(", "r", ",", "g", ",", "b", ")", ")", ";", "}" ]

[ "Sets", "an", "opaque", "RGB", "value", "at", "the", "position", "currently", "referenced", "by", "this", "Pixel", ".", "<br", ">", "Each", "channel", "value", "is", "assumed", "to", "be", "within", "[", "0", ".", "0", "..", "1", ".", "0", "]", ".", "Channel", "values", "outside", "these", "bounds", "will", "be", "clamped", "to", "them", ".", "@param", "r", "normalized", "red", "@param", "g", "normalized", "green", "@param", "b", "normalized", "blue", "@throws", "ArrayIndexOutOfBoundsException", "if", "this", "Pixel", "s", "index", "is", "not", "in", "range", "of", "the", "Img", "s", "data", "array", "." ]

[ "public", "SimpleFieldValidation", "addRule", "(", "ExecutionPath", "fieldPath", ",", "BiFunction", "<", "FieldAndArguments", ",", "FieldValidationEnvironment", ",", "Optional", "<", "GraphQLError", ">", ">", "rule", ")", "{", "rules", ".", "put", "(", "fieldPath", ",", "rule", ")", ";", "return", "this", ";", "}" ]

[ "Adds", "the", "rule", "against", "the", "field", "address", "path", ".", "If", "the", "rule", "returns", "an", "error", "it", "will", "be", "added", "to", "the", "list", "of", "errors" ]

[ "public", "OvhChangeIpStatus", "serviceName_canLicenseBeMovedTo_GET", "(", "String", "serviceName", ",", "String", "destinationIp", ")", "throws", "IOException", "{", "String", "qPath", "=", "\"/license/virtuozzo/{serviceName}/canLicenseBeMovedTo\"", ";", "StringBuilder", "sb", "=", "path", "(", "qPath", ",", "serviceName", ")", ";", "query", "(", "sb", ",", "\"destinationIp\"", ",", "destinationIp", ")", ";", "String", "resp", "=", "exec", "(", "qPath", ",", "\"GET\"", ",", "sb", ".", "toString", "(", ")", ",", "null", ")", ";", "return", "convertTo", "(", "resp", ",", "OvhChangeIpStatus", ".", "class", ")", ";", "}" ]

[ "Will", "tell", "if", "the", "ip", "can", "accept", "the", "license" ]

[ "protected", "<", "R", ",", "C", ">", "R", "accept", "(", "AstVisitor", "<", "R", ",", "C", ">", "visitor", ",", "C", "context", ")", "{", "return", "visitor", ".", "visitNode", "(", "this", ",", "context", ")", ";", "}" ]

[ "Accessible", "for", "{" ]

[ "public", "String", "formatJavadoc", "(", "String", "header", ",", "String", "javadoc", ")", "{", "try", "{", "StringBuilder", "result", "=", "new", "StringBuilder", "(", ")", ";", "result", ".", "append", "(", "escape", "(", "CODE_HIGHLIGHT", ")", ")", ".", "append", "(", "header", ")", ".", "append", "(", "escape", "(", "CODE_RESET", ")", ")", ".", "append", "(", "\"\\n\"", ")", ";", "if", "(", "javadoc", "==", "null", ")", "{", "return", "result", ".", "toString", "(", ")", ";", "}", "JavacTask", "task", "=", "(", "JavacTask", ")", "ToolProvider", ".", "getSystemJavaCompiler", "(", ")", ".", "getTask", "(", "null", ",", "null", ",", "null", ",", "null", ",", "null", ",", "null", ")", ";", "DocTrees", "trees", "=", "DocTrees", ".", "instance", "(", "task", ")", ";", "DocCommentTree", "docComment", "=", "trees", ".", "getDocCommentTree", "(", "new", "SimpleJavaFileObject", "(", "new", "URI", "(", "\"mem://doc.html\"", ")", ",", "Kind", ".", "HTML", ")", "{", "@", "Override", "@", "DefinedBy", "(", "Api", ".", "COMPILER", ")", "public", "CharSequence", "getCharContent", "(", "boolean", "ignoreEncodingErrors", ")", "throws", "IOException", "{", "return", "\"<body>\"", "+", "javadoc", "+", "\"</body>\"", ";", "}", "}", ")", ";", "new", "FormatJavadocScanner", "(", "result", ",", "task", ")", ".", "scan", "(", "docComment", ",", "null", ")", ";", "addNewLineIfNeeded", "(", "result", ")", ";", "return", "result", ".", "toString", "(", ")", ";", "}", "catch", "(", "URISyntaxException", "ex", ")", "{", "throw", "new", "InternalError", "(", "\"Unexpected exception\"", ",", "ex", ")", ";", "}", "}" ]

[ "Format", "javadoc", "to", "plain", "text", "." ]

[ "@", "Override", "protected", "String", "getEscapedValue", "(", "HttpMessage", "msg", ",", "String", "value", ")", "{", "// ZAP: unfortunately the method setQuery() defined inside the httpclient Apache component\r", "// create trouble when special characters like ?+? are set inside the parameter, \r", "// because this method implementation simply doesn't encode them.\r", "// So we have to explicitly encode values using the URLEncoder component before setting it.\r", "return", "(", "value", "!=", "null", ")", "?", "AbstractPlugin", ".", "getURLEncode", "(", "value", ")", ":", "\"\"", ";", "}" ]

[ "Encode", "the", "parameter", "for", "a", "correct", "URL", "introduction" ]

[ "@", "Override", "public", "void", "populateCredentials", "(", "Map", "<", "String", ",", "String", ">", "credentials", ",", "Map", "topologyConfiguration", ")", "{", "populateCredentials", "(", "credentials", ",", "topologyConfiguration", ",", "null", ")", ";", "}" ]

[ "{" ]

[ "public", "FluentSelect", "deselectByIndex", "(", "final", "int", "index", ")", "{", "executeAndWrapReThrowIfNeeded", "(", "new", "DeselectByIndex", "(", "index", ")", ",", "Context", ".", "singular", "(", "context", ",", "\"deselectByIndex\"", ",", "null", ",", "index", ")", ",", "true", ")", ";", "return", "new", "FluentSelect", "(", "super", ".", "delegate", ",", "currentElement", ".", "getFound", "(", ")", ",", "this", ".", "context", ",", "monitor", ",", "booleanInsteadOfNotFoundException", ")", ";", "}" ]

[ "Deselect", "the", "option", "at", "the", "given", "index", ".", "This", "is", "done", "by", "examining", "the", "index", "attribute", "of", "an", "element", "and", "not", "merely", "by", "counting", "." ]

[ "private", "final", "void", "_appendCharacterEscape", "(", "char", "ch", ",", "int", "escCode", ")", "throws", "IOException", ",", "JsonGenerationException", "{", "if", "(", "escCode", ">=", "0", ")", "{", "// \\\\N (2 char)", "if", "(", "(", "_outputTail", "+", "2", ")", ">", "_outputEnd", ")", "{", "_flushBuffer", "(", ")", ";", "}", "_outputBuffer", "[", "_outputTail", "++", "]", "=", "'", "'", ";", "_outputBuffer", "[", "_outputTail", "++", "]", "=", "(", "char", ")", "escCode", ";", "return", ";", "}", "if", "(", "escCode", "!=", "CharacterEscapes", ".", "ESCAPE_CUSTOM", ")", "{", "// std, \\\\uXXXX", "if", "(", "(", "_outputTail", "+", "2", ")", ">", "_outputEnd", ")", "{", "_flushBuffer", "(", ")", ";", "}", "int", "ptr", "=", "_outputTail", ";", "char", "[", "]", "buf", "=", "_outputBuffer", ";", "buf", "[", "ptr", "++", "]", "=", "'", "'", ";", "buf", "[", "ptr", "++", "]", "=", "'", "'", ";", "// We know it's a control char, so only the last 2 chars are non-0", "if", "(", "ch", ">", "0xFF", ")", "{", "// beyond 8 bytes", "int", "hi", "=", "(", "ch", ">>", "8", ")", "&", "0xFF", ";", "buf", "[", "ptr", "++", "]", "=", "HEX_CHARS", "[", "hi", ">>", "4", "]", ";", "buf", "[", "ptr", "++", "]", "=", "HEX_CHARS", "[", "hi", "&", "0xF", "]", ";", "ch", "&=", "0xFF", ";", "}", "else", "{", "buf", "[", "ptr", "++", "]", "=", "'", "'", ";", "buf", "[", "ptr", "++", "]", "=", "'", "'", ";", "}", "buf", "[", "ptr", "++", "]", "=", "HEX_CHARS", "[", "ch", ">>", "4", "]", ";", "buf", "[", "ptr", "]", "=", "HEX_CHARS", "[", "ch", "&", "0xF", "]", ";", "_outputTail", "=", "ptr", ";", "return", ";", "}", "}" ]

[ "Method", "called", "to", "append", "escape", "sequence", "for", "given", "character", "at", "the", "end", "of", "standard", "output", "buffer", ";", "or", "if", "not", "possible", "write", "out", "directly", "." ]

[ "public", "CDownloadRequest", "setRange", "(", "long", "offset", ",", "long", "length", ")", "{", "if", "(", "length", "==", "0", ")", "{", "// Indicate we want to download 0 bytes ?! We ignore such specification", "length", "=", "-", "1", ";", "}", "if", "(", "offset", "<", "0", "&&", "length", "<", "0", ")", "{", "byteRange", "=", "null", ";", "}", "else", "{", "byteRange", "=", "new", "ByteRange", "(", "offset", ",", "length", ")", ";", "}", "return", "this", ";", "}" ]

[ "Defines", "a", "range", "for", "partial", "content", "download", ".", "Note", "that", "second", "parameter", "is", "a", "length", "not", "an", "offset", "(", "this", "differs", "from", "http", "header", "Range", "header", "raw", "value", ")", ".", "<ul", ">", "<li", ">", "(", "-", "1", "-", "1", ")", "=", "default", ":", "download", "full", "blob", ".", "<", "/", "li", ">", "<li", ">", "(", "10", "-", "1", ")", "=", "download", "starting", "at", "offset", "10<", "/", "li", ">", "<li", ">", "(", "-", "1", "10", ")", "=", "download", "last", "10", "bytes<", "/", "li", ">", "<li", ">", "(", "10", "100", ")", "=", "download", "100", "bytes", "starting", "at", "offset", "10", ".", "<", "/", "li", ">", "<", "/", "ul", ">" ]

[ "public", "static", "BlueprintProducer", "getBlueprintProducer", "(", "String", "producerId", ",", "String", "category", ",", "String", "subsystem", ")", "{", "try", "{", "//first find producer", "BlueprintProducer", "producer", "=", "producers", ".", "get", "(", "producerId", ")", ";", "if", "(", "producer", "==", "null", ")", "{", "synchronized", "(", "producers", ")", "{", "producer", "=", "producers", ".", "get", "(", "producerId", ")", ";", "if", "(", "producer", "==", "null", ")", "{", "producer", "=", "new", "BlueprintProducer", "(", "producerId", ",", "category", ",", "subsystem", ")", ";", "producers", ".", "put", "(", "producerId", ",", "producer", ")", ";", "}", "}", "}", "//end producer lookup", "return", "producer", ";", "}", "catch", "(", "Exception", "e", ")", "{", "log", ".", "error", "(", "\"getBlueprintProducer(\"", "+", "producerId", "+", "\", \"", "+", "category", "+", "\", \"", "+", "subsystem", "+", "'", "'", ",", "e", ")", ";", "throw", "new", "RuntimeException", "(", "\"Handler instantiation failed - \"", "+", "e", ".", "getMessage", "(", ")", ")", ";", "}", "}" ]

[ "Returns", "the", "blueprint", "producer", "with", "this", "id", ".", "Creates", "one", "if", "none", "is", "existing", ".", "Uses", "DLC", "pattern", "to", "reduce", "synchronization", "overhead", "." ]

[ "private", "void", "reopenS3InputStream", "(", ")", "throws", "IOException", "{", "// First attempt to close the existing input stream", "try", "{", "closeS3InputStream", "(", ")", ";", "}", "catch", "(", "IOException", "ignore", ")", "{", "// Ignore this exception; we're re-opening because there was in issue with the existing stream", "// in the first place.", "}", "InputStream", "remainingIn", "=", "null", ";", "int", "attempt", "=", "0", ";", "while", "(", "remainingIn", "==", "null", ")", "{", "try", "{", "S3Object", "s3Object", "=", "_s3", ".", "getObject", "(", "new", "GetObjectRequest", "(", "_bucket", ",", "_key", ")", ".", "withRange", "(", "_pos", ",", "_length", "-", "1", ")", ")", ";", "// Range is inclusive, hence length-1", "remainingIn", "=", "s3Object", ".", "getObjectContent", "(", ")", ";", "}", "catch", "(", "AmazonClientException", "e", ")", "{", "// Allow up to 3 retries", "attempt", "+=", "1", ";", "if", "(", "!", "e", ".", "isRetryable", "(", ")", "||", "attempt", "==", "4", ")", "{", "throw", "e", ";", "}", "// Back-off on each retry", "try", "{", "Thread", ".", "sleep", "(", "200", "*", "attempt", ")", ";", "}", "catch", "(", "InterruptedException", "interrupt", ")", "{", "throw", "Throwables", ".", "propagate", "(", "interrupt", ")", ";", "}", "}", "}", "_in", "=", "remainingIn", ";", "}" ]

[ "Re", "-", "opens", "the", "input", "stream", "starting", "at", "the", "first", "unread", "byte", "." ]

[ "private", "Siren4JSubEntity", "getSubEntityAnnotation", "(", "Field", "currentField", ",", "List", "<", "ReflectedInfo", ">", "fieldInfo", ")", "{", "Siren4JSubEntity", "result", "=", "null", ";", "result", "=", "currentField", ".", "getAnnotation", "(", "Siren4JSubEntity", ".", "class", ")", ";", "if", "(", "result", "==", "null", "&&", "fieldInfo", "!=", "null", ")", "{", "ReflectedInfo", "info", "=", "ReflectionUtils", ".", "getFieldInfoByName", "(", "fieldInfo", ",", "currentField", ".", "getName", "(", ")", ")", ";", "if", "(", "info", "!=", "null", "&&", "info", ".", "getGetter", "(", ")", "!=", "null", ")", "{", "result", "=", "info", ".", "getGetter", "(", ")", ".", "getAnnotation", "(", "Siren4JSubEntity", ".", "class", ")", ";", "}", "}", "return", "result", ";", "}" ]

[ "Helper", "to", "retrieve", "a", "sub", "entity", "annotation", "from", "either", "the", "field", "itself", "or", "the", "getter", ".", "If", "an", "annotation", "exists", "on", "both", "then", "the", "field", "wins", "." ]

[ "public", "void", "doRemove", "(", "FieldTable", "table", ",", "KeyAreaInfo", "keyArea", ",", "BaseBuffer", "buffer", ")", "throws", "DBException", "{", "if", "(", "!", "this", ".", "atCurrent", "(", "buffer", ")", ")", "{", "buffer", "=", "this", ".", "doSeek", "(", "\"==\"", ",", "table", ",", "keyArea", ")", ";", "if", "(", "buffer", "==", "null", ")", "throw", "new", "DBException", "(", "Constants", ".", "FILE_INCONSISTENCY", ")", ";", "}", "this", ".", "removeCurrent", "(", "buffer", ")", ";", "}" ]

[ "Delete", "the", "key", "from", "this", "buffer", "." ]

[ "public", "BoxRequestsFolder", ".", "CreateFolder", "getCreateRequest", "(", "String", "parentId", ",", "String", "name", ")", "{", "BoxRequestsFolder", ".", "CreateFolder", "request", "=", "new", "BoxRequestsFolder", ".", "CreateFolder", "(", "parentId", ",", "name", ",", "getFoldersUrl", "(", ")", ",", "mSession", ")", ";", "return", "request", ";", "}" ]

[ "Gets", "a", "request", "that", "creates", "a", "folder", "in", "a", "parent", "folder" ]

[ "public", "FutureData", "<", "Token", ">", "getToken", "(", "String", "identity", ",", "String", "service", ")", "{", "FutureData", "<", "Token", ">", "future", "=", "new", "FutureData", "<>", "(", ")", ";", "URI", "uri", "=", "newParams", "(", ")", ".", "put", "(", "\"id\"", ",", "identity", ")", ".", "forURL", "(", "config", ".", "newAPIEndpointURI", "(", "IDENTITY", "+", "\"/\"", "+", "identity", "+", "\"/token/\"", "+", "service", ")", ")", ";", "Request", "request", "=", "config", ".", "http", "(", ")", ".", "GET", "(", "uri", ",", "new", "PageReader", "(", "newRequestCallback", "(", "future", ",", "new", "Token", "(", ")", ",", "config", ")", ")", ")", ";", "performRequest", "(", "future", ",", "request", ")", ";", "return", "future", ";", "}" ]

[ "/", "*", "Fetch", "a", "token", "using", "it", "s", "service", "ID", "and", "it", "s", "Identity", "s", "ID" ]

[ "public", "static", "String", "getTransactionNameFromId", "(", "String", "parentStreamSegmentName", ",", "UUID", "transactionId", ")", "{", "StringBuilder", "result", "=", "new", "StringBuilder", "(", ")", ";", "result", ".", "append", "(", "parentStreamSegmentName", ")", ";", "result", ".", "append", "(", "TRANSACTION_DELIMITER", ")", ";", "result", ".", "append", "(", "String", ".", "format", "(", "FULL_HEX_FORMAT", ",", "transactionId", ".", "getMostSignificantBits", "(", ")", ")", ")", ";", "result", ".", "append", "(", "String", ".", "format", "(", "FULL_HEX_FORMAT", ",", "transactionId", ".", "getLeastSignificantBits", "(", ")", ")", ")", ";", "return", "result", ".", "toString", "(", ")", ";", "}" ]

[ "Returns", "the", "transaction", "name", "for", "a", "TransactionStreamSegment", "based", "on", "the", "name", "of", "the", "current", "Parent", "StreamSegment", "and", "the", "transactionId", "." ]

[ "public", "T", "queryString", "(", "String", "name", ",", "String", "value", ")", "{", "List", "<", "String", ">", "l", "=", "queryString", ".", "get", "(", "name", ")", ";", "if", "(", "l", "==", "null", ")", "{", "l", "=", "new", "ArrayList", "<", "String", ">", "(", ")", ";", "}", "l", ".", "add", "(", "value", ")", ";", "queryString", ".", "put", "(", "name", ",", "l", ")", ";", "return", "derived", ".", "cast", "(", "this", ")", ";", "}" ]

[ "Add", "a", "query", "param", "." ]

[ "protected", "synchronized", "<", "V", ">", "V", "retryRPC", "(", "RpcCallable", "<", "V", ">", "rpc", ")", "throws", "AlluxioStatusException", "{", "return", "retryRPCInternal", "(", "rpc", ",", "(", ")", "->", "null", ")", ";", "}" ]

[ "Tries", "to", "execute", "an", "RPC", "defined", "as", "a", "{", "@link", "RpcCallable", "}", "." ]

[ "public", "ResponseWrapper", "setGroupShield", "(", "GroupShieldPayload", "payload", ",", "String", "username", ")", "throws", "APIConnectionException", ",", "APIRequestException", "{", "return", "_userClient", ".", "setGroupShield", "(", "payload", ",", "username", ")", ";", "}" ]

[ "Set", "user", "s", "group", "message", "blocking" ]

[ "public", "<", "T", "extends", "ISubscribedState", ">", "T", "setSubscribedState", "(", "String", "componentId", ",", "T", "obj", ")", "{", "return", "setSubscribedState", "(", "componentId", ",", "Utils", ".", "DEFAULT_STREAM_ID", ",", "obj", ")", ";", "}" ]

[ "Synchronizes", "the", "default", "stream", "from", "the", "specified", "state", "spout", "component", "id", "with", "the", "provided", "ISubscribedState", "object", "." ]

[ "void", "unregisterEntry", "(", "ListIterator", "<", "PathElement", ">", "iterator", ",", "String", "value", ",", "ConcreteNotificationHandlerRegistration", ".", "NotificationHandlerEntry", "entry", ")", "{", "NotificationHandlerNodeRegistry", "registry", "=", "childRegistries", ".", "get", "(", "value", ")", ";", "if", "(", "registry", "==", "null", ")", "{", "return", ";", "}", "registry", ".", "unregisterEntry", "(", "iterator", ",", "entry", ")", ";", "}" ]

[ "Get", "the", "registry", "child", "for", "the", "given", "{" ]

[ "private", "static", "<", "T", ">", "T", "mapByIndex", "(", "byte", "[", "]", "content", ",", "Class", "<", "T", ">", "genericType", ",", "ObjectMetaData", "objectMap", ",", "Charset", "charset", ")", "throws", "InstantiationException", ",", "IllegalAccessException", ",", "InvocationTargetException", "{", "List", "<", "FieldMetaData", ">", "mappingFields", "=", "objectMap", ".", "getFieldList", "(", ")", ";", "T", "obj", "=", "genericType", ".", "newInstance", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "mappingFields", ".", "size", "(", ")", ";", "i", "++", ")", "{", "FieldMetaData", "field", "=", "mappingFields", ".", "get", "(", "i", ")", ";", "// 设置属性值", "LOGGER", ".", "debug", "(", "\"设置值是 \" + field", "+", "field", "g", "tValu", "e", "(content", ",", " charse", "t", ");", "", "", "", "BeanUtils", ".", "setProperty", "(", "obj", ",", "field", ".", "getFieldName", "(", ")", ",", "field", ".", "getValue", "(", "content", ",", "charset", ")", ")", ";", "}", "return", "obj", ";", "}" ]

[ "按列顺序映射" ]

[ "public", "static", "<", "T", ">", "T", "get", "(", "Class", "<", "T", ">", "clazz", ",", "String", "sql", ",", "Object", "...", "arg", ")", "{", "List", "<", "T", ">", "list", "=", "DBUtils", ".", "getList", "(", "clazz", ",", "sql", ",", "arg", ")", ";", "if", "(", "list", ".", "isEmpty", "(", ")", ")", "{", "return", "null", ";", "}", "return", "list", ".", "get", "(", "0", ")", ";", "}" ]

[ "本函数所查找的结果只能返回一条记录，若查找到的多条记录符合要求将返回第一条符合要求的记录" ]

[ "public", "static", "int", "indexOfAnyBut", "(", "String", "str", ",", "String", "searchChars", ")", "{", "if", "(", "isEmpty", "(", "str", ")", "||", "isEmpty", "(", "searchChars", ")", ")", "{", "return", "INDEX_NOT_FOUND", ";", "}", "int", "strLen", "=", "str", ".", "length", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "strLen", ";", "i", "++", ")", "{", "char", "ch", "=", "str", ".", "charAt", "(", "i", ")", ";", "boolean", "chFound", "=", "searchChars", ".", "indexOf", "(", "ch", ")", ">=", "0", ";", "if", "(", "i", "+", "1", "<", "strLen", "&&", "CharUtils", ".", "isHighSurrogate", "(", "ch", ")", ")", "{", "char", "ch2", "=", "str", ".", "charAt", "(", "i", "+", "1", ")", ";", "if", "(", "chFound", "&&", "searchChars", ".", "indexOf", "(", "ch2", ")", "<", "0", ")", "{", "return", "i", ";", "}", "}", "else", "{", "if", "(", "!", "chFound", ")", "{", "return", "i", ";", "}", "}", "}", "return", "INDEX_NOT_FOUND", ";", "}" ]

[ "<p", ">", "Search", "a", "String", "to", "find", "the", "first", "index", "of", "any", "character", "not", "in", "the", "given", "set", "of", "characters", ".", "<", "/", "p", ">" ]

[ "public", "static", "InetSocketAddress", "getInetSocketAddress", "(", "String", "endpoint", ")", "{", "String", "[", "]", "array", "=", "endpoint", ".", "split", "(", "\":\"", ")", ";", "return", "new", "InetSocketAddress", "(", "array", "[", "0", "]", ",", "Integer", ".", "parseInt", "(", "array", "[", "1", "]", ")", ")", ";", "}" ]

[ "Convert", "an", "endpoint", "from", "String", "(", "host", ":", "port", ")", "to", "InetSocketAddress" ]

[ "public", "String", "getAttribute", "(", "String", "section", ",", "String", "name", ")", "{", "Attributes", "attr", "=", "getManifest", "(", ")", ".", "getAttributes", "(", "section", ")", ";", "return", "attr", "!=", "null", "?", "attr", ".", "getValue", "(", "name", ")", ":", "null", ";", "}" ]

[ "Returns", "an", "attribute", "s", "value", "from", "a", "non", "-", "main", "section", "of", "this", "JAR", "s", "manifest", "." ]

[ "public", "void", "error", "(", "final", "CellField", "<", "T", ">", "cellField", ",", "final", "String", "messageKey", ")", "{", "error", "(", "cellField", ",", "messageKey", ",", "getMessageVariables", "(", "cellField", ")", ")", ";", "}" ]

[ "メッセージキーを指定して、エラー情報を追加します。", "<p", ">", "エラーメッセージ中の変数は、", "{" ]

[ "public", "CompletableFuture", "<", "Pair", "<", "VersionedTransactionData", ",", "List", "<", "StreamSegmentRecord", ">", ">", ">", "createTxn", "(", "final", "String", "scope", ",", "final", "String", "stream", ",", "final", "long", "lease", ",", "final", "OperationContext", "contextOpt", ")", "{", "final", "OperationContext", "context", "=", "getNonNullOperationContext", "(", "scope", ",", "stream", ",", "contextOpt", ")", ";", "return", "createTxnBody", "(", "scope", ",", "stream", ",", "lease", ",", "context", ")", ";", "}" ]

[ "Create", "transaction", "." ]

[ "String", "computeKeys", "(", "ExecutableElement", "methodElement", ",", "List", "<", "String", ">", "arguments", ")", "{", "String", "keys", "=", "stringJoinAndDecorate", "(", "arguments", ",", "COMMA", ",", "new", "NothingDecorator", "(", ")", ")", ";", "if", "(", "arguments", "!=", "null", "&&", "!", "arguments", ".", "isEmpty", "(", ")", ")", "{", "JsCacheResult", "jcr", "=", "methodElement", ".", "getAnnotation", "(", "JsCacheResult", ".", "class", ")", ";", "// if there is a jcr annotation with value diferrent of *, so we dont use all arguments\r", "if", "(", "!", "considerateAllArgs", "(", "jcr", ")", ")", "{", "keys", "=", "stringJoinAndDecorate", "(", "Arrays", ".", "asList", "(", "jcr", ".", "keys", "(", ")", ")", ",", "COMMA", ",", "new", "KeyForArgDecorator", "(", ")", ")", ";", "}", "}", "return", "keys", ";", "}" ]

[ "Generate", "key", "part", "for", "variable", "part", "of", "md5" ]

[ "public", "String", "getName", "(", "int", "ch", ",", "int", "choice", ")", "{", "if", "(", "ch", "<", "UCharacter", ".", "MIN_VALUE", "||", "ch", ">", "UCharacter", ".", "MAX_VALUE", "||", "choice", ">", "UCharacterNameChoice", ".", "CHAR_NAME_CHOICE_COUNT", ")", "{", "return", "null", ";", "}", "String", "result", "=", "null", ";", "result", "=", "getAlgName", "(", "ch", ",", "choice", ")", ";", "// getting normal character name", "if", "(", "result", "==", "null", "||", "result", ".", "length", "(", ")", "==", "0", ")", "{", "if", "(", "choice", "==", "UCharacterNameChoice", ".", "EXTENDED_CHAR_NAME", ")", "{", "result", "=", "getExtendedName", "(", "ch", ")", ";", "}", "else", "{", "result", "=", "getGroupName", "(", "ch", ",", "choice", ")", ";", "}", "}", "return", "result", ";", "}" ]

[ "Retrieve", "the", "name", "of", "a", "Unicode", "code", "point", ".", "Depending", "on", "<code", ">", "choice<", "/", "code", ">", "the", "character", "name", "written", "into", "the", "buffer", "is", "the", "modern", "name", "or", "the", "name", "that", "was", "defined", "in", "Unicode", "version", "1", ".", "0", ".", "The", "name", "contains", "only", "invariant", "characters", "like", "A", "-", "Z", "0", "-", "9", "space", "and", "-", "." ]