org.opengis.temporal.Period Java Examples

@Test
public void testTContains() throws ParseException {
    Date date1 = dateFormat.parse("1970-07-19T01:02:03.456Z");
    Instant temporalInstant = new DefaultInstant(new DefaultPosition(date1));
    Date date2 = dateFormat.parse("1970-07-19T07:08:09.101Z");
    Instant temporalInstant2 = new DefaultInstant(new DefaultPosition(date2));
    Period period = new DefaultPeriod(temporalInstant, temporalInstant2);

    TContains filter = ff.tcontains(ff.literal(period), ff.property("dateAttr"));
    Map<String,Object> expected = ImmutableMap.of("range", ImmutableMap.of("dateAttr", 
            ImmutableMap.of("gt", "1970-07-19T01:02:03.456Z", "lt", "1970-07-19T07:08:09.101Z")));

    builder.visit(filter, null);
    assertTrue(builder.createCapabilities().fullySupports(filter));
    assertEquals(expected, builder.getQueryBuilder());
}
 

@Test
public void testEndedBy() throws ParseException {
    Date date1 = dateFormat.parse("1970-07-19T01:02:03.456Z");
    Instant temporalInstant = new DefaultInstant(new DefaultPosition(date1));
    Date date2 = dateFormat.parse("1970-07-19T07:08:09.101Z");
    Instant temporalInstant2 = new DefaultInstant(new DefaultPosition(date2));
    Period period = new DefaultPeriod(temporalInstant, temporalInstant2);

    EndedBy filter = ff.endedBy(ff.literal(period), ff.property("dateAttr"));
    Map<String,Object> expected = ImmutableMap.of("term",
            ImmutableMap.of("dateAttr", "1970-07-19T07:08:09.101Z"));

    builder.visit(filter, null);
    assertTrue(builder.createCapabilities().fullySupports(filter));
    assertEquals(expected, builder.getQueryBuilder());
}
 

@Test
public void testEnds() throws ParseException {
    Date date1 = dateFormat.parse("1970-07-19T01:02:03.456Z");
    Instant temporalInstant = new DefaultInstant(new DefaultPosition(date1));
    Date date2 = dateFormat.parse("1970-07-19T07:08:09.101Z");
    Instant temporalInstant2 = new DefaultInstant(new DefaultPosition(date2));
    Period period = new DefaultPeriod(temporalInstant, temporalInstant2);

    Ends filter = ff.ends(ff.property("dateAttr"), ff.literal(period));
    Map<String,Object> expected = ImmutableMap.of("term",
            ImmutableMap.of("dateAttr", "1970-07-19T07:08:09.101Z"));

    builder.visit(filter, null);
    assertTrue(builder.createCapabilities().fullySupports(filter));
    assertEquals(expected, builder.getQueryBuilder());
}
 

@Test
public void testDuring() throws ParseException {
    Date date1 = dateFormat.parse("1970-07-19T01:02:03.456Z");
    Instant temporalInstant = new DefaultInstant(new DefaultPosition(date1));
    Date date2 = dateFormat.parse("1970-07-19T07:08:09.101Z");
    Instant temporalInstant2 = new DefaultInstant(new DefaultPosition(date2));
    Period period = new DefaultPeriod(temporalInstant, temporalInstant2);

    During filter = ff.during(ff.property("dateAttr"), ff.literal(period));
    Map<String,Object> expected = ImmutableMap.of("range", ImmutableMap.of("dateAttr", 
            ImmutableMap.of("gt", "1970-07-19T01:02:03.456Z", "lt", "1970-07-19T07:08:09.101Z")));

    builder.visit(filter, null);
    assertTrue(builder.createCapabilities().fullySupports(filter));
    assertEquals(expected, builder.getQueryBuilder());
}
 

@Test
public void testBegunBy() throws ParseException {
    Date date1 = dateFormat.parse("1970-07-19T01:02:03.456Z");
    Instant temporalInstant = new DefaultInstant(new DefaultPosition(date1));
    Date date2 = dateFormat.parse("1970-07-19T07:08:09.101Z");
    Instant temporalInstant2 = new DefaultInstant(new DefaultPosition(date2));
    Period period = new DefaultPeriod(temporalInstant, temporalInstant2);

    BegunBy filter = ff.begunBy(ff.literal(period), ff.property("dateAttr"));
    Map<String,Object> expected = ImmutableMap.of("term",
            ImmutableMap.of("dateAttr", "1970-07-19T01:02:03.456Z"));

    builder.visit(filter, null);
    assertTrue(builder.createCapabilities().fullySupports(filter));
    assertEquals(expected, builder.getQueryBuilder());
}
 

@Test
public void testBegins() throws ParseException {
    Date date1 = dateFormat.parse("1970-07-19T01:02:03.456Z");
    Instant temporalInstant = new DefaultInstant(new DefaultPosition(date1));
    Date date2 = dateFormat.parse("1970-07-19T07:08:09.101Z");
    Instant temporalInstant2 = new DefaultInstant(new DefaultPosition(date2));
    Period period = new DefaultPeriod(temporalInstant, temporalInstant2);

    Begins filter = ff.begins(ff.property("dateAttr"), ff.literal(period));
    Map<String,Object> expected = ImmutableMap.of("term",
            ImmutableMap.of("dateAttr", "1970-07-19T01:02:03.456Z"));

    builder.visit(filter, null);
    assertTrue(builder.createCapabilities().fullySupports(filter));
    assertEquals(expected, builder.getQueryBuilder());
}
 

@Test
public void testBeforeFilterPeriodSwapped() throws ParseException {
    Date date1 = dateFormat.parse("1970-07-19T01:02:03.456Z");
    Instant temporalInstant = new DefaultInstant(new DefaultPosition(date1));
    Date date2 = dateFormat.parse("1970-07-19T07:08:09.101Z");
    Instant temporalInstant2 = new DefaultInstant(new DefaultPosition(date2));
    Period period = new DefaultPeriod(temporalInstant, temporalInstant2);

    org.opengis.filter.temporal.Before filter = ff.before(ff.literal(period), ff.property("dateAttr"));
    Map<String,Object> expected = ImmutableMap.of("range",
            ImmutableMap.of("dateAttr", ImmutableMap.of("gt", "1970-07-19T07:08:09.101Z")));

    builder.visit(filter, null);
    assertTrue(builder.createCapabilities().fullySupports(filter));
    assertEquals(expected, builder.getQueryBuilder());
}
 

@Test
public void testBeforeFilterPeriod() throws ParseException {
    Date date1 = dateFormat.parse("1970-07-19T01:02:03.456Z");
    Instant temporalInstant = new DefaultInstant(new DefaultPosition(date1));
    Date date2 = dateFormat.parse("1970-07-19T07:08:09.101Z");
    Instant temporalInstant2 = new DefaultInstant(new DefaultPosition(date2));
    Period period = new DefaultPeriod(temporalInstant, temporalInstant2);

    org.opengis.filter.temporal.Before filter = ff.before(ff.property("dateAttr"), ff.literal(period));
    Map<String,Object> expected = ImmutableMap.of("range",
            ImmutableMap.of("dateAttr", ImmutableMap.of("lt", "1970-07-19T01:02:03.456Z")));

    builder.visit(filter, null);
    assertTrue(builder.createCapabilities().fullySupports(filter));
    assertEquals(expected, builder.getQueryBuilder());
}
 

/** {@inheritDoc} */
@Override
public Object visit(During during, Object userData) {
	String propertyName = getPropertyName(during.getExpression1());
	String finalName = parsePropertyName(propertyName, userData);
	Object literal = getLiteralValue(during.getExpression2());
	if (literal instanceof Period) {
		Period p = (Period) literal;
		Date begin = p.getBeginning().getPosition().getDate();
		Date end = p.getEnding().getPosition().getDate();
		return Restrictions.between(finalName, begin, end);
	} else {
		throw new UnsupportedOperationException("visit(Object userData)");
	}
}
 

/**
 * @param startTimeMillis start time (inclusive)
 * @param endTimeMillis end time (exclusive)
 * @param singleTimeField
 * @return the during filter
 */
public static Filter toDuringFilter(
    final long startTimeMillis,
    final long endTimeMillis,
    final String singleTimeField) {
  final FilterFactory2 factory = CommonFactoryFinder.getFilterFactory2();
  final Position ip1 = new DefaultPosition(new Date(startTimeMillis - 1));
  final Position ip2 = new DefaultPosition(new Date(endTimeMillis));
  final Period period = new DefaultPeriod(new DefaultInstant(ip1), new DefaultInstant(ip2));
  return factory.during(factory.property(singleTimeField), factory.literal(period));
}
 

@Test(expected=IllegalArgumentException.class)
public void testTEqualsWithPeriod() throws ParseException {
    Date date1 = dateFormat.parse("1970-07-19T01:02:03.456Z");
    Instant temporalInstant = new DefaultInstant(new DefaultPosition(date1));
    Date date2 = dateFormat.parse("1970-07-19T07:08:09.101Z");
    Instant temporalInstant2 = new DefaultInstant(new DefaultPosition(date2));
    Period period = new DefaultPeriod(temporalInstant, temporalInstant2);

    TEquals filter = ff.tequals(ff.property("dateAttr"), ff.literal(period));

    builder.visit(filter, null);
}
 

@Test(expected=IllegalArgumentException.class)
public void testBeginsWithSwap() throws ParseException {
    Date date1 = dateFormat.parse("1970-07-19T01:02:03.456Z");
    Instant temporalInstant = new DefaultInstant(new DefaultPosition(date1));
    Date date2 = dateFormat.parse("1970-07-19T07:08:09.101Z");
    Instant temporalInstant2 = new DefaultInstant(new DefaultPosition(date2));
    Period period = new DefaultPeriod(temporalInstant, temporalInstant2);

    Begins filter = ff.begins(ff.literal(period), ff.property("dateAttr"));

    builder.visit(filter, null);
}
 

@Test
public void testAfterFilterPeriodSwapped() throws ParseException {
    Date date1 = dateFormat.parse("1970-07-19T01:02:03.456Z");
    Instant temporalInstant = new DefaultInstant(new DefaultPosition(date1));
    Date date2 = dateFormat.parse("1970-07-19T07:08:09.101Z");
    Instant temporalInstant2 = new DefaultInstant(new DefaultPosition(date2));
    Period period = new DefaultPeriod(temporalInstant, temporalInstant2);
    After filter = ff.after(ff.literal(period), ff.property("dateAttr"));
    Map<String,Object> expected = ImmutableMap.of("range",
            ImmutableMap.of("dateAttr", ImmutableMap.of("lt", "1970-07-19T01:02:03.456Z")));

    builder.visit(filter, null);
    assertTrue(builder.createCapabilities().fullySupports(filter));
    assertEquals(expected, builder.getQueryBuilder());
}
 

@Test
public void testAfterFilterPeriod() throws ParseException {
    Date date1 = dateFormat.parse("1970-07-19T01:02:03.456Z");
    Instant temporalInstant = new DefaultInstant(new DefaultPosition(date1));
    Date date2 = dateFormat.parse("1970-07-19T07:08:09.101Z");
    Instant temporalInstant2 = new DefaultInstant(new DefaultPosition(date2));
    Period period = new DefaultPeriod(temporalInstant, temporalInstant2);
    After filter = ff.after(ff.property("dateAttr"), ff.literal(period));
    Map<String,Object> expected = ImmutableMap.of("range",
            ImmutableMap.of("dateAttr", ImmutableMap.of("gt", "1970-07-19T07:08:09.101Z")));

    builder.visit(filter, null);
    assertTrue(builder.createCapabilities().fullySupports(filter));
    assertEquals(expected, builder.getQueryBuilder());
}
 

@Test
public void testTContains() throws Exception {
    init();
    Period period = period("2004-19-06 03:44:56", "2004-20-06 03:44:58");
    FilterFactory ff = dataStore.getFilterFactory();
    Filter f = ff.tcontains(ff.literal(period), ff.property("installed_tdt"));
    SimpleFeatureCollection features = featureSource.getFeatures(f);
    assertEquals(1, features.size());
}
 

@Test
public void testDuring() throws Exception {
    init();
    Period period = period("2004-19-06 03:44:56", "2004-20-06 03:44:58");
    FilterFactory ff = dataStore.getFilterFactory();
    Filter f = ff.during(ff.property("installed_tdt"), ff.literal(period));
    SimpleFeatureCollection features = featureSource.getFeatures(f);
    assertEquals(1, features.size());
}
 

@Test
public void testEndedBy() throws Exception {
    init();
    Period period = period("2004-11-06 03:44:56", "2004-20-06 03:44:56");
    FilterFactory ff = dataStore.getFilterFactory();
    Filter f = ff.endedBy(ff.literal(period), ff.property("installed_tdt"));
    SimpleFeatureCollection features = featureSource.getFeatures(f);
    assertEquals(1, features.size());
}
 

@Test
public void testEnds() throws Exception {
    init();
    Period period = period("2002-20-06 03:44:56", "2004-20-06 03:44:56");
    FilterFactory ff = dataStore.getFilterFactory();
    Filter f = ff.ends(ff.property("installed_tdt"), ff.literal(period));
    SimpleFeatureCollection features = featureSource.getFeatures(f);
    assertEquals(1, features.size());
}
 

@Test
public void testBegunBy() throws Exception {
    init();
    Period period = period("2004-20-06 03:44:56", "2014-22-06 03:44:56");
    FilterFactory ff = dataStore.getFilterFactory();
    Filter f = ff.begunBy(ff.literal(period), ff.property("installed_tdt"));
    SimpleFeatureCollection features = featureSource.getFeatures(f);
    assertEquals(1, features.size());
}
 

@Test
public void testBegins() throws Exception {
    init();
    Period period = period("2004-20-06 03:44:56", "2014-22-06 03:44:56");
    FilterFactory ff = dataStore.getFilterFactory();
    Filter f = ff.begins(ff.property("installed_tdt"), ff.literal(period));
    SimpleFeatureCollection features = featureSource.getFeatures(f);
    assertEquals(1, features.size());
}
 

@Test
public void testBeforeInterval() throws Exception {
    init();
    Period period = period("2000-12-11 00:00:00", "2011-05-21 00:00:00");
    FilterFactory ff = dataStore.getFilterFactory();
    Filter f = ff.before(ff.property("installed_tdt"), ff.literal(period));
    SimpleFeatureCollection features = featureSource.getFeatures(f);
    assertEquals(1, features.size());
}
 

@Test
public void testAfterInterval() throws Exception {
    init();
    Period period = period("2011-21-05 00:00:00", "2011-15-09 00:00:00");
    FilterFactory ff = dataStore.getFilterFactory();
    Filter f = ff.after(ff.property("installed_tdt"), ff.literal(period));
    SimpleFeatureCollection features = featureSource.getFeatures(f);
    assertEquals(4, features.size());
}
 

Period period(String d1, String d2) throws ParseException {
    return new DefaultPeriod(instant(d1), instant(d2));
}
 

private void visitEnd(Period p, Object extraData) {
    filterFactory.literal(p.getEnding().getPosition().getDate()).accept(this, extraData);
}
 

private void visitBegin(Period p, Object extraData) {
    filterFactory.literal(p.getBeginning().getPosition().getDate()).accept(this, extraData);
}