Java Code Examples for java.util.GregorianCalendar#setTime()

/**
 * Test method for
 * {@link org.eclipse.rdf4j.model.util.Literals#createLiteralOrFail(org.eclipse.rdf4j.model.ValueFactory, java.lang.Object)}
 * .
 */
@Test
public void testCreateLiteralOrFailObjectXMLGregorianCalendar() throws Exception {

	GregorianCalendar c = new GregorianCalendar();
	c.setTime(new Date());
	try {
		Object obj = DatatypeFactory.newInstance().newXMLGregorianCalendar(c);
		Literal l = Literals.createLiteralOrFail(SimpleValueFactory.getInstance(), obj);
		assertNotNull(l);
		assertEquals(l.getDatatype(), XMLSchema.DATETIME);
		// TODO check lexical value?
	} catch (DatatypeConfigurationException e) {
		e.printStackTrace();
		fail("Could not instantiate javax.xml.datatype.DatatypeFactory");
	}

}
 

/**
 * GregorianCalendar handling of Dates Long.MIN_VALUE and Long.MAX_VALUE is
 * confusing; unless the time zone has a raw offset of zero, one or the
 * other of these will wrap.  We've modified the test given in the bug
 * report to therefore only check the behavior of a calendar with a zero raw
 * offset zone.
 */
public void Test4145158() {
    GregorianCalendar calendar = new GregorianCalendar();

    calendar.setTimeZone(TimeZone.getTimeZone("GMT"));

    calendar.setTime(new Date(Long.MIN_VALUE));
    int year1 = calendar.get(YEAR);
    int era1 = calendar.get(ERA);

    calendar.setTime(new Date(Long.MAX_VALUE));
    int year2 = calendar.get(YEAR);
    int era2 = calendar.get(ERA);

    if (year1 == year2 && era1 == era2) {
        errln("Fail: Long.MIN_VALUE or Long.MAX_VALUE wrapping around");
    }
}
 

/**
 * Parse a given date string to a GregorianCalendar
 *
 * @param dateValue
 * @param datePattern
 * @return
 */
public GregorianCalendar parseDate(final String dateValue, final String datePattern) {

	/*
	 * **************************************************
	 *   IMPORTANT  IMPORTANT    IMPORTANT    IMPORTANT
	 * **************************************************
	 *
	 * DO NOT REMOVE METHOD OR CHANGE SIGNATURE!!!
	 */

	try {
		final GregorianCalendar returnValue = new GregorianCalendar();
		final Date parsedDate = new SimpleDateFormat(datePattern).parse(dateValue);
		returnValue.setTime(parsedDate);
		return returnValue;
	} catch (final ParseException e) {
		return null;
	}
}
 

/**
 * Set a ProDOS date into the buffer.
 */
public static void setProdosDate(byte[] buffer, int offset, Date date) {
	int day = 0;
	int month = 0;
	int year = 0;
	int minute = 0;
	int hour = 0;
	if (date != null) {
		GregorianCalendar gc = new GregorianCalendar();
		gc.setTime(date);
		day = gc.get(Calendar.DAY_OF_MONTH);
		month = gc.get(Calendar.MONTH) + 1;
		year = gc.get(Calendar.YEAR);
		minute = gc.get(Calendar.MINUTE);
		hour = gc.get(Calendar.HOUR_OF_DAY);
		if (year >= 2000) {
			year -= 2000;
		} else {
			year -= 1900;
		}
	}
	int ymd = ((year & 0x7f) << 9) | ((month & 0xf) << 5) | (day & 0x1f);
	int hm = ((hour & 0x1f) << 8) | (minute & 0x3f);
	setWordValue(buffer, offset, ymd);
	setWordValue(buffer, offset+2, hm);
}
 

/**
 * 获取今年是哪一年
 * @return
 */
public static Integer getNowYear() {
    Date date = new Date();
    GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
    gc.setTime(date);
    return Integer.valueOf(gc.get(1));
}
 

public static XMLGregorianCalendar getXMLGregorianCalendar (Date dateValue) {
	XMLGregorianCalendar dateTime = null;
	try {
		GregorianCalendar calendar = new GregorianCalendar();
		calendar.setTime(dateValue);
		DatatypeFactory df;
		df = DatatypeFactory.newInstance();
		dateTime = df.newXMLGregorianCalendar(calendar);
	} catch (DatatypeConfigurationException e) {
		//printStackTrace(e,startTimeStamp,procedure,info);
	}
	return dateTime;
}
 

@Test
public void testForValue() throws Exception {
	checkForValue(-1);
	checkForValue(1);
	checkForValue(2l);
	checkForValue(-2l);
	checkForValue(123123123123111232l);
	checkForValue(3.0d);
	checkForValue(4.0f);
	checkForValue((short)5);
	checkForValue((short)2000);
	checkForValue((short)-5);
	checkForValue((byte)6);
	checkForValue(true);
	checkForValue(URI.create("http://www.example.org"));
	checkForValue("test");
	checkForValue(new String[]{"test","test2"});
	checkForValue(BigDecimal.ONE);
	checkForValue(BigInteger.ONE);
	checkForValue(BigInteger.ZERO);
	checkForValue(BigInteger.valueOf(-1));
	checkForValue(new QName("http://www.example.org#","name"));
	checkForValue(DatatypeFactory.newInstance().newDuration(23));
	GregorianCalendar gc=new GregorianCalendar();
	gc.setTime(new Date());
	checkForValue(DatatypeFactory.newInstance().newXMLGregorianCalendar(gc));
}
 

private Date time(int hour, int minutes) {
	GregorianCalendar gc = new GregorianCalendar();
	gc.setTime(new Date());
	gc.set(Calendar.HOUR_OF_DAY, hour);
	gc.set(Calendar.MINUTE, minutes);
	return gc.getTime();
}
 

public static boolean isValidSendDate( Date sendDate) {
	// Create the calendar object for comparison
    GregorianCalendar now = new GregorianCalendar();
    GregorianCalendar sendDateCalendar = new GregorianCalendar();

    // Set the time of the test-calendar
    sendDateCalendar.setTime( sendDate);

    // Move "current time" 5 minutes into future, so we get a 5 minute fairness period
    now.add( Calendar.MINUTE, -5);
    
    // Do the hard work!
    return now.before( sendDateCalendar);
}
 

protected JobEntity internalCreateLockedAsyncJob(ExecutionEntity execution, boolean exclusive) {
  JobEntity asyncJob = processEngineConfiguration.getJobEntityManager().create();
  fillDefaultAsyncJobInfo(asyncJob, execution, exclusive);
  
  GregorianCalendar gregorianCalendar = new GregorianCalendar();
  gregorianCalendar.setTime(processEngineConfiguration.getClock().getCurrentTime());
  gregorianCalendar.add(Calendar.MILLISECOND, getAsyncExecutor().getAsyncJobLockTimeInMillis());
  asyncJob.setLockExpirationTime(gregorianCalendar.getTime());
  asyncJob.setLockOwner(getAsyncExecutor().getLockOwner());
  
  return asyncJob;
}
 

/**
  * Set a Pascal data to the buffer.<br>
  * Bits 0-3: month (1-12)<br>
  * Bits 4-8: day (1-31)<br>
  * Bits 9-15: year (0-99)
  */
public static void setPascalDate(byte[] buffer, int offset, Date date) {
	GregorianCalendar gc = new GregorianCalendar();
	gc.setTime(date);
	int month = gc.get(Calendar.MONTH) + 1;
	int day = gc.get(Calendar.DAY_OF_MONTH);
	int year = gc.get(Calendar.YEAR) % 100;
	int pascalDate = (month & 0x000f)
		| ((day << 4) & 0x01f0)
		| ((year << 9) & 0xfe00);
	setWordValue(buffer, offset, pascalDate);
}
 

protected void scheduleAtomicOperationAsync(AtomicOperation executionOperation) {
    JobEntity message = new JobEntity();
    message.setJobType(Job.JOB_TYPE_MESSAGE);
    message.setRevision(1);
    message.setExecution(this);
    message.setExclusive(getActivity().isExclusive());
    message.setJobHandlerType(AsyncContinuationJobHandler.TYPE);
    // At the moment, only AtomicOperationTransitionCreateScope can be performed asynchronously,
    // so there is no need to pass it to the handler

    ProcessEngineConfiguration processEngineConfig = Context.getCommandContext().getProcessEngineConfiguration();

    if (processEngineConfig.getAsyncExecutor().isActive()) {
        GregorianCalendar expireCal = new GregorianCalendar();
        expireCal.setTime(processEngineConfig.getClock().getCurrentTime());
        expireCal.add(Calendar.SECOND, processEngineConfig.getLockTimeAsyncJobWaitTime());
        message.setLockExpirationTime(expireCal.getTime());
    }

    // Inherit tenant id (if applicable)
    if (getTenantId() != null) {
        message.setTenantId(getTenantId());
    }

    callJobProcessors(JobProcessorContext.Phase.BEFORE_CREATE, message, Context.getProcessEngineConfiguration());
    Context.getCommandContext().getJobEntityManager().send(message);
}
 

protected void lockJob(CommandContext commandContext, TimerJobEntity job, int lockTimeInMillis) {
  
  // This will trigger an optimistic locking exception when two concurrent executors 
  // try to lock, as the revision will not match.
  
  GregorianCalendar gregorianCalendar = new GregorianCalendar();
  gregorianCalendar.setTime(commandContext.getProcessEngineConfiguration().getClock().getCurrentTime());
  gregorianCalendar.add(Calendar.MILLISECOND, lockTimeInMillis);
  job.setLockOwner(asyncExecutor.getLockOwner());
  job.setLockExpirationTime(gregorianCalendar.getTime());
}
 

/**
 * <pre>
 * 描述:间隔指定天数后日期(例如:每3天)
 * 作者:ZhangYi
 * 时间:2016年5月5日 下午4:29:07
 * 参数：(参数列表)
 * @param dateTime	指定日期
 * @param interval	间隔天数
 * @return
 * </pre>
 */
public static Date handleDateTimeByDay(Date dateTime, int interval) {
	try {
		GregorianCalendar calendar = new GregorianCalendar();
		calendar.setTime(dateTime);
		calendar.add(Calendar.DAY_OF_MONTH, interval);
		dateTime = calendar.getTime();
	} catch (Exception e) {
		logger.error("--间隔指定天数后日期异常!", e);
	}
	return dateTime;
}
 

public static boolean verifyDate(int expYear, int expMonth, int expDay, int expHour, int expMin, int expSec, Date value) {
   GregorianCalendar gc = new GregorianCalendar(TimeZone.getTimeZone("GMT"));
   gc.setTime(value);
   // 2015-04-23T18:23:09.123
   return ((expYear == gc.get(Calendar.YEAR)) &&
         (expMonth - 1 == gc.get(Calendar.MONTH)) &&
         (expDay == gc.get(Calendar.DAY_OF_MONTH)) &&
         (expHour == gc.get(Calendar.HOUR_OF_DAY)) &&
         (expMin == gc.get(Calendar.MINUTE)) &&
         (expSec == gc.get(Calendar.SECOND)));
}
 

public static int getYear() {
    GregorianCalendar calendar = new GregorianCalendar();
    calendar.setTime(getDate());
    return calendar.get(Calendar.YEAR);
}
 

public static GregorianCalendar createCalendar(long timeMS) {
	GregorianCalendar G = new GregorianCalendar();
	G.setTime(new java.util.Date(timeMS));
	return G;
}
 

public static Date getDateOfHoursAgo(Date initDate, int hoursAgo) {
GregorianCalendar returnDate = new GregorianCalendar();
returnDate.setTime(initDate);
returnDate.add(Calendar.HOUR, -hoursAgo);
return returnDate.getTime();
  }
 

public void setup() throws ParseException, IOException {
  // insert a sample MarkLogic template which can extract fields from the
  // sample data below
  ObjectMapper mapper = new ObjectMapper()
    .configure(Feature.ALLOW_SINGLE_QUOTES, true);
  docMgr.writeAs(templateUri, mapper.readTree(
    "{ 'template':{ 'description':'test template', 'context':'/firstName', " +
    "    'rows':[ { 'schemaName':'employee', 'viewName':'employee'," +
    "      'columns':[ { 'name':'firstName', 'scalarType':'string', 'val':'.' }," +
    "                  { 'name':'salary', 'scalarType':'int', 'nullable':true," +
    "                    'val':'max(../salaries/salary)'}" +
    " ] } ] } }"));

  // insert some sample documents
  String[][] employees = new String[][] {
    {"1", "1990-10-04", "Alice", "Edward", "FEMALE", "2012-04-05", "70675"},
    {"2", "1992-12-23", "Bob", "Miller", "MALE", "2010-06-01", "98023"},
    {"3", "1985-11-30", "Gerard", "Steven", "MALE", "2011-07-29", "87455"},
    {"4", "1970-01-08", "Evelyn", "Erick", "FEMALE", "2012-08-24", "62444"},
    {"5", "1978-05-14", "Daniel", "Washington", "MALE", "2007-02-17", "68978,76543,86732"},
    {"6", "1989-07-19", "Eve", "Alfred", "FEMALE", "2009-08-14", "70987,79083"},
    {"7", "1990-09-29", "Rachel", "Fisher", "FEMALE", "2015-01-01", "50678"},
    {"8", "1987-10-26", "Bruce", "Wayne", "MALE", "2010-04-09", "99873,106742"},
    {"9", "1992-11-25", "Thomas", "Crook", "MALE", "2013-07-07", "79003"},
    {"10", "1994-12-04", "Diana", "Trevor", "FEMALE", "2016-09-23", "67893,67993"}
  };
  for ( String[] employee : employees ) {
    Employee newEmployee = new Employee();
    newEmployee.setEmployeeId(Integer.parseInt(employee[0]));
    GregorianCalendar bday = new GregorianCalendar();
    bday.setTime(df.parse(employee[1]));
    newEmployee.setBirthDate(bday);
    newEmployee.setFirstName(employee[2]);
    newEmployee.setLastName(employee[3]);
    newEmployee.setGender(Gender.valueOf(employee[4]));
    ArrayList<Salary> salaries = new ArrayList<>();
    for ( String salary : employee[6].split(",") ) {
      Salary newSalary = new Salary();
      newSalary.setSalary(Integer.parseInt(salary));
      salaries.add(newSalary);
    }
    newEmployee.setSalaries(salaries.toArray(new Salary[salaries.size()]));
    docMgr.writeAs("/employees/" + employee[0] + ".json", newEmployee);
  }
}
 

/**
 * Convert the given date to string.
 * Always contains the milliseconds and timezone.
 * @param date the date, not null
 * @return the formatted date
 */
public static String formatDateTime(Date date) {
	StringBuilder b = new StringBuilder(24);
	
	GregorianCalendar cal = XSD_CALENDAR.get();
	cal.setTime(date);
	
	int value;
	
	// Year-Month-Day
	value = cal.get(GregorianCalendar.YEAR);
	b.append(value);
	b.append('-');
	value = cal.get(GregorianCalendar.MONTH) + 1;
	if (value < 10) {
		b.append('0');
	}
	b.append(value);
	b.append('-');
	value = cal.get(GregorianCalendar.DATE);
	if (value < 10) {
		b.append('0');
	}
	b.append(value);
	
	b.append('T');
	// hour:minute:second:milliseconds
	value = cal.get(GregorianCalendar.HOUR_OF_DAY);
	if (value < 10) {
		b.append('0');
	}
	b.append(value);
	b.append(':');
	value = cal.get(GregorianCalendar.MINUTE);
	if (value < 10) {
		b.append('0');
	}
	b.append(value);
	b.append(':');
	value = cal.get(GregorianCalendar.SECOND);
	if (value < 10) {
		b.append('0');
	}
	b.append(value);
	b.append('.');
	
	value = cal.get(GregorianCalendar.MILLISECOND);
	// add leading zeros if needed
	if (value < 100) {
		b.append('0');
	}
	if (value < 10) {
		b.append('0');
	}
	b.append(value);
	
	value = cal.get(GregorianCalendar.DST_OFFSET) + cal.get(GregorianCalendar.ZONE_OFFSET);
	
	if (value == 0) {
		b.append('Z');
	} else {
		if (value < 0) {
			b.append('-');
			value = -value;
		} else {
			b.append('+');
		}
		int hour = value / 3600000;
		int minute = value / 60000 % 60;
		if (hour < 10) {
			b.append('0');
		}
		b.append(hour);
		b.append(':');
		if (minute < 10) {
			b.append('0');
		}
		b.append(minute);
	}
	
	
	return b.toString();
}