/** * Retrieves the expression from the specified arguments and peforms the * necessary evaluation steps. */ private boolean evaluateArguments(String[] names, String[] values, SSIMediator ssiMediator) throws SSIStopProcessingException { String expr = getExpression(names, values); if (expr == null) { throw new SSIStopProcessingException(); //throw new SsiCommandException( "No expression specified." ); } try { ExpressionParseTree tree = new ExpressionParseTree(expr, ssiMediator); return tree.evaluateTree(); } catch (ParseException e) { //throw new SsiCommandException( "Error parsing expression." ); throw new SSIStopProcessingException(); } }
protected Hashtable<Room, HashSet<TimeBlock>> readResponse(Document response) throws ParseException { SimpleDateFormat dateFormat = new SimpleDateFormat(response.getRootElement().attributeValue("dateFormat","MM/dd/yyyy"), Locale.US); SimpleDateFormat timeFormat = new SimpleDateFormat(response.getRootElement().attributeValue("timeFormat","h:mm a"), Locale.US); Hashtable<Room, HashSet<TimeBlock>> availability = new Hashtable<Room, HashSet<TimeBlock>>(); for (Iterator i=response.getRootElement().elementIterator("room");i.hasNext();) { Element roomElement = (Element)i.next(); Room room = new Room(roomElement); HashSet<TimeBlock> roomAvailability = availability.get(room); if (roomAvailability==null) { roomAvailability = new HashSet<TimeBlock>(); availability.put(room, roomAvailability); } for (Iterator j=roomElement.elementIterator("event");j.hasNext();) { Element eventElement = (Element)j.next(); EventTimeBlock event = new EventTimeBlock(eventElement, dateFormat, timeFormat); roomAvailability.add(event); } } return availability; }
@Test public void testIssue233() throws ParseException { // https://github.com/aws/aws-sdk-java/issues/233 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"); sdf.setTimeZone(new SimpleTimeZone(0, "GMT")); final String edgeCase = "292278994-08-17T07:12:55.807Z"; Date expected = sdf.parse(edgeCase); if (DEBUG) System.out.println("date: " + expected); String formatted = DateUtils.formatISO8601Date(expected); if (DEBUG) System.out.println("formatted: " + formatted); assertEquals(edgeCase, formatted); Date parsed = DateUtils.parseISO8601Date(edgeCase); if (DEBUG) System.out.println("parsed: " + parsed); assertEquals(expected, parsed); String reformatted = DateUtils.formatISO8601Date(parsed); assertEquals(edgeCase, reformatted); }
protected Timestamp getValueAsTimestamp(Object value) { if (isEmpty(value) || DataViewUtils.isSQLConstantString(value, null)) { return new Timestamp(System.currentTimeMillis()); } else if (value instanceof Timestamp) { return (Timestamp) value; } else if (value instanceof java.util.Date) { return new Timestamp(((java.util.Date) value).getTime()); } else if (value instanceof java.util.Calendar) { return new Timestamp(((java.util.Calendar) value).getTime().getTime()); } else if (value instanceof Long) { return new Timestamp((Long) value); } else if (value instanceof String) { try { return new Timestamp(dateFormat.parse((String) value).getTime()); } catch (ParseException e) { //mLogger.log(Level.SEVERE, e.getMessage(), e.getMessage()); } } return new Timestamp(System.currentTimeMillis()); }
/** {@inheritDoc} */ @Override protected void doExecute(@Nonnull final ProfileRequestContext profileRequestContext) { try { if (idTokenHint != null && idTokenHint.getJWTClaimsSet() != null) { log.debug("{} Using requested sub claim value", getLogPrefix()); getOidcResponseContext().setRequestedSubject(idTokenHint.getJWTClaimsSet().getSubject()); } } catch (ParseException e) { log.error("{} error parsing id token hint", getLogPrefix(), e); ActionSupport.buildEvent(profileRequestContext, EventIds.INVALID_PROFILE_CTX); return; } if (idTokenClaims != null && !idTokenClaims.isEmpty()) { for (Entry entry : idTokenClaims) { if (IDTokenClaimsSet.SUB_CLAIM_NAME.equals(entry.getClaimName())) { log.debug("{} Setting requested sub claim value {} ", getLogPrefix(), entry.getValue()); getOidcResponseContext().setRequestedSubject(entry.getValue()); } } } }
/** * parses a date of the form yyyymmdd or yyyymmdd'T'hhMMss converting from * the given timezone to UTC. */ public static DateValue parseDateValue(String s, TimeZone tzid) throws ParseException { Matcher m = DATE_VALUE.matcher(s); if (!m.matches()) { throw new ParseException(s, 0); } int year = Integer.parseInt(m.group(1)), month = Integer.parseInt(m.group(2)), day = Integer.parseInt(m.group(3)); if (null != m.group(4)) { int hour = Integer.parseInt(m.group(4)), minute = Integer.parseInt(m.group(5)), second = Integer.parseInt(m.group(6)); boolean utc = null != m.group(7); DateValue dv = new DTBuilder( year, month, day, hour, minute, second).toDateTime(); if (!utc && null != tzid) { dv = TimeUtils.toUtc(dv, tzid); } return dv; } else { return new DTBuilder(year, month, day).toDate(); } }
/** * Return the value of the specified date header, if any; otherwise * return -1. * * @param name Name of the requested date header * * @exception IllegalArgumentException if the specified header value * cannot be converted to a date */ public long getDateHeader(String name) { String value = getHeader(name); if (value == null) return (-1L); // Work around a bug in SimpleDateFormat in pre-JDK1.2b4 // (Bug Parade bug #4106807) value += " "; // Attempt to convert the date header in a variety of formats for (int i = 0; i < formats.length; i++) { try { Date date = formats[i].parse(value); return (date.getTime()); } catch (ParseException e) { ; } } throw new IllegalArgumentException(value); }
Date ParseUTCDate(String s) throws ParseException { if (m_pISODate == null) { m_pISODate = Pattern.compile("(\\d+)-(\\d+)-(\\d+)T? ?(\\d+):(\\d+):(\\d+\\.?\\d*)Z?", Pattern.CASE_INSENSITIVE); } Matcher m = m_pISODate.matcher(s); if (m.matches()) { int year = Integer.parseInt(m.group(1)); int month = Integer.parseInt(m.group(2)); int day = Integer.parseInt(m.group(3)); int hour = Integer.parseInt(m.group(4)); int minute = Integer.parseInt(m.group(5)); double second = Double.parseDouble(m.group(6)); GregorianCalendar gc = UTCDate.UTCCalendar(); gc.set(year, month - 1, day, hour, minute, (int) second); return gc.getTime(); } return new Date(); }
@Test public void testOrderOfMainACIComponentsDoesNotMatterButMissingsMatter() throws Exception { String spec = "{ itemOrUserFirst userFirst: { userClasses { allUsers , name { \"ou=people,cn=ersin\" }, " + "subtree {{ base \"ou=system\" }, { base \"ou=ORGANIZATIONUNIT\"," + "minimum 1, maximum 2 } } } , " + "userPermissions { { protectedItems{ entry , attributeType { cn , ou } , attributeValue {x=y,m=n,k=l} , " + "rangeOfValues (cn=ErsinEr) } , grantsAndDenials { grantBrowse } } } }, " + " identificationTag \"id2\" , precedence 14 } "; try { parser.parse( spec ); fail( "testOrderOfMainACIComponentsDoesNotMatterButMissingsMatter() should not have run this line." ); } catch ( ParseException e ) { assertNotNull( e ); } }
public Object getValue(User user, Map context) { if (type.equals(STRING)) { return value; } else if (type.equals(INTEGER)) { return new Integer(value); } else if (type.equals(FLOAT)) { return new Float(value); } else if (type.equals(BOOLEAN)) { return new Boolean(value); } else if (type.equals(DATETIME)) { SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm"); try { return format.parse(value); } catch (ParseException e) { log.error( "", e ); throw new RalasafeException(e); } } else { String msg="Not supported value type '" + type + "'."; log.error( msg ); throw new RalasafeException(msg); } }
public static Date formatDate(String csDate, String csFormat, boolean strict) { Date date = null; if (csDate != null && csFormat != null && csFormat.length() > 0) { try { SimpleDateFormat formatter = new SimpleDateFormat(csFormat); formatter.setLenient(false); date = formatter.parse(csDate); if (strict) { if (csFormat.length() != csDate.length()) { date = null; } } } catch (ParseException e) { } } return date; }
public void applyParamSchema( String rule, String name, String value, IcalObject out) throws ParseException { // all elements are allowed extension parameters if (EXTENSION_PARAM_NAME_RE.matcher(name).find()) { out.getExtParams().put(name, value); return; } // if not an extension, apply the rule ruleStack.add(rule); try { (paramRules.get(rule)).apply(this, name, value, out); } finally { ruleStack.remove(ruleStack.get(ruleStack.size() - 1)); } }
@NotNull @Override public Date getStartedTime() { final PodStatus podStatus = myApiConnector.getPodStatus(myPod.getMetadata().getName()); if(podStatus == null) return myCreationTime; try { final List<PodCondition> podConditions = podStatus.getConditions(); if (podConditions != null && !podConditions.isEmpty()) { for (PodCondition podCondition : podConditions) { if (PodConditionType.valueOf(podCondition.getType()) == PodConditionType.Ready) return myPodTransitionTimeFormat.parse(podCondition.getLastTransitionTime()); } } String startTime = podStatus.getStartTime(); return !StringUtil.isEmpty(startTime) ? myPodStartTimeFormat.parse(startTime) : myCreationTime; } catch (ParseException e) { throw new KubeCloudException("Failed to get instance start date", e); } }
/** * Parse attribute's options : * * options = *( ';' option ) * option = 1*keychar * keychar = 'a'-z' | 'A'-'Z' / '0'-'9' / '-' */ private static void parseOptions( char[] str, Position pos ) throws ParseException { while ( Strings.isCharASCII( str, pos.start, ';' ) ) { pos.start++; // We have an option if ( !Chars.isAlphaDigitMinus( str, pos.start ) ) { // We must have at least one keychar throw new ParseException( I18n.err( I18n.ERR_04343 ), pos.start ); } pos.start++; while ( Chars.isAlphaDigitMinus( str, pos.start ) ) { pos.start++; } } }
/** * Returns a UNIX timestamp of time specified * @param year Year * @param month Month * @param day Day * @param hour Hour * @param minute Minute * @param timeZone Timezone; e.g. "UTC-5:00" * @return Time in UNIX timestamp */ public static long unixTimestamp(int year, int month, int day, int hour, int minute, String timeZone) { long timeNumber = (year * 100000000L) + (month * 1000000) + (day * 10000) + (hour * 100) + (minute); String timeString = Long.toString(timeNumber); long unixTime = 0L; dateFormat.setTimeZone(TimeZone.getTimeZone(timeZone)); try { unixTime = dateFormat.parse(timeString).getTime(); unixTime /= 1000L; } catch(ParseException pe) { pe.printStackTrace(); } return unixTime; }
public static long durationFromNowtoB(String B) { //need format of B is yyyy-MM-dd HH:mm:ss long diff=0; DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); try { Date nowDate=new Date(); Date endDate=df.parse(B); diff = endDate.getTime() - nowDate.getTime();//这样得到的差值是微秒级别 } catch(ParseException e) { e.printStackTrace(); } return diff; }
boolean needUpdateWeather() { int frequency = Integer.parseInt(settingPref.getString("update_frequency", "2")); String lastWeatherUpdate = sharedPref.getString("update_datetime", ""); if (!lastWeatherUpdate.equals("")) { try { Date lastUpdateDate = df_ymd_hms.parse(lastWeatherUpdate); return new Date().getTime() - lastUpdateDate.getTime() > frequency * 60 * 60 * 1000; } catch (ParseException e) { e.printStackTrace(); return false; } } else { return true; } }
@Test public void testInvalidEditIssue() throws InterruptedException, ParseException { Issue editedIssue = setUpEditedIssue(); JsonObject edited = mGson.toJsonTree(editedIssue).getAsJsonObject(); MockResponse mockResponse = new MockResponse() .setResponseCode(HttpURLConnection.HTTP_BAD_REQUEST); mMockWebServer.enqueue(mockResponse); IssueSimpleCallback mockCallback = mock(IssueSimpleCallback.class); UserAdapter.setCurrentUser(mUser); mIssueAdapter.editIssue("issue-auth-token", edited, mockCallback); // Test mockCallback.onFailure() is called verify(mockCallback, timeout(1000)).onFailure(); }
/** * Set the method. * * @param method is the method to set. * @throws IllegalArgumentException if the method is null */ public void setMethod(String method) { if (method == null) throw new IllegalArgumentException("null method"); if (this.requestLine == null) { this.requestLine = new RequestLine(); } // Set to standard constants to speed up processing. // this makes equals compares run much faster in the // stack because then it is just identity comparision String meth = getCannonicalName(method); this.requestLine.setMethod(meth); if (this.cSeqHeader != null) { try { this.cSeqHeader.setMethod(meth); } catch (ParseException e) { } } }
public static String formatTime(String time, String format) { if (!(TextUtils.isEmpty(time) || TextUtils.isEmpty(format))) { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); try { time = new SimpleDateFormat(format).format(sdf.parse(time)); } catch (ParseException e) { e.printStackTrace(); } finally { } } return time; }
@Test public void testInvoiceBillpayPayment() throws ParseException, PaymentException { Payment response = mpay24.payment(getTestPaymentRequest("666", 100l), getInvoiceBillpayTestData(), getCustomer()); assertEquals("REDIRECT", response.getReturnCode()); assertNotNull(response.getmPayTid()); }
/** * 判断二个日期相隔的天数,结束时间为null时,,取当前时间 * * @param startDate * 开始时间 * @param endDate * 结束时间 * @return */ public static int getBetweenTodaysStartDateAndEndDate(Date startDate, Date endDate) { int betweentoday = 0; if (startDate == null) { return betweentoday; } if (endDate == null) { Calendar calendar = Calendar.getInstance(); String year = new Integer(calendar.get(Calendar.YEAR)).toString(); String month = new Integer((calendar.get(Calendar.MONTH) + 1)).toString(); String day = new Integer(calendar.get(Calendar.DAY_OF_MONTH)).toString(); String strtodaytime = year + "-" + month + "-" + day; DateFormat formatter = new SimpleDateFormat("yyyy-MM-dd"); try { endDate = formatter.parse(strtodaytime); } catch (ParseException e) { // TODO Auto-generated catch block e.printStackTrace(); } } if (endDate.after(startDate)) { betweentoday = (int) ((endDate.getTime() - startDate.getTime()) / 86400000); } else { betweentoday = (int) ((startDate.getTime() - endDate.getTime()) / 86400000); } return betweentoday; }
public static String getFormatTime(String time){ DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"); long diff = 0; try { Date publish_date = df.parse(time); Date now_date = new Date(); diff = now_date.getTime() - publish_date.getTime(); if (diff < 0) { return "来自虫洞"; } else { diff /= (1000 * 60); if (diff <= 60) { return diff + "分钟前"; } diff /= 60; if (diff <= 24) { return diff + "小时前"; } diff /= 24; if (diff < 30) { if (diff == 1) return "昨天"; return diff + "天前"; } DateFormat df_date = new SimpleDateFormat("yyyy-MM-dd"); return df_date.format(publish_date); } } catch (ParseException e) { e.printStackTrace(); } return time; }
@Override public void onDateSet(DatePickerDialog view, int year, int monthOfYear, int dayOfMonth) { try { presenter.requestBirthday(new SimpleDateFormat("yyyy-MM-dd").parse(year + "-" + (monthOfYear + 1) + "-" + dayOfMonth)); } catch (ParseException e) { e.printStackTrace(); } }
@Test public void testWeeksBetween() throws ParseException { SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy-MM-dd"); Date startDate = simpleDateFormat.parse("2017-06-01"); Date endDate = simpleDateFormat.parse("2017-06-18"); assertEquals(2, DaysBetweenUtil.weeksBetween(startDate, endDate)); }
public static long str2Date(String str) { SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.SIMPLIFIED_CHINESE); Date parse = null; try { parse = format.parse(str); } catch (ParseException e) { log.error("parse error", e); return 0; } return parse.getTime(); }
public void setIntegrityProtected(String integrityProtected) throws ParseException { if (integrityProtected == null) throw new NullPointerException( "JAIN-SIP Exception, " + " AuthenticationHeader, setIntegrityProtected(), The integrity-protected parameter is null"); setParameter(INTEGRITY_PROTECTED, integrityProtected); }
public Randevular(String rA,String rT,String rY,String tarihAyraci) { randevuAdi=new String(rA); try { randevuTarihi=new SimpleDateFormat("dd"+tarihAyraci+"MM"+tarihAyraci+"yyyy").parse(rT); } catch (ParseException e) { e.printStackTrace(); } randevuYeri=new String(rY); }
/** * Creates an extract result * * @param time time of data point * @param value value of data point * @param metric name of data point * @return Null if either time or value could not be parsed */ private Transmutation createResult(String time, String value, String metric, String endpointId) { try { ZonedDateTime parsedTime = parseUTCTime(time); Number parsedNumber = parseNumber(value); return ImmutableTransmutation.of(parsedTime, metric, parsedNumber, parsedNumber, ImmutableTransmutation.Metadata.builder().build()); } catch (DateTimeParseException |ParseException e) { logger.warn("No data for {}, endpoint {}; invalid time or value: {}", metric, endpointId, e.getMessage()); noData(); return null; } }
/** * 将时间字符串转为时间戳 * <p>time格式为format</p> * * @param time 时间字符串 * @param format 时间格式 * @return 毫秒时间戳 */ public static long string2Millis(String time, DateFormat format) { try { return format.parse(time).getTime(); } catch (ParseException e) { e.printStackTrace(); } return -1; }
/** * Tests fraction of a minute. */ @Test public void testFractionOfMinute2() throws ParseException { String gt = "200801021213,125Z"; GeneralizedTime generalizedTime = new GeneralizedTime( gt ); String result = generalizedTime.toGeneralizedTime(); assertEquals( gt, result ); assertEquals( 7, generalizedTime.getCalendar().get( Calendar.SECOND ) ); assertEquals( 500, generalizedTime.getCalendar().get( Calendar.MILLISECOND ) ); }
public Date getTime() { try { return dateFormatter.parse(content.getProperty(ERROR_TIME)); } catch (ParseException e) { log.warn("Can not parse error time", e); return new Date(); } }
private static String getPreWeekDay(String dateStr) { getPreWeekDay(dateStr); Date date = null; try { date = yyyyMMdd.parse(dateStr); } catch (ParseException e) { e.printStackTrace(); } return ""; }
/** * 将时间字符串转为时间戳 * <p>time格式为pattern</p> * * @param time 时间字符串 * @param pattern 时间格式 * @return 毫秒时间戳 */ public static long string2Millis(String time, String pattern) { try { return new SimpleDateFormat(pattern, Locale.getDefault()).parse(time).getTime(); } catch (ParseException e) { e.printStackTrace(); } return -1; }
public static Date getDateFromFormatString(String formatDate) { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); try { return sdf.parse(formatDate); } catch (ParseException e) { e.printStackTrace(); } return null; }
private static Date parseDate (String strDate) { Date date = null; if (strDate != null) { for (DateFormat fd : dateFormats) { try { date = fd.parse(strDate); } catch (ParseException ex) { } } } return date; }
@Override public void success(Result<List<Tweet>> result) { Log.d(TAG, "Importing Twitter"); try { for (Tweet tweet : result.data) { TwitterPost post = new TwitterPost(uid, getDateFromTweet(tweet), tweet.id); mDatabase.getReference("/posts").child(uid).child("tweets").push().setValue(post); } mDatabase.getReference("/users").child(uid).child("twitter_onboarding").setValue(true); } catch (ParseException e) { Toast.makeText(getApplicationContext(), "Something went wrong with importing your existing posts", Toast.LENGTH_SHORT).show(); Log.w(TAG, e); } }
public String next(String regexp) throws ParseException { trim(); Pattern p = Pattern.compile(regexp); Matcher m = p.matcher(s); if(m.lookingAt()) { String r = m.group(); s = s.substring(r.length()); trim(); return r; } else throw error(); }
@Test public void testDaysBetween() throws ParseException { SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy-MM-dd"); Date startDate = simpleDateFormat.parse("2017-06-01"); Date endDate = simpleDateFormat.parse("2017-06-05"); assertEquals(4, DaysBetweenUtil.daysBetween(startDate, endDate)); }
private double diff(String failedEndTS, String failedStartTS) { try { SimpleDateFormat format = new SimpleDateFormat(CmsConstants.SEARCH_TS_PATTERN); return (format.parse(failedEndTS).getTime() - format.parse(failedStartTS).getTime()) / 1000.0; } catch (ParseException ignore) { return 0; } }