Java Code Examples for java.util.GregorianCalendar

/** 
 * New xml gregorian calendar.
 * @param millis the millis
 * @return the xML gregorian calendar
 */
protected XMLGregorianCalendar newXMLGregorianCalendar(long millis){
  try {
    DatatypeFactory datatypeFactory=DatatypeFactory.newInstance();
    GregorianCalendar cal=new GregorianCalendar();
    return datatypeFactory.newXMLGregorianCalendar(cal);
  }
 catch (  DatatypeConfigurationException e) {
    logger.error(e);
    return null;
  }
}
 

static void putTransitionMillisIntoSystemTime(byte[] bytes,int offset,long millis){
  GregorianCalendar cal=new GregorianCalendar(TimeZone.getDefault());
  cal.setTimeInMillis(millis + 30 * SECONDS);
  setWord(bytes,offset + MSFT_SYSTEMTIME_MONTH,cal.get(Calendar.MONTH) + 1);
  setWord(bytes,offset + MSFT_SYSTEMTIME_DAY_OF_WEEK,cal.get(Calendar.DAY_OF_WEEK) - 1);
  int wom=cal.get(Calendar.DAY_OF_WEEK_IN_MONTH);
  setWord(bytes,offset + MSFT_SYSTEMTIME_DAY,wom < 0 ? 5 : wom);
  setWord(bytes,offset + MSFT_SYSTEMTIME_HOUR,getTrueTransitionHour(cal));
  setWord(bytes,offset + MSFT_SYSTEMTIME_MINUTE,getTrueTransitionMinute(cal));
}
 

/** 
 * This method allows to obtain an <a href="http://www.w3.org/TR/xmlschema-2/#date">XML Schema</a> compliant date providing a textual representation of a date and textual a pattern for parsing it.
 * @param dateToBeParsed the String containing the date.
 * @param format the pattern as descibed in {@link java.text.SimpleDateFormat}
 * @return a {@link String} representing the date
 * @throws java.text.ParseException
 * @throws javax.xml.datatype.DatatypeConfigurationException
 */
public static String getXSDDate(String dateToBeParsed,String format) throws ParseException, DatatypeConfigurationException {
  SimpleDateFormat simpleDateFormat=new SimpleDateFormat(format);
  Date date=simpleDateFormat.parse(dateToBeParsed);
  GregorianCalendar gc=new GregorianCalendar();
  gc.setTime(date);
  XMLGregorianCalendar xml=DatatypeFactory.newInstance().newXMLGregorianCalendar(gc);
  xml.setTimezone(0);
  return xml.toString();
}
 

private static long getNumDaysBetween(GregorianCalendar first,GregorianCalendar second){
  GregorianCalendar tmp=new GregorianCalendar();
  tmp.setTime(first.getTime());
  long numDays=(second.getTimeInMillis() - first.getTimeInMillis()) / 1000 / 86400;
  tmp.add(Calendar.DAY_OF_MONTH,(int)numDays);
  while (tmp.before(second)) {
    tmp.add(Calendar.DAY_OF_MONTH,1);
    ++numDays;
  }
  return numDays;
}
 

/** 
 * there is nothing more annoying than Java date/time APIs!
 * @param year
 * @param month
 * @param day
 * @return
 */
public long getTime(int year,int month,int day){
  GregorianCalendar calendar=new GregorianCalendar();
  calendar.set(Calendar.YEAR,year);
  calendar.set(Calendar.MONTH,month - 1);
  calendar.set(Calendar.DATE,day);
  calendar.set(Calendar.HOUR,0);
  calendar.set(Calendar.MINUTE,0);
  calendar.set(Calendar.SECOND,0);
  calendar.set(Calendar.MILLISECOND,0);
  return calendar.getTime().getTime();
}
 

public String format(String pid) throws LowlevelStorageException {
  GregorianCalendar calendar=new GregorianCalendar();
  String year=Integer.toString(calendar.get(Calendar.YEAR));
  String month=leftPadded(1 + calendar.get(Calendar.MONTH),2);
  String dayOfMonth=leftPadded(calendar.get(Calendar.DAY_OF_MONTH),2);
  String hourOfDay=leftPadded(calendar.get(Calendar.HOUR_OF_DAY),2);
  String minute=leftPadded(calendar.get(Calendar.MINUTE),2);
  return storeBase + SEP + year+ SEP+ month+ dayOfMonth+ SEP+ hourOfDay+ SEP+ minute+ SEP+ pid;
}
 

/** 
 * @return Adds the given number of days to the given date and return acopy.
 */
public static Date addDays(final Date date,final int days){
  final GregorianCalendar gc=new GregorianCalendar();
  gc.setTime(date);
  gc.add(Calendar.DAY_OF_MONTH,days);
  return gc.getTime();
}
 

/** 
 * <p> Get a list of all users so we can figure out which user can access which repository </p> <p> Note that we cache for 30 seconds. </p>
 * @param db Database connection
 * @return List of all users
 * @throws ChiliLogException
 */
private static synchronized UserBO[] getAllUsers(DB db) throws ChiliLogException {
  if (_userListCache == null || _userListCacheExpiry.before(new Date())) {
    UserListCriteria criteria=new UserListCriteria();
    ArrayList<UserBO> list=UserController.getInstance().getList(db,criteria);
    _userListCache=list.toArray(new UserBO[]{});
    GregorianCalendar cal=new GregorianCalendar();
    cal.add(Calendar.SECOND,10);
    _userListCacheExpiry=cal.getTime();
  }
  return _userListCache;
}
 

/** 
 */
@Test public void convertsDatesToXmlGregorianCalendars() throws Exception {
  final Date date=new Date();
  final XMLGregorianCalendar result=DateToXMLGregorianCalendarTypeConverter.converter().convert(date,XMLGregorianCalendar.class);
  GregorianCalendar calendar=new GregorianCalendar();
  calendar.setTime(date);
  assertEquals(calendar.get(Calendar.YEAR),result.getYear());
  assertEquals(calendar.get(Calendar.DAY_OF_MONTH),result.getDay());
  assertEquals(calendar.get(Calendar.MONTH) + 1,result.getMonth());
}
 

private GregorianCalendar startInOneSecond(final Trigger schedTrigger){
  GregorianCalendar gc=getOneSecondLater();
  final Date startTime=new Date(gc.getTimeInMillis());
  schedTrigger.setStartTime(startTime);
  return gc;
}
 

@Override public void onCreate(Bundle savedInstanceState){
  super.onCreate(savedInstanceState);
  setContentView(R.layout.main);
  CheckBox cb=(CheckBox)findViewById(R.id.showCalendar);
  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
    cb.setOnCheckedChangeListener(this);
  }
 else {
    cb.setVisibility(View.GONE);
  }
  GregorianCalendar now=new GregorianCalendar();
  picker=(DatePicker)findViewById(R.id.picker);
  picker.init(now.get(Calendar.YEAR),now.get(Calendar.MONTH),now.get(Calendar.DAY_OF_MONTH),this);
}
 

public static synchronized String toXMLFormat(java.util.Date start){
  try {
    GregorianCalendar gCal=(GregorianCalendar)GregorianCalendar.getInstance();
    gCal.setTime(start);
    XMLGregorianCalendar cal=DatatypeFactory.newInstance().newXMLGregorianCalendar(gCal);
    return cal.toXMLFormat();
  }
 catch (  DatatypeConfigurationException ex) {
    throw new RuntimeException(ex);
  }
}
 

@Test public void testXmlGregorianCalendar(){
  XMLGregorianCalendar xmlCalendar=mock(XMLGregorianCalendar.class);
  GregorianCalendar expected=new GregorianCalendar();
  when(xmlCalendar.toGregorianCalendar()).thenReturn(expected);
  Date date=new Date(expected.getTimeInMillis());
  assertEquals(date,converter.convert(Date.class,xmlCalendar));
}
 

public void execute(DTState state) throws RulesException {
  GregorianCalendar calendar=new GregorianCalendar();
  calendar.setTime(state.datapop().timeValue());
  if (calendar.isLeapYear(calendar.get(Calendar.YEAR))) {
    state.datapush(RInteger.getRIntegerValue(366));
  }
 else {
    state.datapush(RInteger.getRIntegerValue(365));
  }
}
 

/** 
 * convert Date to XMLGregorianCalendar.
 * @param date the date
 * @return the xML gregorian calendar
 */
public static XMLGregorianCalendar convertDate(Date date){
  if (date == null) {
    return null;
  }
  GregorianCalendar gc=new GregorianCalendar();
  gc.setTimeInMillis(date.getTime());
  try {
    return DatatypeFactory.newInstance().newXMLGregorianCalendar(gc);
  }
 catch (  DatatypeConfigurationException ex) {
    return null;
  }
}
 

public static long date2Long(Date time){
  GregorianCalendar gc=new GregorianCalendar();
  gc.setTime(time);
  int month=gc.get(Calendar.MONTH) + 1;
  int day=gc.get(Calendar.DAY_OF_MONTH);
  int year=gc.get(Calendar.YEAR);
  return (long)(day + (month * MONTH_OFFSET) + (year * YEAR_OFFSET));
}
 

public List<KickstartWorkflowInfo> findWorkflowInformation(boolean includeCounts){
  if (includeCounts) {
    throw new UnsupportedOperationException();
  }
  Session cmisSession=getCmisSession();
  Folder workflowDefinitionFolder=(Folder)cmisSession.getObjectByPath(WORKFLOW_DEFINITION_FOLDER);
  String query="select t.cm:description, d." + PropertyIds.NAME + ", d."+ PropertyIds.CREATION_DATE+ " from cmis:document as d join cm:titled as t on d.cmis:objectId = t.cmis:objectId where in_folder(d, '"+ workflowDefinitionFolder.getId()+ "') and d.cmis:name LIKE '%.bpmn20.xml' order by d.cmis:name";
  LOGGER.info("Executing CMIS query '" + query + "'");
  ItemIterable<QueryResult> results=cmisSession.query(query,false);
  ArrayList<KickstartWorkflowInfo> workflowInfos=new ArrayList<KickstartWorkflowInfo>();
  for (  QueryResult result : results) {
    KickstartWorkflowInfo kickstartWorkflowInfo=new KickstartWorkflowInfo();
    kickstartWorkflowInfo.setName((String)result.getPropertyValueById("cm:description"));
    kickstartWorkflowInfo.setId(processNameToBaseName((String)result.getPropertyValueById(PropertyIds.NAME)));
    GregorianCalendar createDate=result.getPropertyValueById(PropertyIds.CREATION_DATE);
    kickstartWorkflowInfo.setCreateTime(createDate.getTime());
    workflowInfos.add(kickstartWorkflowInfo);
  }
  return workflowInfos;
}
 

@Test public void testDateWithNotes(){
  final Date oldXmlDate=new GregorianCalendar(2010,11 - 1,12).getTime();
  final DateWithNotes dwn=JAXBConvertor.dateWithNotes(oldXmlDate);
  final XMLGregorianCalendar cal=JAXBConvertor.dateToXml(oldXmlDate);
  final DateWithNotes dwn2=new DateWithNotes();
  dwn2.setNotes(new Notes());
  dwn2.setValue(cal);
  assertEquals(dwn,dwn2);
}
 

public DateValueDefn(Date date){
  if (date == null) {
    this.year=null;
    this.month=null;
    this.dayOfMonth=null;
    this.hourOfDay=null;
    this.minute=null;
    this.second=null;
  }
 else {
    GregorianCalendar dateValue=new GregorianCalendar();
    dateValue.setTime(date);
    this.year=dateValue.get(Calendar.YEAR);
    this.month=dateValue.get(Calendar.MONTH) + 1;
    this.dayOfMonth=dateValue.get(Calendar.DAY_OF_MONTH);
    this.hourOfDay=dateValue.get(Calendar.HOUR_OF_DAY);
    this.minute=dateValue.get(Calendar.MINUTE);
    this.second=dateValue.get(Calendar.SECOND);
  }
}
 

@Test public void parse() throws Exception {
  final RSSFeed feed=parse(stream);
  assertEquals("Example Channel",feed.getTitle());
  assertEquals(Uri.parse("http://example.com/"),feed.getLink());
  assertEquals("My example channel",feed.getDescription());
  final Iterator<RSSItem> items=feed.getItems().iterator();
  RSSItem item;
  item=items.next();
  assertEquals("News for November",item.getTitle());
  assertEquals(Uri.parse("http://example.com/2010/11/07"),item.getLink());
  assertEquals("Other things happened today",item.getDescription());
  assertTrue(item.getCategories().isEmpty());
  GregorianCalendar calendar=new GregorianCalendar(2010,10,07,8,22,14);
  calendar.setTimeZone(TimeZone.getTimeZone("Etc/GMT"));
  Date expectedDate=calendar.getTime();
  assertEquals(expectedDate,item.getPubDate());
  assertEquals(2,item.getThumbnails().size());
  MediaThumbnail expectedThumbnail0=new MediaThumbnail(Uri.parse("http://example.com/media/images/12/jpg/_7_2.jpg"),49,66);
  assertEquals(expectedThumbnail0.getUrl(),item.getThumbnails().get(0).getUrl());
  assertEquals(expectedThumbnail0.getHeight(),item.getThumbnails().get(0).getHeight());
  assertEquals(expectedThumbnail0.getWidth(),item.getThumbnails().get(0).getWidth());
  MediaThumbnail expectedThumbnail1=new MediaThumbnail(Uri.parse("http://example.com/media/images/12/jpg/_7_2-1.jpg"),81,144);
  assertEquals(expectedThumbnail1.getUrl(),item.getThumbnails().get(1).getUrl());
  assertEquals(expectedThumbnail1.getHeight(),item.getThumbnails().get(1).getHeight());
  assertEquals(expectedThumbnail1.getWidth(),item.getThumbnails().get(1).getWidth());
  item=items.next();
  assertEquals("News for October",item.getTitle());
  assertEquals(Uri.parse("http://example.com/2010/10/12"),item.getLink());
  assertEquals("October days: we&#8217;re, <b>apple</b> ##<i>pie</i>",item.getDescription());
  assertEquals("October days: we&#8217;re, <b>apple</b> ##<i>pie</i>",item.getContent());
  assertEquals(2,item.getCategories().size());
  assertTrue(item.getCategories().contains("Daily news"));
  assertTrue(item.getCategories().contains("October news"));
  assertEquals(0,item.getThumbnails().size());
  assertFalse(items.hasNext());
}
 

/** 
 * Convenience method for making Dates. Because Date is a tricksy bugger of a class.
 * @param year
 * @param month
 * @param day
 * @return date object
 */
public static Date getDate(int year,String month,int day){
  try {
    Field field=GregorianCalendar.class.getField(month.toUpperCase());
    int m=field.getInt(null);
    Calendar date=new GregorianCalendar(year,m,day);
    return date.getTime();
  }
 catch (  Exception x) {
    throw new IllegalArgumentException(x.getMessage());
  }
}
 

@Override public GregorianCalendar deserialize(JsonElement json,Type typeOfT,JsonDeserializationContext context) throws JsonParseException {
  JsonObject obj=json.getAsJsonObject();
  int year=obj.get(YEAR).getAsInt();
  int month=obj.get(MONTH).getAsInt();
  int dayOfMonth=obj.get(DAY_OF_MONTH).getAsInt();
  int hourOfDay=obj.get(HOUR_OF_DAY).getAsInt();
  int minute=obj.get(MINUTE).getAsInt();
  int second=obj.get(SECOND).getAsInt();
  return new GregorianCalendar(year,month,dayOfMonth,hourOfDay,minute,second);
}
 

public DateIndexer(Context context,Cursor cursor,int sortedColumnIndex){
  mCursor=cursor;
  mColumnIndex=sortedColumnIndex;
  mIntFormat=new SimpleDateFormat("yyyyDDD");
  GregorianCalendar calendar=new GregorianCalendar();
  mCursor.moveToFirst();
  long firstDateLong=mCursor.getLong(mColumnIndex);
  mCursor.moveToLast();
  long lastDateLong=mCursor.getLong(mColumnIndex);
  Calendar startDate=Calendar.getInstance();
  startDate.setTimeInMillis(lastDateLong);
  Calendar endDate=Calendar.getInstance();
  endDate.setTimeInMillis(firstDateLong);
  mSectionCount=daysBetween(startDate,endDate);
  mSections=new String[mSectionCount];
  mSectionDates=new int[mSectionCount];
  mSectionPositions=new int[mSectionCount];
  calendar.setTimeInMillis(firstDateLong);
  for (int i=0; i < mSectionCount; i++) {
    mSections[i]=Util.formatDate(context,calendar.getTimeInMillis());
    mSectionDates[i]=Integer.parseInt(mIntFormat.format(calendar.getTime()));
    mSectionPositions[i]=-1;
    calendar.add(GregorianCalendar.DATE,-1);
  }
}
 

public void setRollOver(String str) throws ParseException {
  Date d=dateParser.parse(str);
  rollOver=new GregorianCalendar();
  rollOver.setTime(d);
  rollOver.setLenient(true);
}
 

@Override protected Object formBackingObject(HttpServletRequest request){
  Page page=(Page)super.formBackingObject(request);
  if (page.getVisibleTo() == null) {
    Calendar cal=new GregorianCalendar();
    cal.add(GregorianCalendar.YEAR,1000);
    page.setVisibleTo(cal);
  }
  if (page.getVisibleFrom() == null) {
    page.setVisibleFrom(new GregorianCalendar());
  }
  return page;
}
 

/** 
 * @param corpusDir
 * @param charset
 * @param from start date (inclusive)
 * @param to end date (exclusive)
 */
public CrawlCorpusAccessor(String corpusDir,String charset,Date from,Date to,boolean oneSentPerLine){
  super(oneSentPerLine);
  if (from == null || to == null || from.after(to)) {
    throw new IllegalArgumentException("Dates missing / bad");
  }
  (m_fromDate=new GregorianCalendar()).setTime(from);
  (m_toDate=new GregorianCalendar()).setTime(to);
  resetDays();
  resetFiles();
  m_encoding=charset;
  m_files=new FileList(corpusDir);
}
 

public View getView(int position,View convertView,ViewGroup parent){
  ViewHolder holder;
  BCBUpdatesMessage message=getItem(position);
  if (convertView == null) {
    convertView=layoutInflaterService.inflate(listViewResource,null);
    holder=new ViewHolder();
    holder.text1=(TextView)convertView.findViewById(android.R.id.text1);
    holder.text2=(TextView)convertView.findViewById(android.R.id.text2);
    convertView.setTag(holder);
  }
 else   holder=(ViewHolder)convertView.getTag();
  if (holder.text1 != null) {
    GregorianCalendar time=new GregorianCalendar();
    time.setTimeInMillis(Long.parseLong(message.getTimestamp()));
    holder.text1.setText(DateFormat.format("dd MMM yyyy, h:mmaa",time));
  }
  if (holder.text2 != null) {
    holder.text2.setText(message.getMessage());
  }
  return convertView;
}
 

@Deprecated public static Date[] generateDaysBetweenDates(Date startDate,Date endDate){
  GregorianCalendar startDateCalendar=new GregorianCalendar(startDate.getYear() + 1900,startDate.getMonth(),startDate.getDate());
  GregorianCalendar endDateCalendar=new GregorianCalendar(endDate.getYear() + 1900,endDate.getMonth(),endDate.getDate());
  if (startDateCalendar.getTimeInMillis() > endDateCalendar.getTimeInMillis())   return new Date[0];
  ArrayList workingDaysBetweenDates=new ArrayList();
  GregorianCalendar currentCalendarForDateThatWeAreCalculating=(GregorianCalendar)startDateCalendar.clone();
  final Date actualEndDateAccordingToCalendar=endDateCalendar.getTime();
  boolean shouldKeepGeneratingDaysBetweenDates=true;
  while (shouldKeepGeneratingDaysBetweenDates) {
    Date currentCalculatedDate=currentCalendarForDateThatWeAreCalculating.getTime();
    workingDaysBetweenDates.add(currentCalculatedDate);
    currentCalendarForDateThatWeAreCalculating.add(Calendar.DATE,1);
    if ((currentCalculatedDate.getYear() == actualEndDateAccordingToCalendar.getYear()) && (currentCalculatedDate.getMonth() == actualEndDateAccordingToCalendar.getMonth()) && (currentCalculatedDate.getDate() == actualEndDateAccordingToCalendar.getDate())) {
      shouldKeepGeneratingDaysBetweenDates=false;
    }
  }
  Date[] finalDaysBetweenDates=new Date[workingDaysBetweenDates.size()];
  return (Date[])workingDaysBetweenDates.toArray(finalDaysBetweenDates);
}
 

/** 
 * @param validFrom the validFrom to set
 */
public void setValidFrom(Date validFrom){
  if (validFrom != null) {
    Calendar cal=new GregorianCalendar();
    cal.setTime(validFrom);
    cal.add(Calendar.DAY_OF_MONTH,1);
    this.validFrom=cal.getTime();
  }
 else {
    this.validFrom=validFrom;
  }
}
 

public ResourceBuilder addProperty(URI theProperty,Date theValue){
  if (theValue != null) {
    GregorianCalendar c=new GregorianCalendar();
    c.setTime(theValue);
    try {
      return addProperty(theProperty,mGraph.getValueFactory().createLiteral(DatatypeFactory.newInstance().newXMLGregorianCalendar(c).toXMLFormat(),XMLSchema.DATE));
    }
 catch (    DatatypeConfigurationException e) {
      throw new IllegalArgumentException(e);
    }
  }
 else {
    return this;
  }
}
 

public static String getCurrentMinute(){
  Calendar calendar;
  calendar=new GregorianCalendar();
  String minute=Integer.toString(calendar.get(Calendar.MINUTE));
  return minute;
}
 

@Override public List<T> getResultList(){
  if (this.resultList == null) {
    Calendar handleStart=new GregorianCalendar();
    this.resultList=handleResultList(getQueryConfig());
    Calendar handleStop=new GregorianCalendar();
    resultTime=(handleStop.getTimeInMillis() - handleStart.getTimeInMillis());
  }
  if (this.resultList != null)   this.resultSize=this.resultList.size();
  return this.resultList;
}
 

private Date getStartOfToday(){
  Calendar today=new GregorianCalendar();
  today.set(Calendar.HOUR_OF_DAY,0);
  today.set(Calendar.MINUTE,0);
  today.set(Calendar.SECOND,0);
  today.set(Calendar.MILLISECOND,0);
  return today.getTime();
}
 

public static String getDateAndTimeWithShortFormat(boolean withYear,int year,int month,int day,int hour,int minute){
  SimpleDateFormat dateTimeFormat;
  if (withYear) {
    dateTimeFormat=new SimpleDateFormat("EEE, MMM d, yyyy h:mma");
  }
 else {
    dateTimeFormat=new SimpleDateFormat("EEE, MMM d, h:mma");
  }
  return dateTimeFormat.format(new GregorianCalendar(year,(month - 1),day,hour,minute).getTime());
}
 

public Date randomDate(){
  Calendar cal=new GregorianCalendar();
  cal.add(Calendar.DAY_OF_MONTH,randomInteger(MINIMUM_DATE_DELTA,MAXIMUM_DATE_DELTA));
  cal.add(Calendar.SECOND,-randomInteger(86400));
  return cal.getTime();
}
 

/** 
 */
public UserCriteria(){
  onlyActiveProjects=true;
  onlyActiveCustomers=true;
  onlyActiveUsers=true;
  infiniteStartDate=false;
  infiniteEndDate=false;
  reportRange=DateUtil.getDateRangeForMonth(new GregorianCalendar());
  setCustomParameters(new HashMap<Object,Object>());
}
 

public static String toString(String datatype,Object object){
  if (datatype.equals("EDate") || datatype.equals("Date")) {
    final GregorianCalendar c=new GregorianCalendar();
    c.setTime(((Date)object));
    XMLGregorianCalendar date=null;
    try {
      date=DatatypeFactory.newInstance().newXMLGregorianCalendar(c);
    }
 catch (    DatatypeConfigurationException e) {
      e.printStackTrace();
    }
    if (date != null) {
      return date.toXMLFormat();
    }
  }
 else   if (datatypes.containsKey(datatype)) {
    return EcoreFactory.eINSTANCE.convertToString(datatypes.get(datatype),object);
  }
  return object.toString();
}
 

static void schedule(Context context){
  final Intent intent=new Intent(context,CheckUpdateService.class);
  final PendingIntent pending=PendingIntent.getService(context,0,intent,0);
  Calendar c=new GregorianCalendar();
  c.add(Calendar.DAY_OF_YEAR,1);
  c.set(Calendar.HOUR_OF_DAY,0);
  c.set(Calendar.MINUTE,0);
  c.set(Calendar.SECOND,0);
  c.set(Calendar.MILLISECOND,0);
  final AlarmManager alarm=(AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
  alarm.cancel(pending);
  if (DEBUG) {
    alarm.setRepeating(AlarmManager.ELAPSED_REALTIME,SystemClock.elapsedRealtime(),30 * 1000,pending);
  }
 else {
    alarm.setRepeating(AlarmManager.RTC,c.getTimeInMillis(),UPDATES_CHECK_INTERVAL,pending);
  }
}
 

/** 
 * Convert the Java timezone ID to the "formatted" string that can be accepted by the C/C++ code. Example: "America/New_York" converted to "EST5EDT", etc
 * @param timezoneID
 * @return
 */
public static String convertTimeZone(String timezoneID){
  String result="";
  TimeZone zone=TimeZone.getTimeZone(timezoneID);
  int offset=zone.getRawOffset() / 1000;
  int hour=offset / 3600;
  int min=(offset % 3600) / 60;
  DateFormat dfm=new SimpleDateFormat("z");
  dfm.setTimeZone(zone);
  boolean hasDaylight=zone.useDaylightTime();
  String first=dfm.format(new GregorianCalendar(2010,1,1).getTime()).substring(0,3);
  String second=dfm.format(new GregorianCalendar(2011,6,6).getTime()).substring(0,3);
  int mid=hour * -1;
  result=first + Integer.toString(mid);
  if (min != 0) {
    result=result + ":" + Integer.toString(min);
  }
  if (hasDaylight) {
    result=result + second;
  }
  return result;
}
 

private ValidationResult validate(Object xml,String fileName){
  KnowledgeBase kbase=kbaseManager.getKnowledgeBase();
  ValidationResultManager valResMan=new BaseValidationManager();
  ValidationResult result=new ValidationResult();
  result.setDisclaimer("This validation test provides no warranty that all constraints were checked for given " + "profiles.  Additional testing may be required. Any issues should be reported to testing entity.");
  result.setFileTested(fileName);
  valResMan.setResult(result);
  try {
    result.setTimestamp(DatatypeFactory.newInstance().newXMLGregorianCalendar(new GregorianCalendar()));
  }
 catch (  DatatypeConfigurationException e) {
    logger.log(Level.SEVERE,"Error creating XML datetime type",e);
    e.printStackTrace();
  }
  Collection<KnowledgePackage> pkgs=kbase.getKnowledgePackages();
  logger.log(Level.INFO,"Pkg list: " + pkgs.size());
  StatefulKnowledgeSession ksession=kbase.newStatefulKnowledgeSession();
  List<Rule> rules=new ArrayList<Rule>();
  for (  KnowledgePackage kpackage : kbase.getKnowledgePackages()) {
    rules.addAll(kpackage.getRules());
  }
  result.getRules().getRule().addAll(getRuleTypes(rules));
  ksession.setGlobal("val_result",valResMan);
  ksession.insert(xml);
  ksession.insert(ccrSchVal);
  ksession.fireAllRules();
  ksession.dispose();
  ValidationResult vr=valResMan.getResult();
  return vr;
}
 

@Override public void onEvent(Event event,Object source,Object data){
  XWikiDocument doc=(XWikiDocument)source;
  BaseObject patientRecordObj=doc.getXObject(new DocumentReference(doc.getDocumentReference().getRoot().getName(),"ClinicalInformationCode","PatientClass"));
  if (patientRecordObj == null) {
    return;
  }
  String targetPropertyName="date_of_birth";
  int year=getParameter("date_of_birth_year",patientRecordObj.getNumber());
  int month=getParameter("date_of_birth_month",patientRecordObj.getNumber());
  int day=getParameter("date_of_birth_day",patientRecordObj.getNumber());
  if (year == -1 || month == -1) {
    return;
  }
  if (day <= 0) {
    day=1;
  }
  Date birthdate=patientRecordObj.getDateValue(targetPropertyName);
  Date newBirthdate=new GregorianCalendar(year,month,day).getTime();
  if (!newBirthdate.equals(birthdate)) {
    patientRecordObj.setDateValue(targetPropertyName,newBirthdate);
  }
}
 

private void makeAudioSituation(AdviceSituationItem situationItem){
  String audioSequence=situationItem.getAdvice().getAudioSequence();
  int severity=situationItem.getRecommendation().getSeverity();
  String dataCollectionDate=situationItem.getRecommendation().getDataCollectionDate();
  List<Plot> plotList=mDataProvider.getPlotsByUserId(Global.userId);
  int plotNumber=0;
  for (int x=0; x < plotList.size(); x++) {
    if (plotList.get(x).getId() == situationItem.getPlotId()) {
      plotNumber=x;
      break;
    }
  }
  try {
    Date date=RealFarmProvider.sDateFormat.parse(dataCollectionDate);
    Calendar cal=new GregorianCalendar();
    cal.setTime(date);
    cal.get(Calendar.MONTH);
    cal.get(Calendar.YEAR);
    cal.get(Calendar.DAY_OF_MONTH);
    String[] audioPieces=audioSequence.split(",");
    playInteger(cal.get(Calendar.MONTH) + 1);
    playInteger(cal.get(Calendar.MONTH));
    playInteger(cal.get(Calendar.YEAR));
    addToSoundQueue(Integer.valueOf(audioPieces[0]));
    playInteger(plotNumber);
    addToSoundQueue(Integer.valueOf(audioPieces[1]));
    playInteger(severity);
    addToSoundQueue(Integer.valueOf(audioPieces[2]));
    playSound(true);
  }
 catch (  ParseException e) {
  }
}
 

public void testTouch() throws IOException {
  File file=new File(getTestDirectory(),"touch.txt");
  if (file.exists()) {
    file.delete();
  }
  assertTrue("Bad test: test file still exists",!file.exists());
  FileUtils.touch(file);
  assertTrue("FileUtils.touch() created file",file.exists());
  FileOutputStream out=new FileOutputStream(file);
  assertEquals("Created empty file.",0,file.length());
  out.write(0);
  out.close();
  assertEquals("Wrote one byte to file",1,file.length());
  long y2k=new GregorianCalendar(2000,0,1).getTime().getTime();
  boolean res=file.setLastModified(y2k);
  assertEquals("Bad test: set lastModified failed",true,res);
  assertEquals("Bad test: set lastModified set incorrect value",y2k,file.lastModified());
  long now=System.currentTimeMillis();
  FileUtils.touch(file);
  assertEquals("FileUtils.touch() didn't empty the file.",1,file.length());
  assertEquals("FileUtils.touch() changed lastModified",false,y2k == file.lastModified());
  assertEquals("FileUtils.touch() changed lastModified to more than now-3s",true,file.lastModified() >= now - 3000);
  assertEquals("FileUtils.touch() changed lastModified to less than now+3s",true,file.lastModified() <= now + 3000);
}
 

private static void statsDesc(Connection con,ObjectOutputStream obj_out,ObjectInputStream obj_in,FreetaxStatsDesc freetaxStatsDesc) throws SQLException, IOException {
  PreparedStatement instruc;
  int nbJours;
  if (freetaxStatsDesc.getSemaine() != null) {
    instruc=con.prepareStatement("SELECT jour_semaine AS jour, count " + "FROM stats_desc " + "WHERE categorie = ? "+ "  AND semaine = ?");
    instruc.setInt(2,freetaxStatsDesc.getSemaine().intValue());
    nbJours=7;
  }
 else {
    if (freetaxStatsDesc.getMois() == null) {
      freetaxStatsDesc.setMois(moisPrec());
    }
    instruc=con.prepareStatement("SELECT jour_mois AS jour, count " + "FROM stats_desc " + "WHERE categorie = ? "+ "  AND mois = ?");
    instruc.setInt(2,freetaxStatsDesc.getMois().intValue());
    Calendar cal=new GregorianCalendar();
    cal.set(Calendar.MONTH,freetaxStatsDesc.getMois());
    nbJours=cal.getActualMaximum(Calendar.DAY_OF_MONTH);
  }
  instruc.setString(1,freetaxStatsDesc.getCategorie());
  ResultSet rs=instruc.executeQuery();
  int[] ventes=new int[nbJours];
  while (rs.next()) {
    ventes[rs.getInt("jour") - 1]=rs.getInt("count");
  }
  Number[] ventesInteger=new Integer[nbJours];
  int i=0;
  for (  int v : ventes) {
    ventesInteger[i]=v;
    i++;
  }
  double moyenne=Statistics.calculateMean(ventesInteger);
  double ecartType=Statistics.getStdDev(ventesInteger);
  Integer mode=null;
  for (  int v : ventes) {
    if (mode == null || v > mode.intValue())     mode=v;
  }
  obj_out.writeObject(new FreetaxStatsDescReponse(ventes,moyenne,mode.intValue(),ecartType));
  obj_out.flush();
}
 

public Term getCurrentTerm(){
  Term bestDateMatch=null;
  int bestDist=Integer.MAX_VALUE;
  final int currentYear=new GregorianCalendar().get(Calendar.YEAR);
  for (  Term term : getTerms()) {
    if (term.isCurrent()) {
      return term;
    }
    final BigInteger termYear=term.getYear();
    if (termYear != null) {
      if (bestDateMatch == null) {
        bestDateMatch=term;
        bestDist=Math.abs(termYear.intValue() - currentYear);
      }
 else {
        final int dist=Math.abs(termYear.intValue() - currentYear);
        if (dist < bestDist) {
          bestDateMatch=term;
        }
      }
    }
  }
  return bestDateMatch;
}
 

/** 
 */
@SuppressWarnings("unchecked") protected void reload(){
  ArrayList<NameValuePair> params=new ArrayList<NameValuePair>();
switch (mType) {
case (TYPE_OSD):
    params.add(new BasicNameValuePair("o",""));
  params.add(new BasicNameValuePair("n",""));
break;
case (TYPE_VIDEO):
params.add(new BasicNameValuePair("v",""));
break;
case (TYPE_ALL):
break;
}
switch (mFormat) {
case (FORMAT_JPG):
params.add(new BasicNameValuePair("format","jpg"));
break;
case (FORMAT_PNG):
params.add(new BasicNameValuePair("format","png"));
break;
}
params.add(new BasicNameValuePair("r",String.valueOf(mSize)));
if (mFilename == null) {
long ts=(new GregorianCalendar().getTimeInMillis()) / 1000;
mFilename="/tmp/dreamDroid-" + ts;
}
params.add(new BasicNameValuePair("filename",mFilename));
cancelTaskIfRunning();
mGetScreenshotTask=new GetScreenshotTask();
mGetScreenshotTask.execute(params);
}
 

/** 
 * This method returns a String representing the relative date by comparing the Calendar being passed in to the date / time that it is right now.
 * @param Calendar calendar
 * @return String representing the relative date
 */
public static String getRelativeDate(Calendar calendar){
  Calendar now=GregorianCalendar.getInstance();
  int years=calendar.get(Calendar.YEAR) - now.get(Calendar.YEAR);
  int months=calendar.get(Calendar.MONTH) - now.get(Calendar.MONTH);
  int days=calendar.get(Calendar.DAY_OF_MONTH) - now.get(Calendar.DAY_OF_MONTH);
  int hours=calendar.get(Calendar.HOUR_OF_DAY) - now.get(Calendar.HOUR_OF_DAY);
  int minutes=calendar.get(Calendar.MINUTE) - now.get(Calendar.MINUTE);
  int seconds=calendar.get(Calendar.SECOND) - now.get(Calendar.SECOND);
  return computeRelativeDate(calendar,years,months,days,hours,minutes,seconds);
}
 

/** 
 * Assume ZERO prices as indicators of unknown values
 */
public Option(OptionType optionType,String symbol,GregorianCalendar expiryDate,BigDecimal strikePrice,BigDecimal bidPrice,BigDecimal askPrice,BigDecimal lastPrice){
  this.optionType=optionType;
  this.symbol=symbol;
  this.expiryDate=expiryDate;
  this.strikePrice=strikePrice;
  this.bidPrice=bidPrice;
  this.askPrice=askPrice;
  this.lastPrice=lastPrice;
}
 

public static Duration totalWorkedForDay(Issue issue,Date date){
  Calendar cal=GregorianCalendar.getInstance();
  cal.setTime(date);
  double total=0d;
  Calendar cal2=GregorianCalendar.getInstance();
  for (  DurationWorked worked : issue.getTimeWorked()) {
    if (worked.getDay() == null || worked.getUpdatedRequired() == null) {
      continue;
    }
    cal2.setTime(worked.getDay());
    if (cal.get(Calendar.DATE) == cal2.get(Calendar.DATE) && cal.get(Calendar.MONTH) == cal2.get(Calendar.MONTH) && cal.get(Calendar.YEAR) == cal2.get(Calendar.YEAR)) {
      if (worked.getWorked() != null) {
        total+=worked.getWorked().getHours();
      }
    }
  }
  return new Duration(total);
}
 

public static void trace(String format,Object... values){
  StringBuilder sb=new StringBuilder();
  Formatter formatter=new Formatter(sb);
  if (Defaults.LOG == Defaults.LOGT.ALL) {
    formatter.format("%s [%2$tF %2$tT.%2$tL]: ",Thread.currentThread().getName(),GregorianCalendar.getInstance());
  }
 else   if (Defaults.LOG == Defaults.LOGT.ELAPSED) {
    formatter.format("%s [%d]: ",Thread.currentThread().getName(),(System.currentTimeMillis() - START));
  }
 else   if (Defaults.LOG == Defaults.LOGT.NOTIME) {
    formatter.format("%s: ",Thread.currentThread().getName());
  }
  formatter.format(format,values);
  System.out.println(sb.toString());
}
 

public void parse(Calendar cal,DateFormatSymbols symb,String source,ParsePosition pos) throws java.text.ParseException {
  int i=pos.getIndex();
  String t=source.substring(i,i + 4);
  if (toString().equals(t.toUpperCase())) {
    pos.setIndex(i + 4);
    cal.set(ERA,GregorianCalendar.BC);
  }
 else   if (t.toUpperCase().equals("A.D.")) {
    pos.setIndex(i + 4);
    cal.set(ERA,GregorianCalendar.AD);
  }
 else {
    throw new java.text.ParseException("",0);
  }
}
 

public static Book fromCursor(Cursor c){
  final Book book=new Book();
  book.mInternalId=c.getString(c.getColumnIndexOrThrow(INTERNAL_ID));
  book.mEan=c.getString(c.getColumnIndexOrThrow(EAN));
  book.mIsbn=c.getString(c.getColumnIndexOrThrow(ISBN));
  book.mTitle=c.getString(c.getColumnIndexOrThrow(TITLE));
  Collections.addAll(book.mAuthors,c.getString(c.getColumnIndexOrThrow(AUTHORS)).split(", "));
  book.mPublisher=c.getString(c.getColumnIndexOrThrow(PUBLISHER));
  book.mDescriptions.add(new Description("",c.getString(c.getColumnIndexOrThrow(REVIEWS))));
  book.mPages=c.getInt(c.getColumnIndexOrThrow(PAGES));
  final Calendar calendar=GregorianCalendar.getInstance();
  calendar.setTimeInMillis(c.getLong(c.getColumnIndexOrThrow(LAST_MODIFIED)));
  book.mLastModified=calendar;
  final SimpleDateFormat format=new SimpleDateFormat("MMMM yyyy");
  try {
    book.mPublicationDate=format.parse(c.getString(c.getColumnIndexOrThrow(PUBLICATION)));
  }
 catch (  ParseException e) {
  }
  book.mDetailsUrl=c.getString(c.getColumnIndexOrThrow(DETAILS_URL));
  book.mImages.put(ImageSize.TINY,c.getString(c.getColumnIndexOrThrow(TINY_URL)));
  return book;
}
 

private void initialize(){
  mThrottleManager=(ThrottleManager)mContext.getSystemService(Context.THROTTLE_SERVICE);
  mStart=GregorianCalendar.getInstance();
  mEnd=GregorianCalendar.getInstance();
  mFilter=new IntentFilter();
  mFilter.addAction(ThrottleManager.THROTTLE_POLL_ACTION);
  mFilter.addAction(ThrottleManager.THROTTLE_ACTION);
  mFilter.addAction(ThrottleManager.POLICY_CHANGED_ACTION);
  mReceiver=new BroadcastReceiver(){
    @Override public void onReceive(    Context context,    Intent intent){
      String action=intent.getAction();
      if (ThrottleManager.THROTTLE_POLL_ACTION.equals(action)) {
        updateUsageStats(intent.getLongExtra(ThrottleManager.EXTRA_CYCLE_READ,0),intent.getLongExtra(ThrottleManager.EXTRA_CYCLE_WRITE,0),intent.getLongExtra(ThrottleManager.EXTRA_CYCLE_START,0),intent.getLongExtra(ThrottleManager.EXTRA_CYCLE_END,0));
      }
 else       if (ThrottleManager.POLICY_CHANGED_ACTION.equals(action)) {
        updatePolicy();
      }
 else       if (ThrottleManager.THROTTLE_ACTION.equals(action)) {
        updateThrottleRate(intent.getIntExtra(ThrottleManager.EXTRA_THROTTLE_LEVEL,-1));
      }
    }
  }
;
}
 

public static void close(){
  if (!logOutputIsScreen) {
    out.println("------------------------------");
    out.println("Application Builder Log File - END " + GregorianCalendar.getInstance().getTime());
    out.close();
  }
}
 

@Test @SpecAssertions({@SpecAssertion(section="6",id="a"),@SpecAssertion(section="6",id="m")}) public void testPastConstraint(){
  Validator validator=TestUtil.getValidatorUnderTest();
  PastDummyEntity dummy=new PastDummyEntity();
  Set<ConstraintViolation<PastDummyEntity>> constraintViolations=validator.validate(dummy);
  assertCorrectNumberOfViolations(constraintViolations,0);
  Calendar cal=GregorianCalendar.getInstance();
  cal.add(Calendar.YEAR,1);
  dummy.calendar=cal;
  dummy.date=cal.getTime();
  constraintViolations=validator.validate(dummy);
  assertCorrectNumberOfViolations(constraintViolations,2);
  assertCorrectPropertyPaths(constraintViolations,"date","calendar");
  cal.add(Calendar.YEAR,-2);
  dummy.calendar=cal;
  dummy.date=cal.getTime();
  constraintViolations=validator.validate(dummy);
  assertCorrectNumberOfViolations(constraintViolations,0);
}
 

public static long today(){
  long currentTime=System.currentTimeMillis();
  Calendar cal=GregorianCalendar.getInstance();
  cal.setTimeInMillis(currentTime);
  cal.set(cal.get(Calendar.YEAR),cal.get(Calendar.MONTH),cal.get(Calendar.DAY_OF_MONTH),0,0,0);
  long calendarTime=cal.getTimeInMillis();
  return calendarTime;
}
 

/** 
 * registers a std set of fast cloners.
 */
protected void registerFastCloners(){
  this.fastCloners.put(GregorianCalendar.class,new FastClonerCalendar());
  this.fastCloners.put(ArrayList.class,new FastClonerArrayList());
  this.fastCloners.put(Arrays.asList(new Object[]{""}).getClass(),new FastClonerArrayList());
  this.fastCloners.put(LinkedList.class,new FastClonerLinkedList());
  this.fastCloners.put(HashSet.class,new FastClonerHashSet());
  this.fastCloners.put(HashMap.class,new FastClonerHashMap());
  this.fastCloners.put(TreeMap.class,new FastClonerTreeMap());
}