public boolean containsAnyCodePoint(final CharSequence text, final Range inputRange) { final int len = text.length(); if (len == 0) { return false; } if (mostSignificantGap != null && mostSignificantGap.contains(inputRange.first) && mostSignificantGap.contains(inputRange.last)) { return false; } // if found, returns the index, otherwise "-insertionPoint - 1" final int idxEnd = Arrays.binarySearch(ranges, new Range(inputRange.last), CONTAINS_COMPARATOR); // search for start in "head" range only (likely small) final int startFromIdx = 0; final int startEndIdx = idxEnd >= 0 ? idxEnd + 1 : -(idxEnd + 1); final int idxStart = Arrays.binarySearch( ranges, startFromIdx, startEndIdx, new Range(inputRange.first), CONTAINS_COMPARATOR); // If whole range in text outside same non-contained range, won't be found // If whole range in text inside single contained range, must match if (idxStart == idxEnd) { return idxStart >= 0; } // if start or end inside contained range, match if (idxStart >= 0 || idxEnd >= 0) { return true; } // text spans across multiple ranges of set, need to search individual chars final int searchStart = -idxStart + 1; final int searchEnd = -idxEnd + 1; for (int i = 0; i < len; ) { final int cp = Character.codePointAt(text, i); i += Character.charCount(cp); final int idx = Arrays.binarySearch(ranges, searchStart, searchEnd, new Range(cp), CONTAINS_COMPARATOR); if (idx > 0) { return true; } } return false; }
public boolean intersects(Range intersectedRange) { if (contains(intersectedRange.start) || intersectedRange.contains(start)) { return true; } return false; }
private Range findIncludingRange(long mac) { for (Range range : ranges) { if (range.contains(mac)) { return range; } } return null; }
public boolean contains(final int i) { if (mostSignificantGap != null && mostSignificantGap.contains(i)) { return false; } final Range searchRange = new Range(i); int idx = Arrays.binarySearch(ranges, searchRange, CONTAINS_COMPARATOR); return idx >= 0; }
/** Test of contains method, of class Range. */ @Test public void testContains_Range() { System.out.println("contains"); Range r = new Range(3, 6); Range instance = new Range(4, 5); boolean expResult = false; boolean result = instance.contains(r); assertEquals(expResult, result); }
/** Test of contains method, of class Range. */ @Test public void testContains_int() { System.out.println("contains"); int x = 5; Range instance = new Range(4, 10); boolean expResult = true; boolean result = instance.contains(x); assertEquals(expResult, result); }
public String classify(Range r) { if (this.equals(r)) return "SAME"; if (this.contains(r)) return "SUPERSET"; if (r.contains(this)) return "SUBSET"; if (this.isDisjoint(r)) if (this.lo > r.hi) return "MOREDISJOINT"; else return "LESSDISJOINT"; if (this.lessThan(r)) return "LESSOVERLAP"; return "MOREOVERLAP"; }
public Relation classify(Range r) { if (this.equals(r)) return Relation.SAME; if (this.contains(r)) return Relation.SUPERSET; if (r.contains(this)) return Relation.SUBSET; if (this.isDisjoint(r)) if (this.lo > r.hi) return Relation.MOREDISJOINT; else return Relation.LESSDISJOINT; if (this.lessThan(r)) return Relation.LESSOVERLAP; return Relation.MOREOVERLAP; }
/** Checks whether given peak list row conforms to this search condition. */ public boolean conforms(PeakListRow row) { switch (type) { case NAME: PeakIdentity identity = row.getPreferredPeakIdentity(); if (identity == null) return false; String name = identity.getName(); if (isEmpty(nameRegex.toString()) || isEmpty(name)) { return false; } Matcher matcher = nameRegex.matcher(name); return matcher.find(); case MASS: return range.contains(row.getAverageMZ()); case RT: return range.contains(row.getAverageRT()); } return false; }
public CommandResponse doREMOVEJOB(CommandRequest request) throws ImproperUsageException { if (!request.hasArgument()) { throw new ImproperUsageException(); } class Range { long _low, _high; Range(long low, long high) { if (0 >= low || low > high) { throw new IllegalArgumentException("0 < low <= high"); } _low = low; _high = high; } public boolean contains(long val) { return _low <= val && val <= _high; } } ArrayList<Range> rangeList = new ArrayList<Range>(); String rangeString = request.getArgument(); String[] ranges = rangeString.split(" "); for (String range : ranges) { if (range.indexOf("-") == -1) { long val = Long.parseLong(range); rangeList.add(new Range(val, val)); } else { String[] vals = range.split("-"); rangeList.add(new Range(Long.parseLong(vals[0]), Long.parseLong(vals[1]))); } } TreeSet<Job> treeSet = new TreeSet<Job>(new JobIndexComparator()); treeSet.addAll(getJobManager().getAllJobsFromQueue()); ReplacerEnvironment env = new ReplacerEnvironment(); CommandResponse response = StandardCommandManager.genericResponse("RESPONSE_200_COMMAND_OK"); for (Job job : treeSet) { for (Range range : rangeList) { if (range.contains(job.getIndex())) { env.add("job", job); getJobManager().stopJob(job); response.addComment( request.getSession().jprintf(_bundle, env, _keyPrefix + "removejob.success")); } } } return response; }
@Test public void containsRev() { Range<Integer> range = new IntRange(5, 1).incrementBy(-1); assertThat(range.contains(6), is(false)); assertThat(range.contains(5), is(true)); assertThat(range.contains(4), is(true)); assertThat(range.contains(3), is(true)); assertThat(range.contains(2), is(true)); assertThat(range.contains(1), is(false)); assertThat(range.contains(42), is(false)); range.incrementBy(-2); assertThat(range.contains(5), is(true)); assertThat(range.contains(4), is(false)); assertThat(range.contains(3), is(true)); assertThat(range.contains(2), is(false)); assertThat(range.contains(1), is(false)); }
static FacebookRequestError checkResponseAndCreateError( JSONObject singleResult, Object batchResult, HttpURLConnection connection) { try { if (singleResult.has(CODE_KEY)) { int responseCode = singleResult.getInt(CODE_KEY); Object body = Utility.getStringPropertyAsJSON( singleResult, BODY_KEY, Response.NON_JSON_RESPONSE_PROPERTY); if (body != null && body instanceof JSONObject) { JSONObject jsonBody = (JSONObject) body; // Does this response represent an error from the service? We might get either an "error" // with several sub-properties, or else one or more top-level fields containing error // info. String errorType = null; String errorMessage = null; int errorCode = INVALID_ERROR_CODE; int errorSubCode = INVALID_ERROR_CODE; boolean hasError = false; if (jsonBody.has(ERROR_KEY)) { // We assume the error object is correctly formatted. JSONObject error = (JSONObject) Utility.getStringPropertyAsJSON(jsonBody, ERROR_KEY, null); errorType = error.optString(ERROR_TYPE_FIELD_KEY, null); errorMessage = error.optString(ERROR_MESSAGE_FIELD_KEY, null); errorCode = error.optInt(ERROR_CODE_FIELD_KEY, INVALID_ERROR_CODE); errorSubCode = error.optInt(ERROR_SUB_CODE_KEY, INVALID_ERROR_CODE); hasError = true; } else if (jsonBody.has(ERROR_CODE_KEY) || jsonBody.has(ERROR_MSG_KEY) || jsonBody.has(ERROR_REASON_KEY)) { errorType = jsonBody.optString(ERROR_REASON_KEY, null); errorMessage = jsonBody.optString(ERROR_MSG_KEY, null); errorCode = jsonBody.optInt(ERROR_CODE_KEY, INVALID_ERROR_CODE); errorSubCode = jsonBody.optInt(ERROR_SUB_CODE_KEY, INVALID_ERROR_CODE); hasError = true; } if (hasError) { return new FacebookRequestError( responseCode, errorCode, errorSubCode, errorType, errorMessage, jsonBody, singleResult, batchResult, connection); } } // If we didn't get error details, but we did get a failure response code, report it. if (!HTTP_RANGE_SUCCESS.contains(responseCode)) { return new FacebookRequestError( responseCode, INVALID_ERROR_CODE, INVALID_ERROR_CODE, null, null, singleResult.has(BODY_KEY) ? (JSONObject) Utility.getStringPropertyAsJSON( singleResult, BODY_KEY, Response.NON_JSON_RESPONSE_PROPERTY) : null, singleResult, batchResult, connection); } } } catch (JSONException e) { // defer the throwing of a JSONException to the graph object proxy } return null; }
private FacebookRequestError( int requestStatusCode, int errorCode, int subErrorCode, String errorType, String errorMessage, JSONObject requestResultBody, JSONObject requestResult, Object batchRequestResult, HttpURLConnection connection, FacebookException exception) { this.requestStatusCode = requestStatusCode; this.errorCode = errorCode; this.subErrorCode = subErrorCode; this.errorType = errorType; this.errorMessage = errorMessage; this.requestResultBody = requestResultBody; this.requestResult = requestResult; this.batchRequestResult = batchRequestResult; this.connection = connection; boolean isLocalException = false; if (exception != null) { this.exception = exception; isLocalException = true; } else { this.exception = new FacebookServiceException(this, errorMessage); } // Initializes the error categories based on the documented error codes as outlined here // https://developers.facebook.com/docs/reference/api/errors/ Category errorCategory = null; int messageId = INVALID_MESSAGE_ID; boolean shouldNotify = false; if (isLocalException) { errorCategory = Category.CLIENT; messageId = INVALID_MESSAGE_ID; } else { if (errorCode == EC_UNKNOWN_ERROR || errorCode == EC_SERVICE_UNAVAILABLE) { errorCategory = Category.SERVER; } else if (errorCode == EC_APP_TOO_MANY_CALLS || errorCode == EC_USER_TOO_MANY_CALLS) { errorCategory = Category.THROTTLING; } else if (errorCode == EC_PERMISSION_DENIED || EC_RANGE_PERMISSION.contains(errorCode)) { errorCategory = Category.PERMISSION; // *************** APPCELERATOR TITANIUM CUSTOMIZATION *************************** // messageId = R.string.com_facebook_requesterror_permissions; messageId = Utility.resId_requestErrorPermissions; } else if (errorCode == EC_INVALID_SESSION || errorCode == EC_INVALID_TOKEN) { if (subErrorCode == EC_USER_CHECKPOINTED || subErrorCode == EC_UNCONFIRMED_USER) { errorCategory = Category.AUTHENTICATION_RETRY; // messageId = R.string.com_facebook_requesterror_web_login; messageId = Utility.resId_requestErrorWebLogin; shouldNotify = true; } else { errorCategory = Category.AUTHENTICATION_REOPEN_SESSION; if (subErrorCode == EC_APP_NOT_INSTALLED) { // messageId = R.string.com_facebook_requesterror_relogin; messageId = Utility.resId_requestErrorRelogin; } else if (subErrorCode == EC_PASSWORD_CHANGED) { // messageId = R.string.com_facebook_requesterror_password_changed; messageId = Utility.resId_requestErrorPasswordChanged; } else { // messageId = R.string.com_facebook_requesterror_reconnect; messageId = Utility.resId_requestErrorReconnect; } } } if (errorCategory == null) { if (HTTP_RANGE_CLIENT_ERROR.contains(requestStatusCode)) { errorCategory = Category.BAD_REQUEST; } else if (HTTP_RANGE_SERVER_ERROR.contains(requestStatusCode)) { errorCategory = Category.SERVER; } else { errorCategory = Category.OTHER; } } } this.category = errorCategory; this.userActionMessageId = messageId; this.shouldNotifyUser = shouldNotify; }
@Test public void testMacIsNotContainedInRange() throws Exception { assertThat(rangeOf10Macs.contains(MAC_OUTSIDE_OF_RANGE), is(false)); }
@Test public void testMacIsContainedInRange() throws Exception { assertThat(rangeOf10Macs.contains(MAC_FROM_RANGE), is(true)); }