target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test public void testContains() { assertTrue(range.contains(7)); assertTrue(range.contains(1)); assertTrue(range.contains(10)); assertFalse(range.contains(0)); assertFalse(range.contains(-1)); assertFalse(range.contains(11)); }
|
public boolean contains(int number) { return number >= min && number <= max; }
|
IntRange implements Serializable { public boolean contains(int number) { return number >= min && number <= max; } }
|
IntRange implements Serializable { public boolean contains(int number) { return number >= min && number <= max; } IntRange(int min, int max); }
|
IntRange implements Serializable { public boolean contains(int number) { return number >= min && number <= max; } IntRange(int min, int max); int getMin(); int getMax(); boolean contains(int number); @Override int hashCode(); @Override boolean equals(Object other); @Override String toString(); }
|
IntRange implements Serializable { public boolean contains(int number) { return number >= min && number <= max; } IntRange(int min, int max); int getMin(); int getMax(); boolean contains(int number); @Override int hashCode(); @Override boolean equals(Object other); @Override String toString(); }
|
@Test public void testFindByProperties() { NamedParameters params = NamedParameters.create() .add("category", education) .add("code", "02"); List<Dictionary> results = repository.findByProperties(Dictionary.class, params); assertTrue(results.contains(graduate)); assertFalse(results.contains(undergraduate)); assertFalse(results.contains(male)); }
|
@Override public <T extends Entity> List<T> findByProperties(Class<T> clazz, NamedParameters properties) { CriteriaQuery criteriaQuery = new CriteriaQuery(this, clazz); for (Map.Entry<String, Object> each : properties.getParams().entrySet()) { criteriaQuery = criteriaQuery.eq(each.getKey(), each.getValue()); } return find(criteriaQuery); }
|
EntityRepositoryJpa implements EntityRepository { @Override public <T extends Entity> List<T> findByProperties(Class<T> clazz, NamedParameters properties) { CriteriaQuery criteriaQuery = new CriteriaQuery(this, clazz); for (Map.Entry<String, Object> each : properties.getParams().entrySet()) { criteriaQuery = criteriaQuery.eq(each.getKey(), each.getValue()); } return find(criteriaQuery); } }
|
EntityRepositoryJpa implements EntityRepository { @Override public <T extends Entity> List<T> findByProperties(Class<T> clazz, NamedParameters properties) { CriteriaQuery criteriaQuery = new CriteriaQuery(this, clazz); for (Map.Entry<String, Object> each : properties.getParams().entrySet()) { criteriaQuery = criteriaQuery.eq(each.getKey(), each.getValue()); } return find(criteriaQuery); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); }
|
EntityRepositoryJpa implements EntityRepository { @Override public <T extends Entity> List<T> findByProperties(Class<T> clazz, NamedParameters properties) { CriteriaQuery criteriaQuery = new CriteriaQuery(this, clazz); for (Map.Entry<String, Object> each : properties.getParams().entrySet()) { criteriaQuery = criteriaQuery.eq(each.getKey(), each.getValue()); } return find(criteriaQuery); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); }
|
EntityRepositoryJpa implements EntityRepository { @Override public <T extends Entity> List<T> findByProperties(Class<T> clazz, NamedParameters properties) { CriteriaQuery criteriaQuery = new CriteriaQuery(this, clazz); for (Map.Entry<String, Object> each : properties.getParams().entrySet()) { criteriaQuery = criteriaQuery.eq(each.getKey(), each.getValue()); } return find(criteriaQuery); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); }
|
@Test public void testEqualsObject() { IntRange range1 = new IntRange(1, 10); assertEquals(range1, range); range1 = new IntRange(1, 11); assertFalse(range1.equals(range)); range1 = new IntRange(2, 10); assertFalse(range1.equals(range)); }
|
@Override public boolean equals(Object other) { if (this == other) { return true; } if (!(other instanceof IntRange)) { return false; } IntRange that = (IntRange) other; return new EqualsBuilder().append(this.getMin(), that.getMin()) .append(this.getMax(), that.getMax()) .isEquals(); }
|
IntRange implements Serializable { @Override public boolean equals(Object other) { if (this == other) { return true; } if (!(other instanceof IntRange)) { return false; } IntRange that = (IntRange) other; return new EqualsBuilder().append(this.getMin(), that.getMin()) .append(this.getMax(), that.getMax()) .isEquals(); } }
|
IntRange implements Serializable { @Override public boolean equals(Object other) { if (this == other) { return true; } if (!(other instanceof IntRange)) { return false; } IntRange that = (IntRange) other; return new EqualsBuilder().append(this.getMin(), that.getMin()) .append(this.getMax(), that.getMax()) .isEquals(); } IntRange(int min, int max); }
|
IntRange implements Serializable { @Override public boolean equals(Object other) { if (this == other) { return true; } if (!(other instanceof IntRange)) { return false; } IntRange that = (IntRange) other; return new EqualsBuilder().append(this.getMin(), that.getMin()) .append(this.getMax(), that.getMax()) .isEquals(); } IntRange(int min, int max); int getMin(); int getMax(); boolean contains(int number); @Override int hashCode(); @Override boolean equals(Object other); @Override String toString(); }
|
IntRange implements Serializable { @Override public boolean equals(Object other) { if (this == other) { return true; } if (!(other instanceof IntRange)) { return false; } IntRange that = (IntRange) other; return new EqualsBuilder().append(this.getMin(), that.getMin()) .append(this.getMax(), that.getMax()) .isEquals(); } IntRange(int min, int max); int getMin(); int getMax(); boolean contains(int number); @Override int hashCode(); @Override boolean equals(Object other); @Override String toString(); }
|
@Test public void testToString() { assertEquals("[1 - 10]", range.toString()); }
|
@Override public String toString() { return "[" + min + " - " + max + "]"; }
|
IntRange implements Serializable { @Override public String toString() { return "[" + min + " - " + max + "]"; } }
|
IntRange implements Serializable { @Override public String toString() { return "[" + min + " - " + max + "]"; } IntRange(int min, int max); }
|
IntRange implements Serializable { @Override public String toString() { return "[" + min + " - " + max + "]"; } IntRange(int min, int max); int getMin(); int getMax(); boolean contains(int number); @Override int hashCode(); @Override boolean equals(Object other); @Override String toString(); }
|
IntRange implements Serializable { @Override public String toString() { return "[" + min + " - " + max + "]"; } IntRange(int min, int max); int getMin(); int getMax(); boolean contains(int number); @Override int hashCode(); @Override boolean equals(Object other); @Override String toString(); }
|
@Test public void notSerializeNulls() throws Exception { String result = "{\"prop1\":\"abc\",\"lastModified\":\"2002-12-11\",\"id\":\"anId\",\"occurredOn\":\"2002-04-11\",\"version\":1}"; assertThat(instance.serialize(event), is(result)); }
|
@Override public String serialize(Object anObject) { return gson.toJson(anObject); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); @Override String serialize(Object anObject); @Override T deserialize(String serializedString, Class<T> objectClass); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); @Override String serialize(Object anObject); @Override T deserialize(String serializedString, Class<T> objectClass); }
|
@Test public void serializeNulls() { instance = builder.serializeNulls().build(); String result = "{\"prop1\":\"abc\",\"prop2\":null,\"lastModified\":\"2002-12-11\",\"id\":\"anId\",\"occurredOn\":\"2002-04-11\",\"version\":1}"; assertThat(instance.serialize(event), is(result)); }
|
@Override public String serialize(Object anObject) { return gson.toJson(anObject); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); @Override String serialize(Object anObject); @Override T deserialize(String serializedString, Class<T> objectClass); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); @Override String serialize(Object anObject); @Override T deserialize(String serializedString, Class<T> objectClass); }
|
@Test public void prettyPrinting() { instance = builder.prettyPrinting().build(); String lineSeparator = System.getProperty("line.separator"); String result = String.format( "{\n \"prop1\": \"abc\",\n \"lastModified\": \"2002-12-11\",\n \"id\": \"anId\",\n \"occurredOn\": \"2002-04-11\",\n \"version\": 1\n}", lineSeparator, lineSeparator, lineSeparator, lineSeparator, lineSeparator); assertThat(instance.serialize(event), is(result)); }
|
@Override public String serialize(Object anObject) { return gson.toJson(anObject); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); @Override String serialize(Object anObject); @Override T deserialize(String serializedString, Class<T> objectClass); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); @Override String serialize(Object anObject); @Override T deserialize(String serializedString, Class<T> objectClass); }
|
@Test public void excludeFieldsNamed() throws Exception { String result = "{\"prop1\":\"abc\",\"lastModified\":\"2002-12-11\",\"id\":\"anId\",\"version\":1}"; instance = builder.excludeFieldsNamed("occurredOn").build(); assertThat(instance.serialize(event), is(result)); }
|
@Override public String serialize(Object anObject) { return gson.toJson(anObject); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); @Override String serialize(Object anObject); @Override T deserialize(String serializedString, Class<T> objectClass); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); @Override String serialize(Object anObject); @Override T deserialize(String serializedString, Class<T> objectClass); }
|
@Test public void excludeFieldsWithModifiers() { instance = builder.excludeFieldsWithModifiers(Modifier.PROTECTED, Modifier.TRANSIENT).build(); String result = "{\"prop1\":\"abc\",\"id\":\"anId\",\"occurredOn\":\"2002-04-11\",\"version\":1}"; assertThat(instance.serialize(event), is(result)); }
|
@Override public String serialize(Object anObject) { return gson.toJson(anObject); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); @Override String serialize(Object anObject); @Override T deserialize(String serializedString, Class<T> objectClass); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); @Override String serialize(Object anObject); @Override T deserialize(String serializedString, Class<T> objectClass); }
|
@Test public void deserialize() throws Exception { String eventBody = "{\"prop1\":\"abc\",\"prop2\":null,\"lastModified\":\"2002-12-11\",\"id\":\"anId\",\"occurredOn\":\"2002-04-11\",\"version\":1}"; DomainEventSub result = instance.deserialize(eventBody, DomainEventSub.class); assertThat(result.getOccurredOn(), is(event.getOccurredOn())); assertThat(result.getProp1(), is(event.getProp1())); assertThat(result.getVersion(), is(event.getVersion())); assertNull(result.getProp2()); }
|
@Override public <T> T deserialize(String serializedString, Class<T> objectClass) { return gson.fromJson(serializedString, objectClass); }
|
GsonSerializer implements ObjectSerializer { @Override public <T> T deserialize(String serializedString, Class<T> objectClass) { return gson.fromJson(serializedString, objectClass); } }
|
GsonSerializer implements ObjectSerializer { @Override public <T> T deserialize(String serializedString, Class<T> objectClass) { return gson.fromJson(serializedString, objectClass); } GsonSerializer(); GsonSerializer(Gson gson); }
|
GsonSerializer implements ObjectSerializer { @Override public <T> T deserialize(String serializedString, Class<T> objectClass) { return gson.fromJson(serializedString, objectClass); } GsonSerializer(); GsonSerializer(Gson gson); @Override String serialize(Object anObject); @Override T deserialize(String serializedString, Class<T> objectClass); }
|
GsonSerializer implements ObjectSerializer { @Override public <T> T deserialize(String serializedString, Class<T> objectClass) { return gson.fromJson(serializedString, objectClass); } GsonSerializer(); GsonSerializer(Gson gson); @Override String serialize(Object anObject); @Override T deserialize(String serializedString, Class<T> objectClass); }
|
@Test public void test() { DictionaryCategory category = new DictionaryCategory(); category.setName("a category"); category.setSortOrder(1); category.setId(3L); Dictionary dictionary1 = new Dictionary("01", "男", category); Dictionary dictionary2 = new Dictionary("01", "男", category); Set<Dictionary> dictionaries = new HashSet<Dictionary>(); dictionaries.add(dictionary1); dictionaries.add(dictionary2); category.setDictionaries(dictionaries); System.out.println(instance.serialize(category)); }
|
@Override public String serialize(Object anObject) { return gson.toJson(anObject); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); @Override String serialize(Object anObject); @Override T deserialize(String serializedString, Class<T> objectClass); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); @Override String serialize(Object anObject); @Override T deserialize(String serializedString, Class<T> objectClass); }
|
@Test public void registerTypeAdapter() { builder = builder.registerTypeAdapter(Date.class, new JsonSerializer<Date>() { @Override public JsonElement serialize(Date source, Type typeOfSource, JsonSerializationContext context) { return new JsonPrimitive(source.getTime()); } }); instance = builder.build(); String result = "{\"prop1\":\"abc\",\"lastModified\":1039536000000,\"id\":\"anId\",\"occurredOn\":1018454400000,\"version\":1}"; assertThat(instance.serialize(event), is(result)); }
|
@Override public String serialize(Object anObject) { return gson.toJson(anObject); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); @Override String serialize(Object anObject); @Override T deserialize(String serializedString, Class<T> objectClass); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); @Override String serialize(Object anObject); @Override T deserialize(String serializedString, Class<T> objectClass); }
|
@Test public void testGetQueryStringOfNamedQuery() { NamedQueryParser namedQueryParser = mock(NamedQueryParser.class); repository.setNamedQueryParser(namedQueryParser); when(namedQueryParser.getQueryStringOfNamedQuery("Dictionay.findNameAndOrder")) .thenReturn("select o.code, o.text from Dictionary o where o.category = :category"); assertEquals("select o.code, o.text from Dictionary o where o.category = :category", repository.getQueryStringOfNamedQuery("Dictionay.findNameAndOrder")); }
|
@Override public String getQueryStringOfNamedQuery(String queryName) { return getNamedQueryParser().getQueryStringOfNamedQuery(queryName); }
|
EntityRepositoryJpa implements EntityRepository { @Override public String getQueryStringOfNamedQuery(String queryName) { return getNamedQueryParser().getQueryStringOfNamedQuery(queryName); } }
|
EntityRepositoryJpa implements EntityRepository { @Override public String getQueryStringOfNamedQuery(String queryName) { return getNamedQueryParser().getQueryStringOfNamedQuery(queryName); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); }
|
EntityRepositoryJpa implements EntityRepository { @Override public String getQueryStringOfNamedQuery(String queryName) { return getNamedQueryParser().getQueryStringOfNamedQuery(queryName); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); }
|
EntityRepositoryJpa implements EntityRepository { @Override public String getQueryStringOfNamedQuery(String queryName) { return getNamedQueryParser().getQueryStringOfNamedQuery(queryName); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); }
|
@Test public void addSerializationExclusionStrategy() { builder = builder.addSerializationExclusionStrategy(new FieldNameExclusionStrategy("occurredOn")); String result = "{\"prop1\":\"abc\",\"lastModified\":\"2002-12-11\",\"id\":\"anId\",\"version\":1}"; instance = builder.build(); assertThat(instance.serialize(event), is(result)); }
|
@Override public String serialize(Object anObject) { return gson.toJson(anObject); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); @Override String serialize(Object anObject); @Override T deserialize(String serializedString, Class<T> objectClass); }
|
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); @Override String serialize(Object anObject); @Override T deserialize(String serializedString, Class<T> objectClass); }
|
@Test public void addDeserializationExclusionStrategy() { builder = builder.addDeserializationExclusionStrategy(new FieldNameExclusionStrategy("version")); instance = builder.build(); String eventBody = "{\"prop1\":\"abc\",\"lastModified\":\"2002-12-11\",\"id\":\"anId\",\"occurredOn\":\"2002-04-11\",\"version\":100}"; DomainEventSub result = instance.deserialize(eventBody, DomainEventSub.class); assertThat(result.getOccurredOn(), is(DateUtils.date(2002, 4, 11))); assertThat(result.getLastModified(), is(DateUtils.date(2002, 12, 11))); assertThat(result.getProp1(), is("abc")); assertNull(result.getProp2()); assertThat(result.getId(), is("anId")); assertThat(result.getVersion(), is(not(100))); }
|
@Override public <T> T deserialize(String serializedString, Class<T> objectClass) { return gson.fromJson(serializedString, objectClass); }
|
GsonSerializer implements ObjectSerializer { @Override public <T> T deserialize(String serializedString, Class<T> objectClass) { return gson.fromJson(serializedString, objectClass); } }
|
GsonSerializer implements ObjectSerializer { @Override public <T> T deserialize(String serializedString, Class<T> objectClass) { return gson.fromJson(serializedString, objectClass); } GsonSerializer(); GsonSerializer(Gson gson); }
|
GsonSerializer implements ObjectSerializer { @Override public <T> T deserialize(String serializedString, Class<T> objectClass) { return gson.fromJson(serializedString, objectClass); } GsonSerializer(); GsonSerializer(Gson gson); @Override String serialize(Object anObject); @Override T deserialize(String serializedString, Class<T> objectClass); }
|
GsonSerializer implements ObjectSerializer { @Override public <T> T deserialize(String serializedString, Class<T> objectClass) { return gson.fromJson(serializedString, objectClass); } GsonSerializer(); GsonSerializer(Gson gson); @Override String serialize(Object anObject); @Override T deserialize(String serializedString, Class<T> objectClass); }
|
@Test public void testContains() throws ParseException { Date date = DateUtils.parseDate("2007-12-05 04:10:15", new String[] {"yyyy-M-d hh:mm:ss"}); assertTrue(range.contains(date)); date = DateUtils.parseDate("2007-12-15 23:10:15", new String[] {"yyyy-M-d hh:mm:ss"}); assertTrue(range.contains(date)); date = DateUtils.parseDate("2007-12-10 23:10:15", new String[] {"yyyy-M-d hh:mm:ss"}); assertTrue(range.contains(date)); date = DateUtils.parseDate("2007-11-10 23:10:15", new String[] {"yyyy-M-d hh:mm:ss"}); assertFalse(range.contains(date)); date = DateUtils.parseDate("2008-11-10 23:10:15", new String[] {"yyyy-M-d hh:mm:ss"}); assertFalse(range.contains(date)); }
|
public boolean contains(Date date) { return (date.after(from) || DateUtils.isSameDay(date, from)) && (date.before(to) || DateUtils.isSameDay(date, to)); }
|
DateRange implements Serializable { public boolean contains(Date date) { return (date.after(from) || DateUtils.isSameDay(date, from)) && (date.before(to) || DateUtils.isSameDay(date, to)); } }
|
DateRange implements Serializable { public boolean contains(Date date) { return (date.after(from) || DateUtils.isSameDay(date, from)) && (date.before(to) || DateUtils.isSameDay(date, to)); } DateRange(Date from, Date to); }
|
DateRange implements Serializable { public boolean contains(Date date) { return (date.after(from) || DateUtils.isSameDay(date, from)) && (date.before(to) || DateUtils.isSameDay(date, to)); } DateRange(Date from, Date to); Date getFrom(); Date getTo(); boolean contains(Date date); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
|
DateRange implements Serializable { public boolean contains(Date date) { return (date.after(from) || DateUtils.isSameDay(date, from)) && (date.before(to) || DateUtils.isSameDay(date, to)); } DateRange(Date from, Date to); Date getFrom(); Date getTo(); boolean contains(Date date); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
|
@Test public void testEqualsObject() throws ParseException { DateRange range1 = new DateRange( DateUtils.parseDate("2007-12-05 04:10:15", new String[] {"yyyy-M-d hh:mm:ss"}), DateUtils.parseDate("2007-12-15 23:11:15", new String[] {"yyyy-M-d hh:mm:ss"})); assertEquals(range1, range); range1 = new DateRange( DateUtils.parseDate("2007-12-6 11:29:15", new String[] {"yyyy-M-d hh:mm:ss"}), DateUtils.parseDate("2007-12-15 11:11:15", new String[] {"yyyy-M-d hh:mm:ss"})); assertFalse(range1.equals(range)); range1 = new DateRange( DateUtils.parseDate("2007-12-5 11:29:15", new String[] {"yyyy-M-d hh:mm:ss"}), DateUtils.parseDate("2007-12-16 11:11:15", new String[] {"yyyy-M-d hh:mm:ss"})); assertFalse(range1.equals(range)); }
|
@Override public boolean equals(final Object other) { if (this == other) { return true; } if (!(other instanceof DateRange)) { return false; } DateRange that = (DateRange) other; return DateUtils.isSameDay(this.from, that.from) && DateUtils.isSameDay(this.to, that.to); }
|
DateRange implements Serializable { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (!(other instanceof DateRange)) { return false; } DateRange that = (DateRange) other; return DateUtils.isSameDay(this.from, that.from) && DateUtils.isSameDay(this.to, that.to); } }
|
DateRange implements Serializable { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (!(other instanceof DateRange)) { return false; } DateRange that = (DateRange) other; return DateUtils.isSameDay(this.from, that.from) && DateUtils.isSameDay(this.to, that.to); } DateRange(Date from, Date to); }
|
DateRange implements Serializable { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (!(other instanceof DateRange)) { return false; } DateRange that = (DateRange) other; return DateUtils.isSameDay(this.from, that.from) && DateUtils.isSameDay(this.to, that.to); } DateRange(Date from, Date to); Date getFrom(); Date getTo(); boolean contains(Date date); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
|
DateRange implements Serializable { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (!(other instanceof DateRange)) { return false; } DateRange that = (DateRange) other; return DateUtils.isSameDay(this.from, that.from) && DateUtils.isSameDay(this.to, that.to); } DateRange(Date from, Date to); Date getFrom(); Date getTo(); boolean contains(Date date); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
|
@Test public void testToString() throws ParseException { Date from = DateUtils.parseDate("2007-12-05 04:10:15", new String[] {"yyyy-M-d hh:mm:ss"}); Date to = DateUtils.parseDate("2007-12-15 23:10:15", new String[] {"yyyy-M-d hh:mm:ss"}); String fromString = DateFormat.getDateInstance().format(from); String toString = DateFormat.getDateInstance().format(to); assertEquals("[" + fromString + " - " + toString + "]", range.toString()); }
|
@Override public String toString() { return "[" + DateFormat.getDateInstance().format(from) + " - " + DateFormat.getDateInstance().format(to) + "]"; }
|
DateRange implements Serializable { @Override public String toString() { return "[" + DateFormat.getDateInstance().format(from) + " - " + DateFormat.getDateInstance().format(to) + "]"; } }
|
DateRange implements Serializable { @Override public String toString() { return "[" + DateFormat.getDateInstance().format(from) + " - " + DateFormat.getDateInstance().format(to) + "]"; } DateRange(Date from, Date to); }
|
DateRange implements Serializable { @Override public String toString() { return "[" + DateFormat.getDateInstance().format(from) + " - " + DateFormat.getDateInstance().format(to) + "]"; } DateRange(Date from, Date to); Date getFrom(); Date getTo(); boolean contains(Date date); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
|
DateRange implements Serializable { @Override public String toString() { return "[" + DateFormat.getDateInstance().format(from) + " - " + DateFormat.getDateInstance().format(to) + "]"; } DateRange(Date from, Date to); Date getFrom(); Date getTo(); boolean contains(Date date); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
|
@Test public void testGetPropTypes() { Map<String, Class<?>> types = instance.getPropTypes(); assertEquals(int.class, types.get("id")); assertEquals(String.class, types.get("name")); assertEquals(boolean.class, types.get("disabled")); assertEquals(double.class, types.get("price")); }
|
public Map<String, Class<?>> getPropTypes() { return beanClassUtils.getPropTypes(); }
|
BeanUtils { public Map<String, Class<?>> getPropTypes() { return beanClassUtils.getPropTypes(); } }
|
BeanUtils { public Map<String, Class<?>> getPropTypes() { return beanClassUtils.getPropTypes(); } BeanUtils(final Object bean); }
|
BeanUtils { public Map<String, Class<?>> getPropTypes() { return beanClassUtils.getPropTypes(); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
BeanUtils { public Map<String, Class<?>> getPropTypes() { return beanClassUtils.getPropTypes(); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
@Test public void testGetPropValues() { Map<String, Object> values = instance.getPropValues(); assertEquals(1, values.get("id")); assertEquals("abc", values.get("name")); assertNull(values.get("disabled")); assertEquals(12.5, (Double) values.get("price"), 0.001); }
|
public Map<String, Object> getPropValues() { return getPropValues(getReadablePropNames()); }
|
BeanUtils { public Map<String, Object> getPropValues() { return getPropValues(getReadablePropNames()); } }
|
BeanUtils { public Map<String, Object> getPropValues() { return getPropValues(getReadablePropNames()); } BeanUtils(final Object bean); }
|
BeanUtils { public Map<String, Object> getPropValues() { return getPropValues(getReadablePropNames()); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
BeanUtils { public Map<String, Object> getPropValues() { return getPropValues(getReadablePropNames()); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
@Test public void testGetPropNames() { assertTrue(instance.getPropNames().containsAll( Arrays.asList("id", "price", "name", "disabled"))); }
|
public Set<String> getPropNames() { return beanClassUtils.getPropNames(); }
|
BeanUtils { public Set<String> getPropNames() { return beanClassUtils.getPropNames(); } }
|
BeanUtils { public Set<String> getPropNames() { return beanClassUtils.getPropNames(); } BeanUtils(final Object bean); }
|
BeanUtils { public Set<String> getPropNames() { return beanClassUtils.getPropNames(); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
BeanUtils { public Set<String> getPropNames() { return beanClassUtils.getPropNames(); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
@Test public void testGetReadablePropNames() { Set<String> results = instance.getReadablePropNames(); assertTrue(results.containsAll( Arrays.asList("id", "price", "name"))); assertFalse(results.contains("disabled")); }
|
public Set<String> getReadablePropNames() { return beanClassUtils.getReadablePropNames(); }
|
BeanUtils { public Set<String> getReadablePropNames() { return beanClassUtils.getReadablePropNames(); } }
|
BeanUtils { public Set<String> getReadablePropNames() { return beanClassUtils.getReadablePropNames(); } BeanUtils(final Object bean); }
|
BeanUtils { public Set<String> getReadablePropNames() { return beanClassUtils.getReadablePropNames(); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
BeanUtils { public Set<String> getReadablePropNames() { return beanClassUtils.getReadablePropNames(); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
@Test public void testGetPropValuesExcludeName() { Map<String, Object> values = instance.getPropValuesExclude("id"); assertFalse(values.containsKey("id")); assertEquals("abc", values.get("name")); assertNull(values.get("disabled")); assertEquals(12.5, (Double) values.get("price"), 0.001); }
|
public Map<String, Object> getPropValuesExclude(String... excludePropNames) { return getPropValues(beanClassUtils.getReadablePropNamesExclude(excludePropNames)); }
|
BeanUtils { public Map<String, Object> getPropValuesExclude(String... excludePropNames) { return getPropValues(beanClassUtils.getReadablePropNamesExclude(excludePropNames)); } }
|
BeanUtils { public Map<String, Object> getPropValuesExclude(String... excludePropNames) { return getPropValues(beanClassUtils.getReadablePropNamesExclude(excludePropNames)); } BeanUtils(final Object bean); }
|
BeanUtils { public Map<String, Object> getPropValuesExclude(String... excludePropNames) { return getPropValues(beanClassUtils.getReadablePropNamesExclude(excludePropNames)); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
BeanUtils { public Map<String, Object> getPropValuesExclude(String... excludePropNames) { return getPropValues(beanClassUtils.getReadablePropNamesExclude(excludePropNames)); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
@Test public void testFlush() { String description = "Ha Ha Ha!"; male.setDescription(description); repository.flush(); Dictionary male1 = repository.get(Dictionary.class, male.getId()); assertEquals(description, male1.getDescription()); }
|
@Override public void flush() { getEntityManager().flush(); }
|
EntityRepositoryJpa implements EntityRepository { @Override public void flush() { getEntityManager().flush(); } }
|
EntityRepositoryJpa implements EntityRepository { @Override public void flush() { getEntityManager().flush(); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); }
|
EntityRepositoryJpa implements EntityRepository { @Override public void flush() { getEntityManager().flush(); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); }
|
EntityRepositoryJpa implements EntityRepository { @Override public void flush() { getEntityManager().flush(); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); }
|
@Test public void testGetPropValuesExcludeAnnotation() { Map<String, Object> values = instance.getPropValuesExclude(Deprecated.class); assertEquals(1, values.get("id")); assertEquals("abc", values.get("name")); assertNull(values.get("disabled")); assertFalse(values.containsKey("price")); }
|
public Map<String, Object> getPropValuesExclude(String... excludePropNames) { return getPropValues(beanClassUtils.getReadablePropNamesExclude(excludePropNames)); }
|
BeanUtils { public Map<String, Object> getPropValuesExclude(String... excludePropNames) { return getPropValues(beanClassUtils.getReadablePropNamesExclude(excludePropNames)); } }
|
BeanUtils { public Map<String, Object> getPropValuesExclude(String... excludePropNames) { return getPropValues(beanClassUtils.getReadablePropNamesExclude(excludePropNames)); } BeanUtils(final Object bean); }
|
BeanUtils { public Map<String, Object> getPropValuesExclude(String... excludePropNames) { return getPropValues(beanClassUtils.getReadablePropNamesExclude(excludePropNames)); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
BeanUtils { public Map<String, Object> getPropValuesExclude(String... excludePropNames) { return getPropValues(beanClassUtils.getReadablePropNamesExclude(excludePropNames)); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
@Test public void testGetPropValue() { assertEquals("abc", instance.getPropValue("name")); }
|
public Object getPropValue(String propName) { try { PropertyDescriptor propertyDescriptor = beanClassUtils.getPropertyDescriptors().get(propName); Method readMethod = propertyDescriptor.getReadMethod(); if (readMethod == null) { return null; } return readMethod.invoke(bean, new Object[]{}); } catch (Exception e) { throw new RuntimeException(e); } }
|
BeanUtils { public Object getPropValue(String propName) { try { PropertyDescriptor propertyDescriptor = beanClassUtils.getPropertyDescriptors().get(propName); Method readMethod = propertyDescriptor.getReadMethod(); if (readMethod == null) { return null; } return readMethod.invoke(bean, new Object[]{}); } catch (Exception e) { throw new RuntimeException(e); } } }
|
BeanUtils { public Object getPropValue(String propName) { try { PropertyDescriptor propertyDescriptor = beanClassUtils.getPropertyDescriptors().get(propName); Method readMethod = propertyDescriptor.getReadMethod(); if (readMethod == null) { return null; } return readMethod.invoke(bean, new Object[]{}); } catch (Exception e) { throw new RuntimeException(e); } } BeanUtils(final Object bean); }
|
BeanUtils { public Object getPropValue(String propName) { try { PropertyDescriptor propertyDescriptor = beanClassUtils.getPropertyDescriptors().get(propName); Method readMethod = propertyDescriptor.getReadMethod(); if (readMethod == null) { return null; } return readMethod.invoke(bean, new Object[]{}); } catch (Exception e) { throw new RuntimeException(e); } } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
BeanUtils { public Object getPropValue(String propName) { try { PropertyDescriptor propertyDescriptor = beanClassUtils.getPropertyDescriptors().get(propName); Method readMethod = propertyDescriptor.getReadMethod(); if (readMethod == null) { return null; } return readMethod.invoke(bean, new Object[]{}); } catch (Exception e) { throw new RuntimeException(e); } } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
@Test public void testSetPropValue() { instance.setPropValue("id", 1000); assertEquals(1, item.getId()); instance.setPropValue("price", 2015); assertEquals(2015, item.getPrice(), 0.0001); }
|
public void setPropValue(String key, Object value) { for (Map.Entry<String, PropertyDescriptor> entry : beanClassUtils.getPropertyDescriptors().entrySet()) { if (!entry.getKey().equals(key)) { continue; } PropertyDescriptor propertyDescriptor = entry.getValue(); Method writeMethod = propertyDescriptor.getWriteMethod(); if (writeMethod == null) { continue; } try { writeMethod.invoke(bean, value); } catch (Exception ex) { } } }
|
BeanUtils { public void setPropValue(String key, Object value) { for (Map.Entry<String, PropertyDescriptor> entry : beanClassUtils.getPropertyDescriptors().entrySet()) { if (!entry.getKey().equals(key)) { continue; } PropertyDescriptor propertyDescriptor = entry.getValue(); Method writeMethod = propertyDescriptor.getWriteMethod(); if (writeMethod == null) { continue; } try { writeMethod.invoke(bean, value); } catch (Exception ex) { } } } }
|
BeanUtils { public void setPropValue(String key, Object value) { for (Map.Entry<String, PropertyDescriptor> entry : beanClassUtils.getPropertyDescriptors().entrySet()) { if (!entry.getKey().equals(key)) { continue; } PropertyDescriptor propertyDescriptor = entry.getValue(); Method writeMethod = propertyDescriptor.getWriteMethod(); if (writeMethod == null) { continue; } try { writeMethod.invoke(bean, value); } catch (Exception ex) { } } } BeanUtils(final Object bean); }
|
BeanUtils { public void setPropValue(String key, Object value) { for (Map.Entry<String, PropertyDescriptor> entry : beanClassUtils.getPropertyDescriptors().entrySet()) { if (!entry.getKey().equals(key)) { continue; } PropertyDescriptor propertyDescriptor = entry.getValue(); Method writeMethod = propertyDescriptor.getWriteMethod(); if (writeMethod == null) { continue; } try { writeMethod.invoke(bean, value); } catch (Exception ex) { } } } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
BeanUtils { public void setPropValue(String key, Object value) { for (Map.Entry<String, PropertyDescriptor> entry : beanClassUtils.getPropertyDescriptors().entrySet()) { if (!entry.getKey().equals(key)) { continue; } PropertyDescriptor propertyDescriptor = entry.getValue(); Method writeMethod = propertyDescriptor.getWriteMethod(); if (writeMethod == null) { continue; } try { writeMethod.invoke(bean, value); } catch (Exception ex) { } } } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
@Test public void testPopulateWithMap() { Map<String, Object> properties = new HashMap<String, Object>(); properties.put("id", 1000); properties.put("name", "aaaa"); instance.populate(properties); assertEquals(1, item.getId()); assertEquals("aaaa", item.getName()); assertEquals(12.5, item.getPrice(), 0.0001); }
|
public void populate(Map<String, ? extends Object> properties) { for (Map.Entry<String, ? extends Object> entry : properties.entrySet()) { setPropValue(entry.getKey(), entry.getValue()); } }
|
BeanUtils { public void populate(Map<String, ? extends Object> properties) { for (Map.Entry<String, ? extends Object> entry : properties.entrySet()) { setPropValue(entry.getKey(), entry.getValue()); } } }
|
BeanUtils { public void populate(Map<String, ? extends Object> properties) { for (Map.Entry<String, ? extends Object> entry : properties.entrySet()) { setPropValue(entry.getKey(), entry.getValue()); } } BeanUtils(final Object bean); }
|
BeanUtils { public void populate(Map<String, ? extends Object> properties) { for (Map.Entry<String, ? extends Object> entry : properties.entrySet()) { setPropValue(entry.getKey(), entry.getValue()); } } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
BeanUtils { public void populate(Map<String, ? extends Object> properties) { for (Map.Entry<String, ? extends Object> entry : properties.entrySet()) { setPropValue(entry.getKey(), entry.getValue()); } } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
@Test public void testCopyPropertiesFrom() { Item item1 = new Item(12, "abc", true); ConcreteItem item2 = new ConcreteItem(20, "xyz", false); item2.setPrice(15.5); instance = new BeanUtils(item2); instance.copyPropertiesFrom(item1); assertEquals("abc", item2.getName()); assertEquals(15.5, item2.getPrice(), 0.0001); }
|
public void copyPropertiesFrom(Object otherBean) { copyProperties(otherBean, bean); }
|
BeanUtils { public void copyPropertiesFrom(Object otherBean) { copyProperties(otherBean, bean); } }
|
BeanUtils { public void copyPropertiesFrom(Object otherBean) { copyProperties(otherBean, bean); } BeanUtils(final Object bean); }
|
BeanUtils { public void copyPropertiesFrom(Object otherBean) { copyProperties(otherBean, bean); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
BeanUtils { public void copyPropertiesFrom(Object otherBean) { copyProperties(otherBean, bean); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
@Test public void testCopyPropertiesTo() { Item item1 = new Item(12, "abc", true); ConcreteItem item2 = new ConcreteItem(20, "xyz", false); item2.setPrice(15.5); instance = new BeanUtils(item2); instance.copyPropertiesTo(item1); assertEquals("xyz", item1.getName()); }
|
public void copyPropertiesTo(Object otherBean) { copyProperties(bean, otherBean); }
|
BeanUtils { public void copyPropertiesTo(Object otherBean) { copyProperties(bean, otherBean); } }
|
BeanUtils { public void copyPropertiesTo(Object otherBean) { copyProperties(bean, otherBean); } BeanUtils(final Object bean); }
|
BeanUtils { public void copyPropertiesTo(Object otherBean) { copyProperties(bean, otherBean); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
BeanUtils { public void copyPropertiesTo(Object otherBean) { copyProperties(bean, otherBean); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
@Test public void testCopyPropertiesFromWithExcludes() { Item item1 = new Item(12, "abc", true); ConcreteItem item2 = new ConcreteItem(20, "xyz", false); item2.setPrice(15.5); instance = new BeanUtils(item2); instance.copyPropertiesFrom(item1, "id"); assertEquals(20, item2.getId()); assertEquals("abc", item2.getName()); assertEquals(15.5, item2.getPrice(), 0.0001); }
|
public void copyPropertiesFrom(Object otherBean) { copyProperties(otherBean, bean); }
|
BeanUtils { public void copyPropertiesFrom(Object otherBean) { copyProperties(otherBean, bean); } }
|
BeanUtils { public void copyPropertiesFrom(Object otherBean) { copyProperties(otherBean, bean); } BeanUtils(final Object bean); }
|
BeanUtils { public void copyPropertiesFrom(Object otherBean) { copyProperties(otherBean, bean); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
BeanUtils { public void copyPropertiesFrom(Object otherBean) { copyProperties(otherBean, bean); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
@Test public void testCopyPropertiesToWithExcludes() { Item item1 = new Item(12, "abc", true); ConcreteItem item2 = new ConcreteItem(20, "xyz", false); item2.setPrice(15.5); instance = new BeanUtils(item2); instance.copyPropertiesTo(item1, "id"); assertEquals(20, item2.getId()); assertEquals("xyz", item1.getName()); }
|
public void copyPropertiesTo(Object otherBean) { copyProperties(bean, otherBean); }
|
BeanUtils { public void copyPropertiesTo(Object otherBean) { copyProperties(bean, otherBean); } }
|
BeanUtils { public void copyPropertiesTo(Object otherBean) { copyProperties(bean, otherBean); } BeanUtils(final Object bean); }
|
BeanUtils { public void copyPropertiesTo(Object otherBean) { copyProperties(bean, otherBean); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
BeanUtils { public void copyPropertiesTo(Object otherBean) { copyProperties(bean, otherBean); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
@Test public void testGetPropertyInfos() { Item item1 = new Item(12, "abc", true); ConcreteItem item2 = new ConcreteItem(20, "xyz", false); item2.setPrice(15.5); instance = new BeanUtils(item2); assertEquals(new PropertyInfo("id", int.class, 20), instance.getPropInfo("id")); assertEquals(new PropertyInfo("name", String.class, "xyz"), instance.getPropInfo("name")); assertEquals(new PropertyInfo("price", double.class, 15.5), instance.getPropInfo("price")); }
|
public PropertyInfo getPropInfo(String propName) { return getPropInfos().get(propName); }
|
BeanUtils { public PropertyInfo getPropInfo(String propName) { return getPropInfos().get(propName); } }
|
BeanUtils { public PropertyInfo getPropInfo(String propName) { return getPropInfos().get(propName); } BeanUtils(final Object bean); }
|
BeanUtils { public PropertyInfo getPropInfo(String propName) { return getPropInfos().get(propName); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
BeanUtils { public PropertyInfo getPropInfo(String propName) { return getPropInfos().get(propName); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); }
|
@Test public void testSubstract() { Item[] items = { new Item(1, "A"), new Item(2, "B"), new Item(1, "C") }; assertArrayEquals(new Object[]{1, 2, 1}, ArrayUtils.substract(items, "id")); assertArrayEquals(new Object[]{"A", "B", "C"}, ArrayUtils.substract(items, "name")); }
|
public static Object[] substract(Object[] items, String property) { Assert.notNull(items); Assert.notBlank(property, "property name must not empty!"); if (items.length == 0) { return new Object[0]; } Object[] results = new Object[items.length]; for (int i = 0; i < items.length; i++) { Object item = items[i]; Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results[i] = propValues.get(property); } return results; }
|
ArrayUtils { public static Object[] substract(Object[] items, String property) { Assert.notNull(items); Assert.notBlank(property, "property name must not empty!"); if (items.length == 0) { return new Object[0]; } Object[] results = new Object[items.length]; for (int i = 0; i < items.length; i++) { Object item = items[i]; Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results[i] = propValues.get(property); } return results; } }
|
ArrayUtils { public static Object[] substract(Object[] items, String property) { Assert.notNull(items); Assert.notBlank(property, "property name must not empty!"); if (items.length == 0) { return new Object[0]; } Object[] results = new Object[items.length]; for (int i = 0; i < items.length; i++) { Object item = items[i]; Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results[i] = propValues.get(property); } return results; } private ArrayUtils(); }
|
ArrayUtils { public static Object[] substract(Object[] items, String property) { Assert.notNull(items); Assert.notBlank(property, "property name must not empty!"); if (items.length == 0) { return new Object[0]; } Object[] results = new Object[items.length]; for (int i = 0; i < items.length; i++) { Object item = items[i]; Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results[i] = propValues.get(property); } return results; } private ArrayUtils(); static Object[] substract(Object[] items, String property); static String join(Object[] items, String property, String separator); }
|
ArrayUtils { public static Object[] substract(Object[] items, String property) { Assert.notNull(items); Assert.notBlank(property, "property name must not empty!"); if (items.length == 0) { return new Object[0]; } Object[] results = new Object[items.length]; for (int i = 0; i < items.length; i++) { Object item = items[i]; Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results[i] = propValues.get(property); } return results; } private ArrayUtils(); static Object[] substract(Object[] items, String property); static String join(Object[] items, String property, String separator); }
|
@Test public void testRefresh() { String text = "Ha Ha Ha!"; male.setText(text); repository.refresh(male); assertEquals("男", male.getText()); }
|
@Override public void refresh(Entity entity) { getEntityManager().refresh(entity); }
|
EntityRepositoryJpa implements EntityRepository { @Override public void refresh(Entity entity) { getEntityManager().refresh(entity); } }
|
EntityRepositoryJpa implements EntityRepository { @Override public void refresh(Entity entity) { getEntityManager().refresh(entity); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); }
|
EntityRepositoryJpa implements EntityRepository { @Override public void refresh(Entity entity) { getEntityManager().refresh(entity); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); }
|
EntityRepositoryJpa implements EntityRepository { @Override public void refresh(Entity entity) { getEntityManager().refresh(entity); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); }
|
@Test public void testSubstractEmpty() { assertEquals(ArrayUtils.substract(new Item[]{}, "name").length, 0); }
|
public static Object[] substract(Object[] items, String property) { Assert.notNull(items); Assert.notBlank(property, "property name must not empty!"); if (items.length == 0) { return new Object[0]; } Object[] results = new Object[items.length]; for (int i = 0; i < items.length; i++) { Object item = items[i]; Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results[i] = propValues.get(property); } return results; }
|
ArrayUtils { public static Object[] substract(Object[] items, String property) { Assert.notNull(items); Assert.notBlank(property, "property name must not empty!"); if (items.length == 0) { return new Object[0]; } Object[] results = new Object[items.length]; for (int i = 0; i < items.length; i++) { Object item = items[i]; Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results[i] = propValues.get(property); } return results; } }
|
ArrayUtils { public static Object[] substract(Object[] items, String property) { Assert.notNull(items); Assert.notBlank(property, "property name must not empty!"); if (items.length == 0) { return new Object[0]; } Object[] results = new Object[items.length]; for (int i = 0; i < items.length; i++) { Object item = items[i]; Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results[i] = propValues.get(property); } return results; } private ArrayUtils(); }
|
ArrayUtils { public static Object[] substract(Object[] items, String property) { Assert.notNull(items); Assert.notBlank(property, "property name must not empty!"); if (items.length == 0) { return new Object[0]; } Object[] results = new Object[items.length]; for (int i = 0; i < items.length; i++) { Object item = items[i]; Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results[i] = propValues.get(property); } return results; } private ArrayUtils(); static Object[] substract(Object[] items, String property); static String join(Object[] items, String property, String separator); }
|
ArrayUtils { public static Object[] substract(Object[] items, String property) { Assert.notNull(items); Assert.notBlank(property, "property name must not empty!"); if (items.length == 0) { return new Object[0]; } Object[] results = new Object[items.length]; for (int i = 0; i < items.length; i++) { Object item = items[i]; Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results[i] = propValues.get(property); } return results; } private ArrayUtils(); static Object[] substract(Object[] items, String property); static String join(Object[] items, String property, String separator); }
|
@Test public void testSubstractSingleElement() { Item[] items = { new Item(1, "A") }; assertArrayEquals(new Object[]{1}, ArrayUtils.substract(items, "id")); }
|
public static Object[] substract(Object[] items, String property) { Assert.notNull(items); Assert.notBlank(property, "property name must not empty!"); if (items.length == 0) { return new Object[0]; } Object[] results = new Object[items.length]; for (int i = 0; i < items.length; i++) { Object item = items[i]; Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results[i] = propValues.get(property); } return results; }
|
ArrayUtils { public static Object[] substract(Object[] items, String property) { Assert.notNull(items); Assert.notBlank(property, "property name must not empty!"); if (items.length == 0) { return new Object[0]; } Object[] results = new Object[items.length]; for (int i = 0; i < items.length; i++) { Object item = items[i]; Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results[i] = propValues.get(property); } return results; } }
|
ArrayUtils { public static Object[] substract(Object[] items, String property) { Assert.notNull(items); Assert.notBlank(property, "property name must not empty!"); if (items.length == 0) { return new Object[0]; } Object[] results = new Object[items.length]; for (int i = 0; i < items.length; i++) { Object item = items[i]; Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results[i] = propValues.get(property); } return results; } private ArrayUtils(); }
|
ArrayUtils { public static Object[] substract(Object[] items, String property) { Assert.notNull(items); Assert.notBlank(property, "property name must not empty!"); if (items.length == 0) { return new Object[0]; } Object[] results = new Object[items.length]; for (int i = 0; i < items.length; i++) { Object item = items[i]; Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results[i] = propValues.get(property); } return results; } private ArrayUtils(); static Object[] substract(Object[] items, String property); static String join(Object[] items, String property, String separator); }
|
ArrayUtils { public static Object[] substract(Object[] items, String property) { Assert.notNull(items); Assert.notBlank(property, "property name must not empty!"); if (items.length == 0) { return new Object[0]; } Object[] results = new Object[items.length]; for (int i = 0; i < items.length; i++) { Object item = items[i]; Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results[i] = propValues.get(property); } return results; } private ArrayUtils(); static Object[] substract(Object[] items, String property); static String join(Object[] items, String property, String separator); }
|
@Test(expected = IllegalArgumentException.class) public void testPropertyNotExists() { Item[] items = { new Item(1, "A"), new Item(2, "B"), new Item(1, "C") }; ArrayUtils.substract(items, "birthday"); }
|
public static Object[] substract(Object[] items, String property) { Assert.notNull(items); Assert.notBlank(property, "property name must not empty!"); if (items.length == 0) { return new Object[0]; } Object[] results = new Object[items.length]; for (int i = 0; i < items.length; i++) { Object item = items[i]; Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results[i] = propValues.get(property); } return results; }
|
ArrayUtils { public static Object[] substract(Object[] items, String property) { Assert.notNull(items); Assert.notBlank(property, "property name must not empty!"); if (items.length == 0) { return new Object[0]; } Object[] results = new Object[items.length]; for (int i = 0; i < items.length; i++) { Object item = items[i]; Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results[i] = propValues.get(property); } return results; } }
|
ArrayUtils { public static Object[] substract(Object[] items, String property) { Assert.notNull(items); Assert.notBlank(property, "property name must not empty!"); if (items.length == 0) { return new Object[0]; } Object[] results = new Object[items.length]; for (int i = 0; i < items.length; i++) { Object item = items[i]; Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results[i] = propValues.get(property); } return results; } private ArrayUtils(); }
|
ArrayUtils { public static Object[] substract(Object[] items, String property) { Assert.notNull(items); Assert.notBlank(property, "property name must not empty!"); if (items.length == 0) { return new Object[0]; } Object[] results = new Object[items.length]; for (int i = 0; i < items.length; i++) { Object item = items[i]; Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results[i] = propValues.get(property); } return results; } private ArrayUtils(); static Object[] substract(Object[] items, String property); static String join(Object[] items, String property, String separator); }
|
ArrayUtils { public static Object[] substract(Object[] items, String property) { Assert.notNull(items); Assert.notBlank(property, "property name must not empty!"); if (items.length == 0) { return new Object[0]; } Object[] results = new Object[items.length]; for (int i = 0; i < items.length; i++) { Object item = items[i]; Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results[i] = propValues.get(property); } return results; } private ArrayUtils(); static Object[] substract(Object[] items, String property); static String join(Object[] items, String property, String separator); }
|
@Test public void testJoin() { Item[] items = { new Item(1, "A"), new Item(2, "B"), new Item(1, "C") }; String separator = ", "; String result = ArrayUtils.join(items, "id", separator); assertEquals("1, 2, 1", result); }
|
public static String join(Object[] items, String property, String separator) { if (items == null || items.length == 0) { return ""; } return StringUtils.join(substract(items, property), separator); }
|
ArrayUtils { public static String join(Object[] items, String property, String separator) { if (items == null || items.length == 0) { return ""; } return StringUtils.join(substract(items, property), separator); } }
|
ArrayUtils { public static String join(Object[] items, String property, String separator) { if (items == null || items.length == 0) { return ""; } return StringUtils.join(substract(items, property), separator); } private ArrayUtils(); }
|
ArrayUtils { public static String join(Object[] items, String property, String separator) { if (items == null || items.length == 0) { return ""; } return StringUtils.join(substract(items, property), separator); } private ArrayUtils(); static Object[] substract(Object[] items, String property); static String join(Object[] items, String property, String separator); }
|
ArrayUtils { public static String join(Object[] items, String property, String separator) { if (items == null || items.length == 0) { return ""; } return StringUtils.join(substract(items, property), separator); } private ArrayUtils(); static Object[] substract(Object[] items, String property); static String join(Object[] items, String property, String separator); }
|
@Test public void testJoinNull() { String separator = ", "; Item[] items = null; String result = ArrayUtils.join(items, "id", separator); assertTrue(result.isEmpty()); }
|
public static String join(Object[] items, String property, String separator) { if (items == null || items.length == 0) { return ""; } return StringUtils.join(substract(items, property), separator); }
|
ArrayUtils { public static String join(Object[] items, String property, String separator) { if (items == null || items.length == 0) { return ""; } return StringUtils.join(substract(items, property), separator); } }
|
ArrayUtils { public static String join(Object[] items, String property, String separator) { if (items == null || items.length == 0) { return ""; } return StringUtils.join(substract(items, property), separator); } private ArrayUtils(); }
|
ArrayUtils { public static String join(Object[] items, String property, String separator) { if (items == null || items.length == 0) { return ""; } return StringUtils.join(substract(items, property), separator); } private ArrayUtils(); static Object[] substract(Object[] items, String property); static String join(Object[] items, String property, String separator); }
|
ArrayUtils { public static String join(Object[] items, String property, String separator) { if (items == null || items.length == 0) { return ""; } return StringUtils.join(substract(items, property), separator); } private ArrayUtils(); static Object[] substract(Object[] items, String property); static String join(Object[] items, String property, String separator); }
|
@Test public void testJoinEmpty() { Item[] items = {}; String separator = ", "; String result = ArrayUtils.join(items, "id", separator); assertTrue(result.isEmpty()); }
|
public static String join(Object[] items, String property, String separator) { if (items == null || items.length == 0) { return ""; } return StringUtils.join(substract(items, property), separator); }
|
ArrayUtils { public static String join(Object[] items, String property, String separator) { if (items == null || items.length == 0) { return ""; } return StringUtils.join(substract(items, property), separator); } }
|
ArrayUtils { public static String join(Object[] items, String property, String separator) { if (items == null || items.length == 0) { return ""; } return StringUtils.join(substract(items, property), separator); } private ArrayUtils(); }
|
ArrayUtils { public static String join(Object[] items, String property, String separator) { if (items == null || items.length == 0) { return ""; } return StringUtils.join(substract(items, property), separator); } private ArrayUtils(); static Object[] substract(Object[] items, String property); static String join(Object[] items, String property, String separator); }
|
ArrayUtils { public static String join(Object[] items, String property, String separator) { if (items == null || items.length == 0) { return ""; } return StringUtils.join(substract(items, property), separator); } private ArrayUtils(); static Object[] substract(Object[] items, String property); static String join(Object[] items, String property, String separator); }
|
@Test public void testJoinSingleElement() { Item[] items = { new Item(1, "A") }; String separator = ", "; String result = ArrayUtils.join(items, "name", separator); assertEquals("A", result); }
|
public static String join(Object[] items, String property, String separator) { if (items == null || items.length == 0) { return ""; } return StringUtils.join(substract(items, property), separator); }
|
ArrayUtils { public static String join(Object[] items, String property, String separator) { if (items == null || items.length == 0) { return ""; } return StringUtils.join(substract(items, property), separator); } }
|
ArrayUtils { public static String join(Object[] items, String property, String separator) { if (items == null || items.length == 0) { return ""; } return StringUtils.join(substract(items, property), separator); } private ArrayUtils(); }
|
ArrayUtils { public static String join(Object[] items, String property, String separator) { if (items == null || items.length == 0) { return ""; } return StringUtils.join(substract(items, property), separator); } private ArrayUtils(); static Object[] substract(Object[] items, String property); static String join(Object[] items, String property, String separator); }
|
ArrayUtils { public static String join(Object[] items, String property, String separator) { if (items == null || items.length == 0) { return ""; } return StringUtils.join(substract(items, property), separator); } private ArrayUtils(); static Object[] substract(Object[] items, String property); static String join(Object[] items, String property, String separator); }
|
@Test public void testDate() throws ParseException { assertEquals(DateUtils.date(1968, 4, 11), org.apache.commons.lang3.time.DateUtils.parseDate("1968-04-11", "yyyy-MM-dd")); }
|
public static Date date(int year, int month, int day) { Calendar calendar = Calendar.getInstance(); calendar.set(year, month - 1, day, 0, 0, 0); calendar.set(Calendar.MILLISECOND, 0); return calendar.getTime(); }
|
DateUtils { public static Date date(int year, int month, int day) { Calendar calendar = Calendar.getInstance(); calendar.set(year, month - 1, day, 0, 0, 0); calendar.set(Calendar.MILLISECOND, 0); return calendar.getTime(); } }
|
DateUtils { public static Date date(int year, int month, int day) { Calendar calendar = Calendar.getInstance(); calendar.set(year, month - 1, day, 0, 0, 0); calendar.set(Calendar.MILLISECOND, 0); return calendar.getTime(); } private DateUtils(); }
|
DateUtils { public static Date date(int year, int month, int day) { Calendar calendar = Calendar.getInstance(); calendar.set(year, month - 1, day, 0, 0, 0); calendar.set(Calendar.MILLISECOND, 0); return calendar.getTime(); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); }
|
DateUtils { public static Date date(int year, int month, int day) { Calendar calendar = Calendar.getInstance(); calendar.set(year, month - 1, day, 0, 0, 0); calendar.set(Calendar.MILLISECOND, 0); return calendar.getTime(); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; }
|
@Test public void getYearDiff() { assertEquals(2009 - 1968, DateUtils.getYearDiff(parseDate("1968-4-16"), parseDate("2009-5-1"))); assertEquals(2009 - 1968 - 1, DateUtils.getYearDiff(parseDate("1968-4-16"), parseDate("2009-3-20"))); assertEquals(2009 - 1968, DateUtils.getYearDiff(parseDate("1968-4-16"), parseDate("2009-4-17"))); assertEquals(2009 - 1968, DateUtils.getYearDiff(parseDate("1968-4-16"), parseDate("2009-4-16"))); assertEquals(2009 - 1968 - 1, DateUtils.getYearDiff(parseDate("1968-4-16"), parseDate("2009-4-15"))); }
|
public static int getYearDiff(Date date1, Date date2) { if (date1 == null || date2 == null) { throw new InvalidParameterException( "date1 and date2 cannot be null!"); } if (date1.after(date2)) { throw new InvalidParameterException("date1 cannot be after date2!"); } Calendar calendar = Calendar.getInstance(); calendar.setTime(date1); int year1 = calendar.get(Calendar.YEAR); int month1 = calendar.get(Calendar.MONTH); int day1 = calendar.get(Calendar.DATE); calendar.setTime(date2); int year2 = calendar.get(Calendar.YEAR); int month2 = calendar.get(Calendar.MONTH); int day2 = calendar.get(Calendar.DATE); int result = year2 - year1; if (month2 < month1) { result--; } else if (month2 == month1 && day2 < day1) { result--; } return result; }
|
DateUtils { public static int getYearDiff(Date date1, Date date2) { if (date1 == null || date2 == null) { throw new InvalidParameterException( "date1 and date2 cannot be null!"); } if (date1.after(date2)) { throw new InvalidParameterException("date1 cannot be after date2!"); } Calendar calendar = Calendar.getInstance(); calendar.setTime(date1); int year1 = calendar.get(Calendar.YEAR); int month1 = calendar.get(Calendar.MONTH); int day1 = calendar.get(Calendar.DATE); calendar.setTime(date2); int year2 = calendar.get(Calendar.YEAR); int month2 = calendar.get(Calendar.MONTH); int day2 = calendar.get(Calendar.DATE); int result = year2 - year1; if (month2 < month1) { result--; } else if (month2 == month1 && day2 < day1) { result--; } return result; } }
|
DateUtils { public static int getYearDiff(Date date1, Date date2) { if (date1 == null || date2 == null) { throw new InvalidParameterException( "date1 and date2 cannot be null!"); } if (date1.after(date2)) { throw new InvalidParameterException("date1 cannot be after date2!"); } Calendar calendar = Calendar.getInstance(); calendar.setTime(date1); int year1 = calendar.get(Calendar.YEAR); int month1 = calendar.get(Calendar.MONTH); int day1 = calendar.get(Calendar.DATE); calendar.setTime(date2); int year2 = calendar.get(Calendar.YEAR); int month2 = calendar.get(Calendar.MONTH); int day2 = calendar.get(Calendar.DATE); int result = year2 - year1; if (month2 < month1) { result--; } else if (month2 == month1 && day2 < day1) { result--; } return result; } private DateUtils(); }
|
DateUtils { public static int getYearDiff(Date date1, Date date2) { if (date1 == null || date2 == null) { throw new InvalidParameterException( "date1 and date2 cannot be null!"); } if (date1.after(date2)) { throw new InvalidParameterException("date1 cannot be after date2!"); } Calendar calendar = Calendar.getInstance(); calendar.setTime(date1); int year1 = calendar.get(Calendar.YEAR); int month1 = calendar.get(Calendar.MONTH); int day1 = calendar.get(Calendar.DATE); calendar.setTime(date2); int year2 = calendar.get(Calendar.YEAR); int month2 = calendar.get(Calendar.MONTH); int day2 = calendar.get(Calendar.DATE); int result = year2 - year1; if (month2 < month1) { result--; } else if (month2 == month1 && day2 < day1) { result--; } return result; } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); }
|
DateUtils { public static int getYearDiff(Date date1, Date date2) { if (date1 == null || date2 == null) { throw new InvalidParameterException( "date1 and date2 cannot be null!"); } if (date1.after(date2)) { throw new InvalidParameterException("date1 cannot be after date2!"); } Calendar calendar = Calendar.getInstance(); calendar.setTime(date1); int year1 = calendar.get(Calendar.YEAR); int month1 = calendar.get(Calendar.MONTH); int day1 = calendar.get(Calendar.DATE); calendar.setTime(date2); int year2 = calendar.get(Calendar.YEAR); int month2 = calendar.get(Calendar.MONTH); int day2 = calendar.get(Calendar.DATE); int result = year2 - year1; if (month2 < month1) { result--; } else if (month2 == month1 && day2 < day1) { result--; } return result; } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; }
|
@Test public void getMonthDiff() { assertEquals(0, DateUtils.getMonthDiff(parseDate("1968-4-16"), parseDate("1968-4-30"))); assertEquals(0, DateUtils.getMonthDiff(parseDate("1968-4-16"), parseDate("1968-5-15"))); assertEquals(1, DateUtils.getMonthDiff(parseDate("1968-4-16"), parseDate("1968-5-16"))); assertEquals(1, DateUtils.getMonthDiff(parseDate("1968-4-16"), parseDate("1968-5-17"))); assertEquals(2, DateUtils.getMonthDiff(parseDate("1968-4-16"), parseDate("1968-6-16"))); assertEquals(24, DateUtils.getMonthDiff(parseDate("1968-4-16"), parseDate("1970-4-30"))); assertEquals(24, DateUtils.getMonthDiff(parseDate("1968-4-16"), parseDate("1970-5-15"))); assertEquals(25, DateUtils.getMonthDiff(parseDate("1968-4-16"), parseDate("1970-5-16"))); assertEquals(25, DateUtils.getMonthDiff(parseDate("1968-4-16"), parseDate("1970-5-17"))); assertEquals(26, DateUtils.getMonthDiff(parseDate("1968-4-16"), parseDate("1970-6-16"))); }
|
public static int getMonthDiff(Date date1, Date date2) { if (date1 == null || date2 == null) { throw new InvalidParameterException( "date1 and date2 cannot be null!"); } if (date1.after(date2)) { throw new InvalidParameterException("date1 cannot be after date2!"); } Calendar calendar = Calendar.getInstance(); calendar.setTime(date1); int year1 = calendar.get(Calendar.YEAR); int month1 = calendar.get(Calendar.MONTH); int day1 = calendar.get(Calendar.DATE); calendar.setTime(date2); int year2 = calendar.get(Calendar.YEAR); int month2 = calendar.get(Calendar.MONTH); int day2 = calendar.get(Calendar.DATE); int months = 0; if (day2 >= day1) { months = month2 - month1; } else { months = month2 - month1 - 1; } return (year2 - year1) * MONTHS_IN_A_YEAR + months; }
|
DateUtils { public static int getMonthDiff(Date date1, Date date2) { if (date1 == null || date2 == null) { throw new InvalidParameterException( "date1 and date2 cannot be null!"); } if (date1.after(date2)) { throw new InvalidParameterException("date1 cannot be after date2!"); } Calendar calendar = Calendar.getInstance(); calendar.setTime(date1); int year1 = calendar.get(Calendar.YEAR); int month1 = calendar.get(Calendar.MONTH); int day1 = calendar.get(Calendar.DATE); calendar.setTime(date2); int year2 = calendar.get(Calendar.YEAR); int month2 = calendar.get(Calendar.MONTH); int day2 = calendar.get(Calendar.DATE); int months = 0; if (day2 >= day1) { months = month2 - month1; } else { months = month2 - month1 - 1; } return (year2 - year1) * MONTHS_IN_A_YEAR + months; } }
|
DateUtils { public static int getMonthDiff(Date date1, Date date2) { if (date1 == null || date2 == null) { throw new InvalidParameterException( "date1 and date2 cannot be null!"); } if (date1.after(date2)) { throw new InvalidParameterException("date1 cannot be after date2!"); } Calendar calendar = Calendar.getInstance(); calendar.setTime(date1); int year1 = calendar.get(Calendar.YEAR); int month1 = calendar.get(Calendar.MONTH); int day1 = calendar.get(Calendar.DATE); calendar.setTime(date2); int year2 = calendar.get(Calendar.YEAR); int month2 = calendar.get(Calendar.MONTH); int day2 = calendar.get(Calendar.DATE); int months = 0; if (day2 >= day1) { months = month2 - month1; } else { months = month2 - month1 - 1; } return (year2 - year1) * MONTHS_IN_A_YEAR + months; } private DateUtils(); }
|
DateUtils { public static int getMonthDiff(Date date1, Date date2) { if (date1 == null || date2 == null) { throw new InvalidParameterException( "date1 and date2 cannot be null!"); } if (date1.after(date2)) { throw new InvalidParameterException("date1 cannot be after date2!"); } Calendar calendar = Calendar.getInstance(); calendar.setTime(date1); int year1 = calendar.get(Calendar.YEAR); int month1 = calendar.get(Calendar.MONTH); int day1 = calendar.get(Calendar.DATE); calendar.setTime(date2); int year2 = calendar.get(Calendar.YEAR); int month2 = calendar.get(Calendar.MONTH); int day2 = calendar.get(Calendar.DATE); int months = 0; if (day2 >= day1) { months = month2 - month1; } else { months = month2 - month1 - 1; } return (year2 - year1) * MONTHS_IN_A_YEAR + months; } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); }
|
DateUtils { public static int getMonthDiff(Date date1, Date date2) { if (date1 == null || date2 == null) { throw new InvalidParameterException( "date1 and date2 cannot be null!"); } if (date1.after(date2)) { throw new InvalidParameterException("date1 cannot be after date2!"); } Calendar calendar = Calendar.getInstance(); calendar.setTime(date1); int year1 = calendar.get(Calendar.YEAR); int month1 = calendar.get(Calendar.MONTH); int day1 = calendar.get(Calendar.DATE); calendar.setTime(date2); int year2 = calendar.get(Calendar.YEAR); int month2 = calendar.get(Calendar.MONTH); int day2 = calendar.get(Calendar.DATE); int months = 0; if (day2 >= day1) { months = month2 - month1; } else { months = month2 - month1 - 1; } return (year2 - year1) * MONTHS_IN_A_YEAR + months; } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; }
|
@Test public void testClear() { repository.clear(); }
|
@Override public void clear() { getEntityManager().clear(); }
|
EntityRepositoryJpa implements EntityRepository { @Override public void clear() { getEntityManager().clear(); } }
|
EntityRepositoryJpa implements EntityRepository { @Override public void clear() { getEntityManager().clear(); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); }
|
EntityRepositoryJpa implements EntityRepository { @Override public void clear() { getEntityManager().clear(); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); }
|
EntityRepositoryJpa implements EntityRepository { @Override public void clear() { getEntityManager().clear(); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); }
|
@Test public void getDayDiff() { assertEquals(31, DateUtils.getDayDiff(DateUtils.parseDate("2009-1-1"), DateUtils.parseDate("2009-2-1"))); assertEquals(2, DateUtils.getDayDiff(DateUtils.parseDate("2009-1-31"), DateUtils.parseDate("2009-2-2"))); }
|
public static int getDayDiff(Date date1, Date date2) { if (date1 == null || date2 == null) { throw new InvalidParameterException( "date1 and date2 cannot be null!"); } Date startDate = org.apache.commons.lang3.time.DateUtils.truncate( date1, Calendar.DATE); Date endDate = org.apache.commons.lang3.time.DateUtils.truncate(date2, Calendar.DATE); if (startDate.after(endDate)) { throw new InvalidParameterException("date1 cannot be after date2!"); } long millSecondsInOneDay = HOURS_IN_A_DAY * MINUTES_IN_AN_HOUR * SECONDS_IN_A_MINUTE * MILLIS_IN_A_SECOND; return (int) ((endDate.getTime() - startDate.getTime()) / millSecondsInOneDay); }
|
DateUtils { public static int getDayDiff(Date date1, Date date2) { if (date1 == null || date2 == null) { throw new InvalidParameterException( "date1 and date2 cannot be null!"); } Date startDate = org.apache.commons.lang3.time.DateUtils.truncate( date1, Calendar.DATE); Date endDate = org.apache.commons.lang3.time.DateUtils.truncate(date2, Calendar.DATE); if (startDate.after(endDate)) { throw new InvalidParameterException("date1 cannot be after date2!"); } long millSecondsInOneDay = HOURS_IN_A_DAY * MINUTES_IN_AN_HOUR * SECONDS_IN_A_MINUTE * MILLIS_IN_A_SECOND; return (int) ((endDate.getTime() - startDate.getTime()) / millSecondsInOneDay); } }
|
DateUtils { public static int getDayDiff(Date date1, Date date2) { if (date1 == null || date2 == null) { throw new InvalidParameterException( "date1 and date2 cannot be null!"); } Date startDate = org.apache.commons.lang3.time.DateUtils.truncate( date1, Calendar.DATE); Date endDate = org.apache.commons.lang3.time.DateUtils.truncate(date2, Calendar.DATE); if (startDate.after(endDate)) { throw new InvalidParameterException("date1 cannot be after date2!"); } long millSecondsInOneDay = HOURS_IN_A_DAY * MINUTES_IN_AN_HOUR * SECONDS_IN_A_MINUTE * MILLIS_IN_A_SECOND; return (int) ((endDate.getTime() - startDate.getTime()) / millSecondsInOneDay); } private DateUtils(); }
|
DateUtils { public static int getDayDiff(Date date1, Date date2) { if (date1 == null || date2 == null) { throw new InvalidParameterException( "date1 and date2 cannot be null!"); } Date startDate = org.apache.commons.lang3.time.DateUtils.truncate( date1, Calendar.DATE); Date endDate = org.apache.commons.lang3.time.DateUtils.truncate(date2, Calendar.DATE); if (startDate.after(endDate)) { throw new InvalidParameterException("date1 cannot be after date2!"); } long millSecondsInOneDay = HOURS_IN_A_DAY * MINUTES_IN_AN_HOUR * SECONDS_IN_A_MINUTE * MILLIS_IN_A_SECOND; return (int) ((endDate.getTime() - startDate.getTime()) / millSecondsInOneDay); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); }
|
DateUtils { public static int getDayDiff(Date date1, Date date2) { if (date1 == null || date2 == null) { throw new InvalidParameterException( "date1 and date2 cannot be null!"); } Date startDate = org.apache.commons.lang3.time.DateUtils.truncate( date1, Calendar.DATE); Date endDate = org.apache.commons.lang3.time.DateUtils.truncate(date2, Calendar.DATE); if (startDate.after(endDate)) { throw new InvalidParameterException("date1 cannot be after date2!"); } long millSecondsInOneDay = HOURS_IN_A_DAY * MINUTES_IN_AN_HOUR * SECONDS_IN_A_MINUTE * MILLIS_IN_A_SECOND; return (int) ((endDate.getTime() - startDate.getTime()) / millSecondsInOneDay); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; }
|
@Test public void getMinuteDiffByTime() { Date time1 = getTime("12:15"); Date time2 = getTime("14:14"); Date time3 = getTime("14:15"); Date time4 = getTime("14:16"); assertEquals(1, DateUtils.getMinuteDiffByTime(time1, time2)); assertEquals(2, DateUtils.getMinuteDiffByTime(time1, time3)); assertEquals(2, DateUtils.getMinuteDiffByTime(time1, time4)); }
|
public static int getMinuteDiffByTime(Date time1, Date time2) { long startMil = 0; long endMil = 0; Calendar calendar = Calendar.getInstance(); calendar.setTime(time1); calendar.set(1900, 1, 1); startMil = calendar.getTimeInMillis(); calendar.setTime(time2); calendar.set(1900, 1, 1); endMil = calendar.getTimeInMillis(); return (int) ((endMil - startMil) / MILLIS_IN_A_SECOND / SECONDS_IN_A_MINUTE); }
|
DateUtils { public static int getMinuteDiffByTime(Date time1, Date time2) { long startMil = 0; long endMil = 0; Calendar calendar = Calendar.getInstance(); calendar.setTime(time1); calendar.set(1900, 1, 1); startMil = calendar.getTimeInMillis(); calendar.setTime(time2); calendar.set(1900, 1, 1); endMil = calendar.getTimeInMillis(); return (int) ((endMil - startMil) / MILLIS_IN_A_SECOND / SECONDS_IN_A_MINUTE); } }
|
DateUtils { public static int getMinuteDiffByTime(Date time1, Date time2) { long startMil = 0; long endMil = 0; Calendar calendar = Calendar.getInstance(); calendar.setTime(time1); calendar.set(1900, 1, 1); startMil = calendar.getTimeInMillis(); calendar.setTime(time2); calendar.set(1900, 1, 1); endMil = calendar.getTimeInMillis(); return (int) ((endMil - startMil) / MILLIS_IN_A_SECOND / SECONDS_IN_A_MINUTE); } private DateUtils(); }
|
DateUtils { public static int getMinuteDiffByTime(Date time1, Date time2) { long startMil = 0; long endMil = 0; Calendar calendar = Calendar.getInstance(); calendar.setTime(time1); calendar.set(1900, 1, 1); startMil = calendar.getTimeInMillis(); calendar.setTime(time2); calendar.set(1900, 1, 1); endMil = calendar.getTimeInMillis(); return (int) ((endMil - startMil) / MILLIS_IN_A_SECOND / SECONDS_IN_A_MINUTE); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); }
|
DateUtils { public static int getMinuteDiffByTime(Date time1, Date time2) { long startMil = 0; long endMil = 0; Calendar calendar = Calendar.getInstance(); calendar.setTime(time1); calendar.set(1900, 1, 1); startMil = calendar.getTimeInMillis(); calendar.setTime(time2); calendar.set(1900, 1, 1); endMil = calendar.getTimeInMillis(); return (int) ((endMil - startMil) / MILLIS_IN_A_SECOND / SECONDS_IN_A_MINUTE); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; }
|
@Test public void testIsDateAfter() { Date date1 = parseDateTime("2007-1-2 08:12:02"); Date date2 = parseDateTime("2007-1-1 18:12:02"); assertTrue(DateUtils.isDateAfter(date1, date2)); date1 = parseDateTime("2007-1-1 09:12:02"); date2 = parseDateTime("2007-1-1 08:12:02"); assertFalse(DateUtils.isDateAfter(date1, date2)); }
|
public static boolean isDateAfter(Date date1, Date date2) { Date theDate1 = org.apache.commons.lang3.time.DateUtils.truncate(date1, Calendar.DATE); Date theDate2 = org.apache.commons.lang3.time.DateUtils.truncate(date2, Calendar.DATE); return theDate1.after(theDate2); }
|
DateUtils { public static boolean isDateAfter(Date date1, Date date2) { Date theDate1 = org.apache.commons.lang3.time.DateUtils.truncate(date1, Calendar.DATE); Date theDate2 = org.apache.commons.lang3.time.DateUtils.truncate(date2, Calendar.DATE); return theDate1.after(theDate2); } }
|
DateUtils { public static boolean isDateAfter(Date date1, Date date2) { Date theDate1 = org.apache.commons.lang3.time.DateUtils.truncate(date1, Calendar.DATE); Date theDate2 = org.apache.commons.lang3.time.DateUtils.truncate(date2, Calendar.DATE); return theDate1.after(theDate2); } private DateUtils(); }
|
DateUtils { public static boolean isDateAfter(Date date1, Date date2) { Date theDate1 = org.apache.commons.lang3.time.DateUtils.truncate(date1, Calendar.DATE); Date theDate2 = org.apache.commons.lang3.time.DateUtils.truncate(date2, Calendar.DATE); return theDate1.after(theDate2); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); }
|
DateUtils { public static boolean isDateAfter(Date date1, Date date2) { Date theDate1 = org.apache.commons.lang3.time.DateUtils.truncate(date1, Calendar.DATE); Date theDate2 = org.apache.commons.lang3.time.DateUtils.truncate(date2, Calendar.DATE); return theDate1.after(theDate2); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; }
|
@Test public void testIsDateBefore() { Date date1 = parseDateTime("2007-1-2 08:12:02"); Date date2 = parseDateTime("2007-1-1 18:12:02"); assertTrue(DateUtils.isDateBefore(date2, date1)); date1 = parseDateTime("2007-1-1 09:12:02"); date2 = parseDateTime("2007-1-1 08:12:02"); assertFalse(DateUtils.isDateBefore(date2, date1)); }
|
public static boolean isDateBefore(Date date1, Date date2) { return isDateAfter(date2, date1); }
|
DateUtils { public static boolean isDateBefore(Date date1, Date date2) { return isDateAfter(date2, date1); } }
|
DateUtils { public static boolean isDateBefore(Date date1, Date date2) { return isDateAfter(date2, date1); } private DateUtils(); }
|
DateUtils { public static boolean isDateBefore(Date date1, Date date2) { return isDateAfter(date2, date1); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); }
|
DateUtils { public static boolean isDateBefore(Date date1, Date date2) { return isDateAfter(date2, date1); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; }
|
@Test public void testIsTimeAfter() { Date date1 = parseDateTime("2007-1-1 18:12:02"); Date date2 = parseDateTime("2007-1-2 08:12:02"); assertTrue(DateUtils.isTimeAfter(date1, date2)); date1 = parseDateTime("2007-1-2 08:12:02"); date2 = parseDateTime("2007-1-1 08:12:02"); assertFalse(DateUtils.isTimeAfter(date1, date2)); }
|
public static boolean isTimeAfter(Date time1, Date time2) { Calendar calendar1 = Calendar.getInstance(); calendar1.setTime(time1); calendar1.set(1900, 1, 1); Calendar calendar2 = Calendar.getInstance(); calendar2.setTime(time2); calendar2.set(1900, 1, 1); return calendar1.after(calendar2); }
|
DateUtils { public static boolean isTimeAfter(Date time1, Date time2) { Calendar calendar1 = Calendar.getInstance(); calendar1.setTime(time1); calendar1.set(1900, 1, 1); Calendar calendar2 = Calendar.getInstance(); calendar2.setTime(time2); calendar2.set(1900, 1, 1); return calendar1.after(calendar2); } }
|
DateUtils { public static boolean isTimeAfter(Date time1, Date time2) { Calendar calendar1 = Calendar.getInstance(); calendar1.setTime(time1); calendar1.set(1900, 1, 1); Calendar calendar2 = Calendar.getInstance(); calendar2.setTime(time2); calendar2.set(1900, 1, 1); return calendar1.after(calendar2); } private DateUtils(); }
|
DateUtils { public static boolean isTimeAfter(Date time1, Date time2) { Calendar calendar1 = Calendar.getInstance(); calendar1.setTime(time1); calendar1.set(1900, 1, 1); Calendar calendar2 = Calendar.getInstance(); calendar2.setTime(time2); calendar2.set(1900, 1, 1); return calendar1.after(calendar2); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); }
|
DateUtils { public static boolean isTimeAfter(Date time1, Date time2) { Calendar calendar1 = Calendar.getInstance(); calendar1.setTime(time1); calendar1.set(1900, 1, 1); Calendar calendar2 = Calendar.getInstance(); calendar2.setTime(time2); calendar2.set(1900, 1, 1); return calendar1.after(calendar2); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; }
|
@Test public void testIsTimeBefore() { Date date1 = parseDateTime("2007-1-1 18:12:02"); Date date2 = parseDateTime("2007-1-2 08:12:02"); assertTrue(DateUtils.isTimeBefore(date2, date1)); date1 = parseDateTime("2007-1-2 08:12:02"); date2 = parseDateTime("2007-1-1 08:12:02"); assertFalse(DateUtils.isTimeBefore(date2, date1)); }
|
public static boolean isTimeBefore(Date time1, Date time2) { return isTimeAfter(time2, time1); }
|
DateUtils { public static boolean isTimeBefore(Date time1, Date time2) { return isTimeAfter(time2, time1); } }
|
DateUtils { public static boolean isTimeBefore(Date time1, Date time2) { return isTimeAfter(time2, time1); } private DateUtils(); }
|
DateUtils { public static boolean isTimeBefore(Date time1, Date time2) { return isTimeAfter(time2, time1); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); }
|
DateUtils { public static boolean isTimeBefore(Date time1, Date time2) { return isTimeAfter(time2, time1); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; }
|
@Test public void getWeekDaysBetween() { Date fromDate = DateUtils.parseDate("2009-1-1"); Date toDate = DateUtils.parseDate("2009-2-1"); assertEquals(4, DateUtils.getWeekDaysBetween(fromDate, toDate, Calendar.SUNDAY)); assertEquals(4, DateUtils.getWeekDaysBetween(fromDate, toDate, Calendar.MONDAY)); assertEquals(4, DateUtils.getWeekDaysBetween(fromDate, toDate, Calendar.TUESDAY)); assertEquals(4, DateUtils.getWeekDaysBetween(fromDate, toDate, Calendar.WEDNESDAY)); assertEquals(5, DateUtils.getWeekDaysBetween(fromDate, toDate, Calendar.THURSDAY)); assertEquals(5, DateUtils.getWeekDaysBetween(fromDate, toDate, Calendar.FRIDAY)); assertEquals(5, DateUtils.getWeekDaysBetween(fromDate, toDate, Calendar.SATURDAY)); }
|
public static int getWeekDaysBetween(Date fromDate, Date toDate, int dayOfWeek) { int result = 0; Date firstDate = getFirstWeekdayBetween(fromDate, toDate, dayOfWeek); if (firstDate == null) { return 0; } Calendar aDay = Calendar.getInstance(); aDay.setTime(firstDate); while (aDay.getTime().before(toDate)) { result++; aDay.add(Calendar.DATE, DAYS_IN_A_WEEK); } return result; }
|
DateUtils { public static int getWeekDaysBetween(Date fromDate, Date toDate, int dayOfWeek) { int result = 0; Date firstDate = getFirstWeekdayBetween(fromDate, toDate, dayOfWeek); if (firstDate == null) { return 0; } Calendar aDay = Calendar.getInstance(); aDay.setTime(firstDate); while (aDay.getTime().before(toDate)) { result++; aDay.add(Calendar.DATE, DAYS_IN_A_WEEK); } return result; } }
|
DateUtils { public static int getWeekDaysBetween(Date fromDate, Date toDate, int dayOfWeek) { int result = 0; Date firstDate = getFirstWeekdayBetween(fromDate, toDate, dayOfWeek); if (firstDate == null) { return 0; } Calendar aDay = Calendar.getInstance(); aDay.setTime(firstDate); while (aDay.getTime().before(toDate)) { result++; aDay.add(Calendar.DATE, DAYS_IN_A_WEEK); } return result; } private DateUtils(); }
|
DateUtils { public static int getWeekDaysBetween(Date fromDate, Date toDate, int dayOfWeek) { int result = 0; Date firstDate = getFirstWeekdayBetween(fromDate, toDate, dayOfWeek); if (firstDate == null) { return 0; } Calendar aDay = Calendar.getInstance(); aDay.setTime(firstDate); while (aDay.getTime().before(toDate)) { result++; aDay.add(Calendar.DATE, DAYS_IN_A_WEEK); } return result; } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); }
|
DateUtils { public static int getWeekDaysBetween(Date fromDate, Date toDate, int dayOfWeek) { int result = 0; Date firstDate = getFirstWeekdayBetween(fromDate, toDate, dayOfWeek); if (firstDate == null) { return 0; } Calendar aDay = Calendar.getInstance(); aDay.setTime(firstDate); while (aDay.getTime().before(toDate)) { result++; aDay.add(Calendar.DATE, DAYS_IN_A_WEEK); } return result; } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; }
|
@Test public void getFirstWeekdayBetween() { Date fromDate = DateUtils.parseDate("2009-1-1"); Date toDate = DateUtils.parseDate("2009-2-1"); assertEquals(DateUtils.parseDate("2009-1-4"), DateUtils.getFirstWeekdayBetween(fromDate, toDate, Calendar.SUNDAY)); assertEquals(DateUtils.parseDate("2009-1-5"), DateUtils.getFirstWeekdayBetween(fromDate, toDate, Calendar.MONDAY)); assertEquals(DateUtils.parseDate("2009-1-6"), DateUtils.getFirstWeekdayBetween(fromDate, toDate, Calendar.TUESDAY)); assertEquals(DateUtils.parseDate("2009-1-7"), DateUtils.getFirstWeekdayBetween(fromDate, toDate, Calendar.WEDNESDAY)); assertEquals(DateUtils.parseDate("2009-1-1"), DateUtils.getFirstWeekdayBetween(fromDate, toDate, Calendar.THURSDAY)); assertEquals(DateUtils.parseDate("2009-1-2"), DateUtils.getFirstWeekdayBetween(fromDate, toDate, Calendar.FRIDAY)); assertEquals(DateUtils.parseDate("2009-1-3"), DateUtils.getFirstWeekdayBetween(fromDate, toDate, Calendar.SATURDAY)); }
|
public static Date getFirstWeekdayBetween(Date fromDate, Date toDate, int dayOfWeek) { Calendar aDay = Calendar.getInstance(); aDay.setTime(fromDate); while (aDay.getTime().before(toDate)) { if (aDay.get(Calendar.DAY_OF_WEEK) == dayOfWeek) { return aDay.getTime(); } aDay.add(Calendar.DATE, 1); } return null; }
|
DateUtils { public static Date getFirstWeekdayBetween(Date fromDate, Date toDate, int dayOfWeek) { Calendar aDay = Calendar.getInstance(); aDay.setTime(fromDate); while (aDay.getTime().before(toDate)) { if (aDay.get(Calendar.DAY_OF_WEEK) == dayOfWeek) { return aDay.getTime(); } aDay.add(Calendar.DATE, 1); } return null; } }
|
DateUtils { public static Date getFirstWeekdayBetween(Date fromDate, Date toDate, int dayOfWeek) { Calendar aDay = Calendar.getInstance(); aDay.setTime(fromDate); while (aDay.getTime().before(toDate)) { if (aDay.get(Calendar.DAY_OF_WEEK) == dayOfWeek) { return aDay.getTime(); } aDay.add(Calendar.DATE, 1); } return null; } private DateUtils(); }
|
DateUtils { public static Date getFirstWeekdayBetween(Date fromDate, Date toDate, int dayOfWeek) { Calendar aDay = Calendar.getInstance(); aDay.setTime(fromDate); while (aDay.getTime().before(toDate)) { if (aDay.get(Calendar.DAY_OF_WEEK) == dayOfWeek) { return aDay.getTime(); } aDay.add(Calendar.DATE, 1); } return null; } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); }
|
DateUtils { public static Date getFirstWeekdayBetween(Date fromDate, Date toDate, int dayOfWeek) { Calendar aDay = Calendar.getInstance(); aDay.setTime(fromDate); while (aDay.getTime().before(toDate)) { if (aDay.get(Calendar.DAY_OF_WEEK) == dayOfWeek) { return aDay.getTime(); } aDay.add(Calendar.DATE, 1); } return null; } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; }
|
@Test public void getDaysInYear() { assertEquals(366, DateUtils.getDaysInYear(2000)); assertEquals(365, DateUtils.getDaysInYear(2009)); }
|
public static int getDaysInYear(int year) { Calendar aDay = Calendar.getInstance(); aDay.set(year, 1, 1); Date from = aDay.getTime(); aDay.set(year + 1, 1, 1); Date to = aDay.getTime(); return getDayDiff(from, to); }
|
DateUtils { public static int getDaysInYear(int year) { Calendar aDay = Calendar.getInstance(); aDay.set(year, 1, 1); Date from = aDay.getTime(); aDay.set(year + 1, 1, 1); Date to = aDay.getTime(); return getDayDiff(from, to); } }
|
DateUtils { public static int getDaysInYear(int year) { Calendar aDay = Calendar.getInstance(); aDay.set(year, 1, 1); Date from = aDay.getTime(); aDay.set(year + 1, 1, 1); Date to = aDay.getTime(); return getDayDiff(from, to); } private DateUtils(); }
|
DateUtils { public static int getDaysInYear(int year) { Calendar aDay = Calendar.getInstance(); aDay.set(year, 1, 1); Date from = aDay.getTime(); aDay.set(year + 1, 1, 1); Date to = aDay.getTime(); return getDayDiff(from, to); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); }
|
DateUtils { public static int getDaysInYear(int year) { Calendar aDay = Calendar.getInstance(); aDay.set(year, 1, 1); Date from = aDay.getTime(); aDay.set(year + 1, 1, 1); Date to = aDay.getTime(); return getDayDiff(from, to); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; }
|
@Test public void getDaysInMonth() { assertEquals(29, DateUtils.getDaysInMonth(2000, Calendar.FEBRUARY)); assertEquals(28, DateUtils.getDaysInMonth(2009, Calendar.FEBRUARY)); assertEquals(31, DateUtils.getDaysInMonth(2009, Calendar.DECEMBER)); }
|
public static int getDaysInMonth(int year, int month) { Calendar aDay = Calendar.getInstance(); aDay.set(year, month, 1); Date from = aDay.getTime(); if (month == Calendar.DECEMBER) { aDay.set(year + 1, Calendar.JANUARY, 1); } else { aDay.set(year, month + 1, 1); } Date to = aDay.getTime(); return getDayDiff(from, to); }
|
DateUtils { public static int getDaysInMonth(int year, int month) { Calendar aDay = Calendar.getInstance(); aDay.set(year, month, 1); Date from = aDay.getTime(); if (month == Calendar.DECEMBER) { aDay.set(year + 1, Calendar.JANUARY, 1); } else { aDay.set(year, month + 1, 1); } Date to = aDay.getTime(); return getDayDiff(from, to); } }
|
DateUtils { public static int getDaysInMonth(int year, int month) { Calendar aDay = Calendar.getInstance(); aDay.set(year, month, 1); Date from = aDay.getTime(); if (month == Calendar.DECEMBER) { aDay.set(year + 1, Calendar.JANUARY, 1); } else { aDay.set(year, month + 1, 1); } Date to = aDay.getTime(); return getDayDiff(from, to); } private DateUtils(); }
|
DateUtils { public static int getDaysInMonth(int year, int month) { Calendar aDay = Calendar.getInstance(); aDay.set(year, month, 1); Date from = aDay.getTime(); if (month == Calendar.DECEMBER) { aDay.set(year + 1, Calendar.JANUARY, 1); } else { aDay.set(year, month + 1, 1); } Date to = aDay.getTime(); return getDayDiff(from, to); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); }
|
DateUtils { public static int getDaysInMonth(int year, int month) { Calendar aDay = Calendar.getInstance(); aDay.set(year, month, 1); Date from = aDay.getTime(); if (month == Calendar.DECEMBER) { aDay.set(year + 1, Calendar.JANUARY, 1); } else { aDay.set(year, month + 1, 1); } Date to = aDay.getTime(); return getDayDiff(from, to); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; }
|
@Test public void testDefaultConstructor() { InstanceFactory.bind(SessionFactory.class, sessionFactory); SessionProvider instance = new SessionProvider(); Session session2 = instance.getSession(); assertSame(session2, session); Session session3 = instance.getSession(); assertSame(session3, session); }
|
public Session getSession() { Session result = sessionHolder.get(); if (result != null && result.isOpen()) { return result; } result = getSessionFromIoC(); sessionHolder.set(result); return result; }
|
SessionProvider { public Session getSession() { Session result = sessionHolder.get(); if (result != null && result.isOpen()) { return result; } result = getSessionFromIoC(); sessionHolder.set(result); return result; } }
|
SessionProvider { public Session getSession() { Session result = sessionHolder.get(); if (result != null && result.isOpen()) { return result; } result = getSessionFromIoC(); sessionHolder.set(result); return result; } SessionProvider(); SessionProvider(Session session); SessionProvider(SessionFactory sessionFactory); }
|
SessionProvider { public Session getSession() { Session result = sessionHolder.get(); if (result != null && result.isOpen()) { return result; } result = getSessionFromIoC(); sessionHolder.set(result); return result; } SessionProvider(); SessionProvider(Session session); SessionProvider(SessionFactory sessionFactory); Session getSession(); }
|
SessionProvider { public Session getSession() { Session result = sessionHolder.get(); if (result != null && result.isOpen()) { return result; } result = getSessionFromIoC(); sessionHolder.set(result); return result; } SessionProvider(); SessionProvider(Session session); SessionProvider(SessionFactory sessionFactory); Session getSession(); }
|
@Test public void testParseDate() { Calendar calendar = Calendar.getInstance(); calendar.setTime(DateUtils.parseDate("1968-4-16")); assertEquals(1968, calendar.get(Calendar.YEAR)); assertEquals(3, calendar.get(Calendar.MONTH)); assertEquals(16, calendar.get(Calendar.DATE)); calendar.setTime(DateUtils.parseDate("1968-04-16")); assertEquals(1968, calendar.get(Calendar.YEAR)); assertEquals(3, calendar.get(Calendar.MONTH)); assertEquals(16, calendar.get(Calendar.DATE)); }
|
public static Date parseDate(String dateString) { try { return org.apache.commons.lang3.time.DateUtils.parseDate( dateString, new String[]{"yyyy-MM-dd", "yyyy-M-d", "yyyy-MM-d", "yyyy-M-dd"}); } catch (ParseException e) { return null; } }
|
DateUtils { public static Date parseDate(String dateString) { try { return org.apache.commons.lang3.time.DateUtils.parseDate( dateString, new String[]{"yyyy-MM-dd", "yyyy-M-d", "yyyy-MM-d", "yyyy-M-dd"}); } catch (ParseException e) { return null; } } }
|
DateUtils { public static Date parseDate(String dateString) { try { return org.apache.commons.lang3.time.DateUtils.parseDate( dateString, new String[]{"yyyy-MM-dd", "yyyy-M-d", "yyyy-MM-d", "yyyy-M-dd"}); } catch (ParseException e) { return null; } } private DateUtils(); }
|
DateUtils { public static Date parseDate(String dateString) { try { return org.apache.commons.lang3.time.DateUtils.parseDate( dateString, new String[]{"yyyy-MM-dd", "yyyy-M-d", "yyyy-MM-d", "yyyy-M-dd"}); } catch (ParseException e) { return null; } } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); }
|
DateUtils { public static Date parseDate(String dateString) { try { return org.apache.commons.lang3.time.DateUtils.parseDate( dateString, new String[]{"yyyy-MM-dd", "yyyy-M-d", "yyyy-MM-d", "yyyy-M-dd"}); } catch (ParseException e) { return null; } } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; }
|
@Test public void testParseTime() { Calendar calendar = Calendar.getInstance(); calendar.setTime(DateUtils.parseTime("02:04:06")); assertEquals(2, calendar.get(Calendar.HOUR)); assertEquals(4, calendar.get(Calendar.MINUTE)); assertEquals(6, calendar.get(Calendar.SECOND)); calendar.setTime(DateUtils.parseTime("2:4:6")); assertEquals(2, calendar.get(Calendar.HOUR)); assertEquals(4, calendar.get(Calendar.MINUTE)); assertEquals(6, calendar.get(Calendar.SECOND)); }
|
public static Date parseTime(String timeString) { try { return org.apache.commons.lang3.time.DateUtils.parseDate( timeString, new String[]{"hh:mm:ss", "h:m:s", "hh:mm", "h:m"}); } catch (ParseException e) { return null; } }
|
DateUtils { public static Date parseTime(String timeString) { try { return org.apache.commons.lang3.time.DateUtils.parseDate( timeString, new String[]{"hh:mm:ss", "h:m:s", "hh:mm", "h:m"}); } catch (ParseException e) { return null; } } }
|
DateUtils { public static Date parseTime(String timeString) { try { return org.apache.commons.lang3.time.DateUtils.parseDate( timeString, new String[]{"hh:mm:ss", "h:m:s", "hh:mm", "h:m"}); } catch (ParseException e) { return null; } } private DateUtils(); }
|
DateUtils { public static Date parseTime(String timeString) { try { return org.apache.commons.lang3.time.DateUtils.parseDate( timeString, new String[]{"hh:mm:ss", "h:m:s", "hh:mm", "h:m"}); } catch (ParseException e) { return null; } } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); }
|
DateUtils { public static Date parseTime(String timeString) { try { return org.apache.commons.lang3.time.DateUtils.parseDate( timeString, new String[]{"hh:mm:ss", "h:m:s", "hh:mm", "h:m"}); } catch (ParseException e) { return null; } } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; }
|
@Test public void testParseDateTime() { Calendar calendar = Calendar.getInstance(); calendar.setTime(DateUtils.parseDateTime("1968-04-16 02:04:06")); assertEquals(1968, calendar.get(Calendar.YEAR)); assertEquals(3, calendar.get(Calendar.MONTH)); assertEquals(16, calendar.get(Calendar.DATE)); assertEquals(2, calendar.get(Calendar.HOUR)); assertEquals(4, calendar.get(Calendar.MINUTE)); assertEquals(6, calendar.get(Calendar.SECOND)); calendar.setTime(DateUtils.parseDateTime("1968-4-16 2:4:6")); assertEquals(1968, calendar.get(Calendar.YEAR)); assertEquals(3, calendar.get(Calendar.MONTH)); assertEquals(16, calendar.get(Calendar.DATE)); assertEquals(2, calendar.get(Calendar.HOUR)); assertEquals(4, calendar.get(Calendar.MINUTE)); assertEquals(6, calendar.get(Calendar.SECOND)); calendar.setTime(DateUtils.parseDateTime("1968-04-16 2:4:6")); assertEquals(1968, calendar.get(Calendar.YEAR)); assertEquals(3, calendar.get(Calendar.MONTH)); assertEquals(16, calendar.get(Calendar.DATE)); assertEquals(2, calendar.get(Calendar.HOUR)); assertEquals(4, calendar.get(Calendar.MINUTE)); assertEquals(6, calendar.get(Calendar.SECOND)); calendar.setTime(DateUtils.parseDateTime("1968-04-16 2:4:6")); assertEquals(1968, calendar.get(Calendar.YEAR)); assertEquals(3, calendar.get(Calendar.MONTH)); assertEquals(16, calendar.get(Calendar.DATE)); assertEquals(2, calendar.get(Calendar.HOUR)); assertEquals(4, calendar.get(Calendar.MINUTE)); assertEquals(6, calendar.get(Calendar.SECOND)); }
|
public static Date parseDateTime(String timeString) { try { return org.apache.commons.lang3.time.DateUtils.parseDate( timeString, new String[]{"yyyy-MM-dd HH:mm:ss", "yyyy-M-d H:m:s", "yyyy-MM-dd H:m:s", "yyyy-M-d HH:mm:ss"}); } catch (ParseException e) { return null; } }
|
DateUtils { public static Date parseDateTime(String timeString) { try { return org.apache.commons.lang3.time.DateUtils.parseDate( timeString, new String[]{"yyyy-MM-dd HH:mm:ss", "yyyy-M-d H:m:s", "yyyy-MM-dd H:m:s", "yyyy-M-d HH:mm:ss"}); } catch (ParseException e) { return null; } } }
|
DateUtils { public static Date parseDateTime(String timeString) { try { return org.apache.commons.lang3.time.DateUtils.parseDate( timeString, new String[]{"yyyy-MM-dd HH:mm:ss", "yyyy-M-d H:m:s", "yyyy-MM-dd H:m:s", "yyyy-M-d HH:mm:ss"}); } catch (ParseException e) { return null; } } private DateUtils(); }
|
DateUtils { public static Date parseDateTime(String timeString) { try { return org.apache.commons.lang3.time.DateUtils.parseDate( timeString, new String[]{"yyyy-MM-dd HH:mm:ss", "yyyy-M-d H:m:s", "yyyy-MM-dd H:m:s", "yyyy-M-d HH:mm:ss"}); } catch (ParseException e) { return null; } } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); }
|
DateUtils { public static Date parseDateTime(String timeString) { try { return org.apache.commons.lang3.time.DateUtils.parseDate( timeString, new String[]{"yyyy-MM-dd HH:mm:ss", "yyyy-M-d H:m:s", "yyyy-MM-dd H:m:s", "yyyy-M-d HH:mm:ss"}); } catch (ParseException e) { return null; } } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; }
|
@Test public void dateAfter() { Date origDate = DateUtils.parseDate("2000-01-02"); assertEquals(DateUtils.parseDate("2000-01-05"), DateUtils.dateAfter(origDate, 3, Calendar.DATE)); assertEquals(DateUtils.parseDate("2003-01-02"), DateUtils.dateAfter(origDate, 3, Calendar.YEAR)); }
|
public static final Date dateAfter(Date origDate, int amount, int timeUnit) { Calendar calendar = Calendar.getInstance(); calendar.setTime(origDate); calendar.add(timeUnit, amount); return calendar.getTime(); }
|
DateUtils { public static final Date dateAfter(Date origDate, int amount, int timeUnit) { Calendar calendar = Calendar.getInstance(); calendar.setTime(origDate); calendar.add(timeUnit, amount); return calendar.getTime(); } }
|
DateUtils { public static final Date dateAfter(Date origDate, int amount, int timeUnit) { Calendar calendar = Calendar.getInstance(); calendar.setTime(origDate); calendar.add(timeUnit, amount); return calendar.getTime(); } private DateUtils(); }
|
DateUtils { public static final Date dateAfter(Date origDate, int amount, int timeUnit) { Calendar calendar = Calendar.getInstance(); calendar.setTime(origDate); calendar.add(timeUnit, amount); return calendar.getTime(); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); }
|
DateUtils { public static final Date dateAfter(Date origDate, int amount, int timeUnit) { Calendar calendar = Calendar.getInstance(); calendar.setTime(origDate); calendar.add(timeUnit, amount); return calendar.getTime(); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; }
|
@Test public void dateBefore() { Date origDate = DateUtils.parseDate("2000-01-05"); assertEquals(DateUtils.parseDate("2000-01-02"), DateUtils.dateBefore(origDate, 3, Calendar.DATE)); assertEquals(DateUtils.parseDate("1997-01-05"), DateUtils.dateBefore(origDate, 3, Calendar.YEAR)); }
|
public static final Date dateBefore(Date origDate, int amount, int timeUnit) { Calendar calendar = Calendar.getInstance(); calendar.setTime(origDate); calendar.add(timeUnit, -amount); return calendar.getTime(); }
|
DateUtils { public static final Date dateBefore(Date origDate, int amount, int timeUnit) { Calendar calendar = Calendar.getInstance(); calendar.setTime(origDate); calendar.add(timeUnit, -amount); return calendar.getTime(); } }
|
DateUtils { public static final Date dateBefore(Date origDate, int amount, int timeUnit) { Calendar calendar = Calendar.getInstance(); calendar.setTime(origDate); calendar.add(timeUnit, -amount); return calendar.getTime(); } private DateUtils(); }
|
DateUtils { public static final Date dateBefore(Date origDate, int amount, int timeUnit) { Calendar calendar = Calendar.getInstance(); calendar.setTime(origDate); calendar.add(timeUnit, -amount); return calendar.getTime(); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); }
|
DateUtils { public static final Date dateBefore(Date origDate, int amount, int timeUnit) { Calendar calendar = Calendar.getInstance(); calendar.setTime(origDate); calendar.add(timeUnit, -amount); return calendar.getTime(); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; }
|
@Test public void testGetPropTypes() { Map<String, Class<?>> types = instance.getPropTypes(); assertEquals(int.class, types.get("id")); assertEquals(String.class, types.get("name")); assertEquals(boolean.class, types.get("disabled")); assertEquals(double.class, types.get("price")); }
|
public Map<String, Class<?>> getPropTypes() { Map<String, Class<?>> results = new HashMap<String, Class<?>>(); for (Map.Entry<String, PropertyDescriptor> each : getPropertyDescriptors().entrySet()) { results.put(each.getKey(), each.getValue().getPropertyType()); } return results; }
|
BeanClassUtils { public Map<String, Class<?>> getPropTypes() { Map<String, Class<?>> results = new HashMap<String, Class<?>>(); for (Map.Entry<String, PropertyDescriptor> each : getPropertyDescriptors().entrySet()) { results.put(each.getKey(), each.getValue().getPropertyType()); } return results; } }
|
BeanClassUtils { public Map<String, Class<?>> getPropTypes() { Map<String, Class<?>> results = new HashMap<String, Class<?>>(); for (Map.Entry<String, PropertyDescriptor> each : getPropertyDescriptors().entrySet()) { results.put(each.getKey(), each.getValue().getPropertyType()); } return results; } BeanClassUtils(final Class<?> clazz); }
|
BeanClassUtils { public Map<String, Class<?>> getPropTypes() { Map<String, Class<?>> results = new HashMap<String, Class<?>>(); for (Map.Entry<String, PropertyDescriptor> each : getPropertyDescriptors().entrySet()) { results.put(each.getKey(), each.getValue().getPropertyType()); } return results; } BeanClassUtils(final Class<?> clazz); Map<String, Class<?>> getPropTypes(); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Set<String> getReadablePropNamesExclude(String... excludePropNames); Set<String> getReadablePropNamesExclude(Class<? extends Annotation>... excludeAnnotations); }
|
BeanClassUtils { public Map<String, Class<?>> getPropTypes() { Map<String, Class<?>> results = new HashMap<String, Class<?>>(); for (Map.Entry<String, PropertyDescriptor> each : getPropertyDescriptors().entrySet()) { results.put(each.getKey(), each.getValue().getPropertyType()); } return results; } BeanClassUtils(final Class<?> clazz); Map<String, Class<?>> getPropTypes(); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Set<String> getReadablePropNamesExclude(String... excludePropNames); Set<String> getReadablePropNamesExclude(Class<? extends Annotation>... excludeAnnotations); }
|
@Test public void testGetPropNames() { assertTrue(instance.getPropNames().containsAll( Arrays.asList("id", "price", "name", "disabled"))); }
|
public Set<String> getPropNames() { return getPropertyDescriptors().keySet(); }
|
BeanClassUtils { public Set<String> getPropNames() { return getPropertyDescriptors().keySet(); } }
|
BeanClassUtils { public Set<String> getPropNames() { return getPropertyDescriptors().keySet(); } BeanClassUtils(final Class<?> clazz); }
|
BeanClassUtils { public Set<String> getPropNames() { return getPropertyDescriptors().keySet(); } BeanClassUtils(final Class<?> clazz); Map<String, Class<?>> getPropTypes(); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Set<String> getReadablePropNamesExclude(String... excludePropNames); Set<String> getReadablePropNamesExclude(Class<? extends Annotation>... excludeAnnotations); }
|
BeanClassUtils { public Set<String> getPropNames() { return getPropertyDescriptors().keySet(); } BeanClassUtils(final Class<?> clazz); Map<String, Class<?>> getPropTypes(); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Set<String> getReadablePropNamesExclude(String... excludePropNames); Set<String> getReadablePropNamesExclude(Class<? extends Annotation>... excludeAnnotations); }
|
@Test public void testGetReadablePropNames() { Set<String> results = instance.getReadablePropNames(); assertTrue(results.containsAll( Arrays.asList("id", "price", "name"))); assertFalse(results.contains("disabled")); }
|
public Set<String> getReadablePropNames() { Set<String> results = new HashSet<String>(); for (Map.Entry<String, PropertyDescriptor> each : getPropertyDescriptors().entrySet()) { if (each.getValue().getReadMethod() == null) { continue; } results.add(each.getKey()); } return results; }
|
BeanClassUtils { public Set<String> getReadablePropNames() { Set<String> results = new HashSet<String>(); for (Map.Entry<String, PropertyDescriptor> each : getPropertyDescriptors().entrySet()) { if (each.getValue().getReadMethod() == null) { continue; } results.add(each.getKey()); } return results; } }
|
BeanClassUtils { public Set<String> getReadablePropNames() { Set<String> results = new HashSet<String>(); for (Map.Entry<String, PropertyDescriptor> each : getPropertyDescriptors().entrySet()) { if (each.getValue().getReadMethod() == null) { continue; } results.add(each.getKey()); } return results; } BeanClassUtils(final Class<?> clazz); }
|
BeanClassUtils { public Set<String> getReadablePropNames() { Set<String> results = new HashSet<String>(); for (Map.Entry<String, PropertyDescriptor> each : getPropertyDescriptors().entrySet()) { if (each.getValue().getReadMethod() == null) { continue; } results.add(each.getKey()); } return results; } BeanClassUtils(final Class<?> clazz); Map<String, Class<?>> getPropTypes(); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Set<String> getReadablePropNamesExclude(String... excludePropNames); Set<String> getReadablePropNamesExclude(Class<? extends Annotation>... excludeAnnotations); }
|
BeanClassUtils { public Set<String> getReadablePropNames() { Set<String> results = new HashSet<String>(); for (Map.Entry<String, PropertyDescriptor> each : getPropertyDescriptors().entrySet()) { if (each.getValue().getReadMethod() == null) { continue; } results.add(each.getKey()); } return results; } BeanClassUtils(final Class<?> clazz); Map<String, Class<?>> getPropTypes(); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Set<String> getReadablePropNamesExclude(String... excludePropNames); Set<String> getReadablePropNamesExclude(Class<? extends Annotation>... excludeAnnotations); }
|
@Test public void testGetReadablePropNamesexcludeName() { Set<String> results = instance.getReadablePropNamesExclude("id", "price"); assertTrue(results.containsAll( Arrays.asList("name"))); assertFalse(results.contains("id")); assertFalse(results.contains("price")); assertFalse(results.contains("disabled")); }
|
public Set<String> getReadablePropNamesExclude(String... excludePropNames) { List<String> propNamesExclude = Arrays.asList(excludePropNames); Set<String> results = new HashSet<String>(); for (String propName : getReadablePropNames()) { if (propNamesExclude.contains(propName)) { continue; } results.add(propName); } return results; }
|
BeanClassUtils { public Set<String> getReadablePropNamesExclude(String... excludePropNames) { List<String> propNamesExclude = Arrays.asList(excludePropNames); Set<String> results = new HashSet<String>(); for (String propName : getReadablePropNames()) { if (propNamesExclude.contains(propName)) { continue; } results.add(propName); } return results; } }
|
BeanClassUtils { public Set<String> getReadablePropNamesExclude(String... excludePropNames) { List<String> propNamesExclude = Arrays.asList(excludePropNames); Set<String> results = new HashSet<String>(); for (String propName : getReadablePropNames()) { if (propNamesExclude.contains(propName)) { continue; } results.add(propName); } return results; } BeanClassUtils(final Class<?> clazz); }
|
BeanClassUtils { public Set<String> getReadablePropNamesExclude(String... excludePropNames) { List<String> propNamesExclude = Arrays.asList(excludePropNames); Set<String> results = new HashSet<String>(); for (String propName : getReadablePropNames()) { if (propNamesExclude.contains(propName)) { continue; } results.add(propName); } return results; } BeanClassUtils(final Class<?> clazz); Map<String, Class<?>> getPropTypes(); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Set<String> getReadablePropNamesExclude(String... excludePropNames); Set<String> getReadablePropNamesExclude(Class<? extends Annotation>... excludeAnnotations); }
|
BeanClassUtils { public Set<String> getReadablePropNamesExclude(String... excludePropNames) { List<String> propNamesExclude = Arrays.asList(excludePropNames); Set<String> results = new HashSet<String>(); for (String propName : getReadablePropNames()) { if (propNamesExclude.contains(propName)) { continue; } results.add(propName); } return results; } BeanClassUtils(final Class<?> clazz); Map<String, Class<?>> getPropTypes(); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Set<String> getReadablePropNamesExclude(String... excludePropNames); Set<String> getReadablePropNamesExclude(Class<? extends Annotation>... excludeAnnotations); }
|
@Test public void testGetReadablePropNamesexcludeAnnotation() { Set<String> results = instance.getReadablePropNamesExclude(Deprecated.class); assertTrue(results.containsAll( Arrays.asList("name", "id"))); assertFalse(results.contains("price")); assertFalse(results.contains("disabled")); }
|
public Set<String> getReadablePropNamesExclude(String... excludePropNames) { List<String> propNamesExclude = Arrays.asList(excludePropNames); Set<String> results = new HashSet<String>(); for (String propName : getReadablePropNames()) { if (propNamesExclude.contains(propName)) { continue; } results.add(propName); } return results; }
|
BeanClassUtils { public Set<String> getReadablePropNamesExclude(String... excludePropNames) { List<String> propNamesExclude = Arrays.asList(excludePropNames); Set<String> results = new HashSet<String>(); for (String propName : getReadablePropNames()) { if (propNamesExclude.contains(propName)) { continue; } results.add(propName); } return results; } }
|
BeanClassUtils { public Set<String> getReadablePropNamesExclude(String... excludePropNames) { List<String> propNamesExclude = Arrays.asList(excludePropNames); Set<String> results = new HashSet<String>(); for (String propName : getReadablePropNames()) { if (propNamesExclude.contains(propName)) { continue; } results.add(propName); } return results; } BeanClassUtils(final Class<?> clazz); }
|
BeanClassUtils { public Set<String> getReadablePropNamesExclude(String... excludePropNames) { List<String> propNamesExclude = Arrays.asList(excludePropNames); Set<String> results = new HashSet<String>(); for (String propName : getReadablePropNames()) { if (propNamesExclude.contains(propName)) { continue; } results.add(propName); } return results; } BeanClassUtils(final Class<?> clazz); Map<String, Class<?>> getPropTypes(); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Set<String> getReadablePropNamesExclude(String... excludePropNames); Set<String> getReadablePropNamesExclude(Class<? extends Annotation>... excludeAnnotations); }
|
BeanClassUtils { public Set<String> getReadablePropNamesExclude(String... excludePropNames) { List<String> propNamesExclude = Arrays.asList(excludePropNames); Set<String> results = new HashSet<String>(); for (String propName : getReadablePropNames()) { if (propNamesExclude.contains(propName)) { continue; } results.add(propName); } return results; } BeanClassUtils(final Class<?> clazz); Map<String, Class<?>> getPropTypes(); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Set<String> getReadablePropNamesExclude(String... excludePropNames); Set<String> getReadablePropNamesExclude(Class<? extends Annotation>... excludeAnnotations); }
|
@Test public void testConstructorSessionFactory() { SessionProvider instance = new SessionProvider(sessionFactory); Session session2 = instance.getSession(); assertSame(session2, session); Session session3 = instance.getSession(); assertSame(session3, session); }
|
public Session getSession() { Session result = sessionHolder.get(); if (result != null && result.isOpen()) { return result; } result = getSessionFromIoC(); sessionHolder.set(result); return result; }
|
SessionProvider { public Session getSession() { Session result = sessionHolder.get(); if (result != null && result.isOpen()) { return result; } result = getSessionFromIoC(); sessionHolder.set(result); return result; } }
|
SessionProvider { public Session getSession() { Session result = sessionHolder.get(); if (result != null && result.isOpen()) { return result; } result = getSessionFromIoC(); sessionHolder.set(result); return result; } SessionProvider(); SessionProvider(Session session); SessionProvider(SessionFactory sessionFactory); }
|
SessionProvider { public Session getSession() { Session result = sessionHolder.get(); if (result != null && result.isOpen()) { return result; } result = getSessionFromIoC(); sessionHolder.set(result); return result; } SessionProvider(); SessionProvider(Session session); SessionProvider(SessionFactory sessionFactory); Session getSession(); }
|
SessionProvider { public Session getSession() { Session result = sessionHolder.get(); if (result != null && result.isOpen()) { return result; } result = getSessionFromIoC(); sessionHolder.set(result); return result; } SessionProvider(); SessionProvider(Session session); SessionProvider(SessionFactory sessionFactory); Session getSession(); }
|
@Test public void testGet() { assertEquals(male, repository.get(Dictionary.class, male.getId())); }
|
@Override public <T extends Entity> T get(final Class<T> clazz, final Serializable id) { return getEntityManager().find(clazz, id); }
|
EntityRepositoryJpa implements EntityRepository { @Override public <T extends Entity> T get(final Class<T> clazz, final Serializable id) { return getEntityManager().find(clazz, id); } }
|
EntityRepositoryJpa implements EntityRepository { @Override public <T extends Entity> T get(final Class<T> clazz, final Serializable id) { return getEntityManager().find(clazz, id); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); }
|
EntityRepositoryJpa implements EntityRepository { @Override public <T extends Entity> T get(final Class<T> clazz, final Serializable id) { return getEntityManager().find(clazz, id); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); }
|
EntityRepositoryJpa implements EntityRepository { @Override public <T extends Entity> T get(final Class<T> clazz, final Serializable id) { return getEntityManager().find(clazz, id); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); }
|
@Test public void testSubstract() { Collection<Item> items = new ArrayList<Item>(); items.add(new Item(1, "A")); items.add(new Item(2, "B")); items.add(new Item(1, "C")); assertEquals(Arrays.asList(1, 2, 1), CollectionUtils.substract(items, "id")); assertEquals(Arrays.asList("A", "B", "C"), CollectionUtils.substract(items, "name")); }
|
public static Collection<?> substract(Collection<?> items, String property) { if (items == null) { return null; } if (StringUtils.isEmpty(property)) { throw new IllegalArgumentException("property name must not empty!"); } Collection<Object> results = new ArrayList<Object>(); for (Object item : items) { Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results.add(propValues.get(property)); } return results; }
|
CollectionUtils { public static Collection<?> substract(Collection<?> items, String property) { if (items == null) { return null; } if (StringUtils.isEmpty(property)) { throw new IllegalArgumentException("property name must not empty!"); } Collection<Object> results = new ArrayList<Object>(); for (Object item : items) { Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results.add(propValues.get(property)); } return results; } }
|
CollectionUtils { public static Collection<?> substract(Collection<?> items, String property) { if (items == null) { return null; } if (StringUtils.isEmpty(property)) { throw new IllegalArgumentException("property name must not empty!"); } Collection<Object> results = new ArrayList<Object>(); for (Object item : items) { Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results.add(propValues.get(property)); } return results; } private CollectionUtils(); }
|
CollectionUtils { public static Collection<?> substract(Collection<?> items, String property) { if (items == null) { return null; } if (StringUtils.isEmpty(property)) { throw new IllegalArgumentException("property name must not empty!"); } Collection<Object> results = new ArrayList<Object>(); for (Object item : items) { Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results.add(propValues.get(property)); } return results; } private CollectionUtils(); static Collection<?> substract(Collection<?> items, String property); static String join(Collection<?> items, String property, String separator); }
|
CollectionUtils { public static Collection<?> substract(Collection<?> items, String property) { if (items == null) { return null; } if (StringUtils.isEmpty(property)) { throw new IllegalArgumentException("property name must not empty!"); } Collection<Object> results = new ArrayList<Object>(); for (Object item : items) { Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results.add(propValues.get(property)); } return results; } private CollectionUtils(); static Collection<?> substract(Collection<?> items, String property); static String join(Collection<?> items, String property, String separator); }
|
@Test public void testSubstractNull() { assertNull(CollectionUtils.substract(null, "name")); }
|
public static Collection<?> substract(Collection<?> items, String property) { if (items == null) { return null; } if (StringUtils.isEmpty(property)) { throw new IllegalArgumentException("property name must not empty!"); } Collection<Object> results = new ArrayList<Object>(); for (Object item : items) { Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results.add(propValues.get(property)); } return results; }
|
CollectionUtils { public static Collection<?> substract(Collection<?> items, String property) { if (items == null) { return null; } if (StringUtils.isEmpty(property)) { throw new IllegalArgumentException("property name must not empty!"); } Collection<Object> results = new ArrayList<Object>(); for (Object item : items) { Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results.add(propValues.get(property)); } return results; } }
|
CollectionUtils { public static Collection<?> substract(Collection<?> items, String property) { if (items == null) { return null; } if (StringUtils.isEmpty(property)) { throw new IllegalArgumentException("property name must not empty!"); } Collection<Object> results = new ArrayList<Object>(); for (Object item : items) { Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results.add(propValues.get(property)); } return results; } private CollectionUtils(); }
|
CollectionUtils { public static Collection<?> substract(Collection<?> items, String property) { if (items == null) { return null; } if (StringUtils.isEmpty(property)) { throw new IllegalArgumentException("property name must not empty!"); } Collection<Object> results = new ArrayList<Object>(); for (Object item : items) { Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results.add(propValues.get(property)); } return results; } private CollectionUtils(); static Collection<?> substract(Collection<?> items, String property); static String join(Collection<?> items, String property, String separator); }
|
CollectionUtils { public static Collection<?> substract(Collection<?> items, String property) { if (items == null) { return null; } if (StringUtils.isEmpty(property)) { throw new IllegalArgumentException("property name must not empty!"); } Collection<Object> results = new ArrayList<Object>(); for (Object item : items) { Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results.add(propValues.get(property)); } return results; } private CollectionUtils(); static Collection<?> substract(Collection<?> items, String property); static String join(Collection<?> items, String property, String separator); }
|
@Test public void testSubstractEmpty() { assertTrue(CollectionUtils.substract(Collections.EMPTY_LIST, "name").isEmpty()); }
|
public static Collection<?> substract(Collection<?> items, String property) { if (items == null) { return null; } if (StringUtils.isEmpty(property)) { throw new IllegalArgumentException("property name must not empty!"); } Collection<Object> results = new ArrayList<Object>(); for (Object item : items) { Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results.add(propValues.get(property)); } return results; }
|
CollectionUtils { public static Collection<?> substract(Collection<?> items, String property) { if (items == null) { return null; } if (StringUtils.isEmpty(property)) { throw new IllegalArgumentException("property name must not empty!"); } Collection<Object> results = new ArrayList<Object>(); for (Object item : items) { Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results.add(propValues.get(property)); } return results; } }
|
CollectionUtils { public static Collection<?> substract(Collection<?> items, String property) { if (items == null) { return null; } if (StringUtils.isEmpty(property)) { throw new IllegalArgumentException("property name must not empty!"); } Collection<Object> results = new ArrayList<Object>(); for (Object item : items) { Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results.add(propValues.get(property)); } return results; } private CollectionUtils(); }
|
CollectionUtils { public static Collection<?> substract(Collection<?> items, String property) { if (items == null) { return null; } if (StringUtils.isEmpty(property)) { throw new IllegalArgumentException("property name must not empty!"); } Collection<Object> results = new ArrayList<Object>(); for (Object item : items) { Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results.add(propValues.get(property)); } return results; } private CollectionUtils(); static Collection<?> substract(Collection<?> items, String property); static String join(Collection<?> items, String property, String separator); }
|
CollectionUtils { public static Collection<?> substract(Collection<?> items, String property) { if (items == null) { return null; } if (StringUtils.isEmpty(property)) { throw new IllegalArgumentException("property name must not empty!"); } Collection<Object> results = new ArrayList<Object>(); for (Object item : items) { Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results.add(propValues.get(property)); } return results; } private CollectionUtils(); static Collection<?> substract(Collection<?> items, String property); static String join(Collection<?> items, String property, String separator); }
|
@Test public void testSubstractSingleElement() { Collection<?> expected = Collections.singletonList(2); Collection<?> actual = CollectionUtils.substract(Collections.singletonList(new Item(2, "B")), "id"); assertEquals(expected, actual); }
|
public static Collection<?> substract(Collection<?> items, String property) { if (items == null) { return null; } if (StringUtils.isEmpty(property)) { throw new IllegalArgumentException("property name must not empty!"); } Collection<Object> results = new ArrayList<Object>(); for (Object item : items) { Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results.add(propValues.get(property)); } return results; }
|
CollectionUtils { public static Collection<?> substract(Collection<?> items, String property) { if (items == null) { return null; } if (StringUtils.isEmpty(property)) { throw new IllegalArgumentException("property name must not empty!"); } Collection<Object> results = new ArrayList<Object>(); for (Object item : items) { Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results.add(propValues.get(property)); } return results; } }
|
CollectionUtils { public static Collection<?> substract(Collection<?> items, String property) { if (items == null) { return null; } if (StringUtils.isEmpty(property)) { throw new IllegalArgumentException("property name must not empty!"); } Collection<Object> results = new ArrayList<Object>(); for (Object item : items) { Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results.add(propValues.get(property)); } return results; } private CollectionUtils(); }
|
CollectionUtils { public static Collection<?> substract(Collection<?> items, String property) { if (items == null) { return null; } if (StringUtils.isEmpty(property)) { throw new IllegalArgumentException("property name must not empty!"); } Collection<Object> results = new ArrayList<Object>(); for (Object item : items) { Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results.add(propValues.get(property)); } return results; } private CollectionUtils(); static Collection<?> substract(Collection<?> items, String property); static String join(Collection<?> items, String property, String separator); }
|
CollectionUtils { public static Collection<?> substract(Collection<?> items, String property) { if (items == null) { return null; } if (StringUtils.isEmpty(property)) { throw new IllegalArgumentException("property name must not empty!"); } Collection<Object> results = new ArrayList<Object>(); for (Object item : items) { Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results.add(propValues.get(property)); } return results; } private CollectionUtils(); static Collection<?> substract(Collection<?> items, String property); static String join(Collection<?> items, String property, String separator); }
|
@Test public void testJoin() { Collection<Item> items = new ArrayList<Item>(); items.add(new Item(1, "A")); items.add(new Item(2, "B")); items.add(new Item(1, "C")); String separator = ", "; String result = CollectionUtils.join(items, "id", separator); assertEquals("1, 2, 1", result); }
|
public static String join(Collection<?> items, String property, String separator) { if (items == null) { return ""; } return StringUtils.join(substract(items, property), separator); }
|
CollectionUtils { public static String join(Collection<?> items, String property, String separator) { if (items == null) { return ""; } return StringUtils.join(substract(items, property), separator); } }
|
CollectionUtils { public static String join(Collection<?> items, String property, String separator) { if (items == null) { return ""; } return StringUtils.join(substract(items, property), separator); } private CollectionUtils(); }
|
CollectionUtils { public static String join(Collection<?> items, String property, String separator) { if (items == null) { return ""; } return StringUtils.join(substract(items, property), separator); } private CollectionUtils(); static Collection<?> substract(Collection<?> items, String property); static String join(Collection<?> items, String property, String separator); }
|
CollectionUtils { public static String join(Collection<?> items, String property, String separator) { if (items == null) { return ""; } return StringUtils.join(substract(items, property), separator); } private CollectionUtils(); static Collection<?> substract(Collection<?> items, String property); static String join(Collection<?> items, String property, String separator); }
|
@Test public void testJoinNull() { String separator = ", "; List<Item> items = null; String result = CollectionUtils.join(items, "id", separator); assertTrue(result.isEmpty()); }
|
public static String join(Collection<?> items, String property, String separator) { if (items == null) { return ""; } return StringUtils.join(substract(items, property), separator); }
|
CollectionUtils { public static String join(Collection<?> items, String property, String separator) { if (items == null) { return ""; } return StringUtils.join(substract(items, property), separator); } }
|
CollectionUtils { public static String join(Collection<?> items, String property, String separator) { if (items == null) { return ""; } return StringUtils.join(substract(items, property), separator); } private CollectionUtils(); }
|
CollectionUtils { public static String join(Collection<?> items, String property, String separator) { if (items == null) { return ""; } return StringUtils.join(substract(items, property), separator); } private CollectionUtils(); static Collection<?> substract(Collection<?> items, String property); static String join(Collection<?> items, String property, String separator); }
|
CollectionUtils { public static String join(Collection<?> items, String property, String separator) { if (items == null) { return ""; } return StringUtils.join(substract(items, property), separator); } private CollectionUtils(); static Collection<?> substract(Collection<?> items, String property); static String join(Collection<?> items, String property, String separator); }
|
@Test public void testJoinEmpty() { String separator = ", "; String result = CollectionUtils.join(new ArrayList<Object>(), "id", separator); assertTrue(result.isEmpty()); }
|
public static String join(Collection<?> items, String property, String separator) { if (items == null) { return ""; } return StringUtils.join(substract(items, property), separator); }
|
CollectionUtils { public static String join(Collection<?> items, String property, String separator) { if (items == null) { return ""; } return StringUtils.join(substract(items, property), separator); } }
|
CollectionUtils { public static String join(Collection<?> items, String property, String separator) { if (items == null) { return ""; } return StringUtils.join(substract(items, property), separator); } private CollectionUtils(); }
|
CollectionUtils { public static String join(Collection<?> items, String property, String separator) { if (items == null) { return ""; } return StringUtils.join(substract(items, property), separator); } private CollectionUtils(); static Collection<?> substract(Collection<?> items, String property); static String join(Collection<?> items, String property, String separator); }
|
CollectionUtils { public static String join(Collection<?> items, String property, String separator) { if (items == null) { return ""; } return StringUtils.join(substract(items, property), separator); } private CollectionUtils(); static Collection<?> substract(Collection<?> items, String property); static String join(Collection<?> items, String property, String separator); }
|
@Test public void testJoinSingleElement() { Collection<Item> items = new ArrayList<Item>(); items.add(new Item(1, "A")); String separator = ", "; String result = CollectionUtils.join(items, "name", separator); assertEquals("A", result); }
|
public static String join(Collection<?> items, String property, String separator) { if (items == null) { return ""; } return StringUtils.join(substract(items, property), separator); }
|
CollectionUtils { public static String join(Collection<?> items, String property, String separator) { if (items == null) { return ""; } return StringUtils.join(substract(items, property), separator); } }
|
CollectionUtils { public static String join(Collection<?> items, String property, String separator) { if (items == null) { return ""; } return StringUtils.join(substract(items, property), separator); } private CollectionUtils(); }
|
CollectionUtils { public static String join(Collection<?> items, String property, String separator) { if (items == null) { return ""; } return StringUtils.join(substract(items, property), separator); } private CollectionUtils(); static Collection<?> substract(Collection<?> items, String property); static String join(Collection<?> items, String property, String separator); }
|
CollectionUtils { public static String join(Collection<?> items, String property, String separator) { if (items == null) { return ""; } return StringUtils.join(substract(items, property), separator); } private CollectionUtils(); static Collection<?> substract(Collection<?> items, String property); static String join(Collection<?> items, String property, String separator); }
|
@Test public void testDebugEnable() { when(logger.isDebugEnabled()).thenReturn(true); instance.debug(msg, "A", "B", "C"); verify(logger).debug(msg, args); }
|
public void debug(String msg, Object... args) { if (logger.isDebugEnabled()) { logger.debug(msg, args); } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void debug(String msg, Object... args) { if (logger.isDebugEnabled()) { logger.debug(msg, args); } } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void debug(String msg, Object... args) { if (logger.isDebugEnabled()) { logger.debug(msg, args); } } Slf4JLogger(Logger logger); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void debug(String msg, Object... args) { if (logger.isDebugEnabled()) { logger.debug(msg, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void debug(String msg, Object... args) { if (logger.isDebugEnabled()) { logger.debug(msg, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
@Test public void testDebugDisable() { when(logger.isDebugEnabled()).thenReturn(false); instance.debug(msg, "A", "B", "C"); verify(logger, never()).debug(msg, args); }
|
public void debug(String msg, Object... args) { if (logger.isDebugEnabled()) { logger.debug(msg, args); } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void debug(String msg, Object... args) { if (logger.isDebugEnabled()) { logger.debug(msg, args); } } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void debug(String msg, Object... args) { if (logger.isDebugEnabled()) { logger.debug(msg, args); } } Slf4JLogger(Logger logger); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void debug(String msg, Object... args) { if (logger.isDebugEnabled()) { logger.debug(msg, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void debug(String msg, Object... args) { if (logger.isDebugEnabled()) { logger.debug(msg, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
@Test public void testExists() { assertTrue(repository.exists(Dictionary.class, male.getId())); assertFalse(repository.exists(Dictionary.class, 1000L)); }
|
@Override public <T extends Entity> boolean exists(final Class<T> clazz, final Serializable id) { return get(clazz, id) != null; }
|
EntityRepositoryHibernate implements EntityRepository { @Override public <T extends Entity> boolean exists(final Class<T> clazz, final Serializable id) { return get(clazz, id) != null; } }
|
EntityRepositoryHibernate implements EntityRepository { @Override public <T extends Entity> boolean exists(final Class<T> clazz, final Serializable id) { return get(clazz, id) != null; } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); }
|
EntityRepositoryHibernate implements EntityRepository { @Override public <T extends Entity> boolean exists(final Class<T> clazz, final Serializable id) { return get(clazz, id) != null; } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); }
|
EntityRepositoryHibernate implements EntityRepository { @Override public <T extends Entity> boolean exists(final Class<T> clazz, final Serializable id) { return get(clazz, id) != null; } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); }
|
@Test public void testDebugEnabledException() { when(logger.isDebugEnabled()).thenReturn(true); instance.debug(errorMsg, t); verify(logger).debug(errorMsg, t); }
|
public void debug(String msg, Object... args) { if (logger.isDebugEnabled()) { logger.debug(msg, args); } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void debug(String msg, Object... args) { if (logger.isDebugEnabled()) { logger.debug(msg, args); } } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void debug(String msg, Object... args) { if (logger.isDebugEnabled()) { logger.debug(msg, args); } } Slf4JLogger(Logger logger); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void debug(String msg, Object... args) { if (logger.isDebugEnabled()) { logger.debug(msg, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void debug(String msg, Object... args) { if (logger.isDebugEnabled()) { logger.debug(msg, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
@Test public void testDebugDisabledException() { when(logger.isDebugEnabled()).thenReturn(false); instance.debug(errorMsg, t); verify(logger, never()).debug(errorMsg, t); }
|
public void debug(String msg, Object... args) { if (logger.isDebugEnabled()) { logger.debug(msg, args); } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void debug(String msg, Object... args) { if (logger.isDebugEnabled()) { logger.debug(msg, args); } } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void debug(String msg, Object... args) { if (logger.isDebugEnabled()) { logger.debug(msg, args); } } Slf4JLogger(Logger logger); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void debug(String msg, Object... args) { if (logger.isDebugEnabled()) { logger.debug(msg, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void debug(String msg, Object... args) { if (logger.isDebugEnabled()) { logger.debug(msg, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
@Test public void testInfoEnable() { when(logger.isInfoEnabled()).thenReturn(true); instance.info(msg, "A", "B", "C"); verify(logger).info(msg, args); }
|
public void info(String msg, Object... args) { if (logger.isInfoEnabled()) { logger.info(msg, args); } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void info(String msg, Object... args) { if (logger.isInfoEnabled()) { logger.info(msg, args); } } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void info(String msg, Object... args) { if (logger.isInfoEnabled()) { logger.info(msg, args); } } Slf4JLogger(Logger logger); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void info(String msg, Object... args) { if (logger.isInfoEnabled()) { logger.info(msg, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void info(String msg, Object... args) { if (logger.isInfoEnabled()) { logger.info(msg, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
@Test public void testInfoDisable() { when(logger.isInfoEnabled()).thenReturn(false); instance.info(msg, "A", "B", "C"); verify(logger, never()).info(msg, args); }
|
public void info(String msg, Object... args) { if (logger.isInfoEnabled()) { logger.info(msg, args); } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void info(String msg, Object... args) { if (logger.isInfoEnabled()) { logger.info(msg, args); } } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void info(String msg, Object... args) { if (logger.isInfoEnabled()) { logger.info(msg, args); } } Slf4JLogger(Logger logger); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void info(String msg, Object... args) { if (logger.isInfoEnabled()) { logger.info(msg, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void info(String msg, Object... args) { if (logger.isInfoEnabled()) { logger.info(msg, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
@Test public void testInfoEnabledException() { when(logger.isInfoEnabled()).thenReturn(true); instance.info(errorMsg, t); verify(logger).info(errorMsg, t); }
|
public void info(String msg, Object... args) { if (logger.isInfoEnabled()) { logger.info(msg, args); } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void info(String msg, Object... args) { if (logger.isInfoEnabled()) { logger.info(msg, args); } } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void info(String msg, Object... args) { if (logger.isInfoEnabled()) { logger.info(msg, args); } } Slf4JLogger(Logger logger); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void info(String msg, Object... args) { if (logger.isInfoEnabled()) { logger.info(msg, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void info(String msg, Object... args) { if (logger.isInfoEnabled()) { logger.info(msg, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
@Test public void testInfoDisabledException() { when(logger.isInfoEnabled()).thenReturn(false); instance.info(errorMsg, t); verify(logger, never()).info(errorMsg, t); }
|
public void info(String msg, Object... args) { if (logger.isInfoEnabled()) { logger.info(msg, args); } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void info(String msg, Object... args) { if (logger.isInfoEnabled()) { logger.info(msg, args); } } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void info(String msg, Object... args) { if (logger.isInfoEnabled()) { logger.info(msg, args); } } Slf4JLogger(Logger logger); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void info(String msg, Object... args) { if (logger.isInfoEnabled()) { logger.info(msg, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void info(String msg, Object... args) { if (logger.isInfoEnabled()) { logger.info(msg, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
@Test public void testTraceEnable() { when(logger.isTraceEnabled()).thenReturn(true); instance.trace(msg, "A", "B", "C"); verify(logger).trace(msg, args); }
|
public void trace(String format, Object... args) { if (logger.isTraceEnabled()) { logger.trace(format, args); } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void trace(String format, Object... args) { if (logger.isTraceEnabled()) { logger.trace(format, args); } } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void trace(String format, Object... args) { if (logger.isTraceEnabled()) { logger.trace(format, args); } } Slf4JLogger(Logger logger); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void trace(String format, Object... args) { if (logger.isTraceEnabled()) { logger.trace(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void trace(String format, Object... args) { if (logger.isTraceEnabled()) { logger.trace(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
@Test public void testTraceDisable() { when(logger.isTraceEnabled()).thenReturn(false); instance.trace(msg, "A", "B", "C"); verify(logger, never()).trace(msg, args); }
|
public void trace(String format, Object... args) { if (logger.isTraceEnabled()) { logger.trace(format, args); } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void trace(String format, Object... args) { if (logger.isTraceEnabled()) { logger.trace(format, args); } } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void trace(String format, Object... args) { if (logger.isTraceEnabled()) { logger.trace(format, args); } } Slf4JLogger(Logger logger); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void trace(String format, Object... args) { if (logger.isTraceEnabled()) { logger.trace(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void trace(String format, Object... args) { if (logger.isTraceEnabled()) { logger.trace(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
@Test public void testTraceEnabledException() { when(logger.isTraceEnabled()).thenReturn(true); instance.trace(errorMsg, t); verify(logger).trace(errorMsg, t); }
|
public void trace(String format, Object... args) { if (logger.isTraceEnabled()) { logger.trace(format, args); } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void trace(String format, Object... args) { if (logger.isTraceEnabled()) { logger.trace(format, args); } } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void trace(String format, Object... args) { if (logger.isTraceEnabled()) { logger.trace(format, args); } } Slf4JLogger(Logger logger); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void trace(String format, Object... args) { if (logger.isTraceEnabled()) { logger.trace(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void trace(String format, Object... args) { if (logger.isTraceEnabled()) { logger.trace(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
@Test public void testTraceDisabledException() { when(logger.isTraceEnabled()).thenReturn(false); instance.trace(errorMsg, t); verify(logger, never()).trace(errorMsg, t); }
|
public void trace(String format, Object... args) { if (logger.isTraceEnabled()) { logger.trace(format, args); } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void trace(String format, Object... args) { if (logger.isTraceEnabled()) { logger.trace(format, args); } } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void trace(String format, Object... args) { if (logger.isTraceEnabled()) { logger.trace(format, args); } } Slf4JLogger(Logger logger); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void trace(String format, Object... args) { if (logger.isTraceEnabled()) { logger.trace(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void trace(String format, Object... args) { if (logger.isTraceEnabled()) { logger.trace(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
@Test public void testGet() { assertEquals(male, repository.get(Dictionary.class, male.getId())); }
|
@Override public <T extends Entity> T get(final Class<T> clazz, final Serializable id) { return (T) getSession().get(clazz, id); }
|
EntityRepositoryHibernate implements EntityRepository { @Override public <T extends Entity> T get(final Class<T> clazz, final Serializable id) { return (T) getSession().get(clazz, id); } }
|
EntityRepositoryHibernate implements EntityRepository { @Override public <T extends Entity> T get(final Class<T> clazz, final Serializable id) { return (T) getSession().get(clazz, id); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); }
|
EntityRepositoryHibernate implements EntityRepository { @Override public <T extends Entity> T get(final Class<T> clazz, final Serializable id) { return (T) getSession().get(clazz, id); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); }
|
EntityRepositoryHibernate implements EntityRepository { @Override public <T extends Entity> T get(final Class<T> clazz, final Serializable id) { return (T) getSession().get(clazz, id); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); }
|
@Test public void testWarnEnable() { when(logger.isWarnEnabled()).thenReturn(true); instance.warn(msg, "A", "B", "C"); verify(logger).warn(msg, args); }
|
public void warn(String format, Object... args) { if (logger.isWarnEnabled()) { logger.warn(format, args); } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void warn(String format, Object... args) { if (logger.isWarnEnabled()) { logger.warn(format, args); } } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void warn(String format, Object... args) { if (logger.isWarnEnabled()) { logger.warn(format, args); } } Slf4JLogger(Logger logger); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void warn(String format, Object... args) { if (logger.isWarnEnabled()) { logger.warn(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void warn(String format, Object... args) { if (logger.isWarnEnabled()) { logger.warn(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
@Test public void testWarnDisable() { when(logger.isWarnEnabled()).thenReturn(false); instance.warn(msg, "A", "B", "C"); verify(logger, never()).warn(msg, args); }
|
public void warn(String format, Object... args) { if (logger.isWarnEnabled()) { logger.warn(format, args); } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void warn(String format, Object... args) { if (logger.isWarnEnabled()) { logger.warn(format, args); } } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void warn(String format, Object... args) { if (logger.isWarnEnabled()) { logger.warn(format, args); } } Slf4JLogger(Logger logger); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void warn(String format, Object... args) { if (logger.isWarnEnabled()) { logger.warn(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void warn(String format, Object... args) { if (logger.isWarnEnabled()) { logger.warn(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
@Test public void testWarnEnabledException() { when(logger.isWarnEnabled()).thenReturn(true); instance.warn(errorMsg, t); verify(logger).warn(errorMsg, t); }
|
public void warn(String format, Object... args) { if (logger.isWarnEnabled()) { logger.warn(format, args); } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void warn(String format, Object... args) { if (logger.isWarnEnabled()) { logger.warn(format, args); } } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void warn(String format, Object... args) { if (logger.isWarnEnabled()) { logger.warn(format, args); } } Slf4JLogger(Logger logger); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void warn(String format, Object... args) { if (logger.isWarnEnabled()) { logger.warn(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void warn(String format, Object... args) { if (logger.isWarnEnabled()) { logger.warn(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
@Test public void testWarnDisabledException() { when(logger.isWarnEnabled()).thenReturn(false); instance.warn(errorMsg, t); verify(logger, never()).warn(errorMsg, t); }
|
public void warn(String format, Object... args) { if (logger.isWarnEnabled()) { logger.warn(format, args); } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void warn(String format, Object... args) { if (logger.isWarnEnabled()) { logger.warn(format, args); } } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void warn(String format, Object... args) { if (logger.isWarnEnabled()) { logger.warn(format, args); } } Slf4JLogger(Logger logger); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void warn(String format, Object... args) { if (logger.isWarnEnabled()) { logger.warn(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void warn(String format, Object... args) { if (logger.isWarnEnabled()) { logger.warn(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
@Test public void testErrorEnable() { when(logger.isErrorEnabled()).thenReturn(true); instance.error(msg, "A", "B", "C"); verify(logger).error(msg, args); }
|
public void error(String format, Object... args) { if (logger.isErrorEnabled()) { logger.error(format, args); } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void error(String format, Object... args) { if (logger.isErrorEnabled()) { logger.error(format, args); } } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void error(String format, Object... args) { if (logger.isErrorEnabled()) { logger.error(format, args); } } Slf4JLogger(Logger logger); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void error(String format, Object... args) { if (logger.isErrorEnabled()) { logger.error(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void error(String format, Object... args) { if (logger.isErrorEnabled()) { logger.error(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
@Test public void testErrorDisable() { when(logger.isErrorEnabled()).thenReturn(false); instance.error(msg, "A", "B", "C"); verify(logger, never()).error(msg, args); }
|
public void error(String format, Object... args) { if (logger.isErrorEnabled()) { logger.error(format, args); } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void error(String format, Object... args) { if (logger.isErrorEnabled()) { logger.error(format, args); } } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void error(String format, Object... args) { if (logger.isErrorEnabled()) { logger.error(format, args); } } Slf4JLogger(Logger logger); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void error(String format, Object... args) { if (logger.isErrorEnabled()) { logger.error(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void error(String format, Object... args) { if (logger.isErrorEnabled()) { logger.error(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
@Test public void testErrorEnabledException() { when(logger.isErrorEnabled()).thenReturn(true); instance.error(errorMsg, t); verify(logger).error(errorMsg, t); }
|
public void error(String format, Object... args) { if (logger.isErrorEnabled()) { logger.error(format, args); } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void error(String format, Object... args) { if (logger.isErrorEnabled()) { logger.error(format, args); } } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void error(String format, Object... args) { if (logger.isErrorEnabled()) { logger.error(format, args); } } Slf4JLogger(Logger logger); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void error(String format, Object... args) { if (logger.isErrorEnabled()) { logger.error(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void error(String format, Object... args) { if (logger.isErrorEnabled()) { logger.error(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
@Test public void testErrorDisabledException() { when(logger.isErrorEnabled()).thenReturn(false); instance.error(errorMsg, t); verify(logger, never()).error(errorMsg, t); }
|
public void error(String format, Object... args) { if (logger.isErrorEnabled()) { logger.error(format, args); } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void error(String format, Object... args) { if (logger.isErrorEnabled()) { logger.error(format, args); } } }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void error(String format, Object... args) { if (logger.isErrorEnabled()) { logger.error(format, args); } } Slf4JLogger(Logger logger); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void error(String format, Object... args) { if (logger.isErrorEnabled()) { logger.error(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
Slf4JLogger implements org.dayatang.utils.Logger { public void error(String format, Object... args) { if (logger.isErrorEnabled()) { logger.error(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); }
|
@Test public void testConvertColumnNameToIndex() { assertEquals(0, ExcelUtils.convertColumnNameToIndex("A")); assertEquals(25, ExcelUtils.convertColumnNameToIndex("Z")); assertEquals(26, ExcelUtils.convertColumnNameToIndex("AA")); assertEquals(52, ExcelUtils.convertColumnNameToIndex("BA")); assertEquals(26 * 26 + 2 * 26 + 1, ExcelUtils.convertColumnNameToIndex("ABB")); }
|
public static int convertColumnNameToIndex(String columnName) { Assert.notBlank(columnName); String theColumn = columnName.toUpperCase(); int length = theColumn.length(); int result = letterToInt(theColumn.charAt(length - 1)); if (length == 1) { return result; } for (int i = 1; i < length; i++) { int letter = theColumn.charAt(length - i - 1); result = (letterToInt(letter) + 1) * ((int) Math.pow(26, i)) + result; } return result; }
|
ExcelUtils { public static int convertColumnNameToIndex(String columnName) { Assert.notBlank(columnName); String theColumn = columnName.toUpperCase(); int length = theColumn.length(); int result = letterToInt(theColumn.charAt(length - 1)); if (length == 1) { return result; } for (int i = 1; i < length; i++) { int letter = theColumn.charAt(length - i - 1); result = (letterToInt(letter) + 1) * ((int) Math.pow(26, i)) + result; } return result; } }
|
ExcelUtils { public static int convertColumnNameToIndex(String columnName) { Assert.notBlank(columnName); String theColumn = columnName.toUpperCase(); int length = theColumn.length(); int result = letterToInt(theColumn.charAt(length - 1)); if (length == 1) { return result; } for (int i = 1; i < length; i++) { int letter = theColumn.charAt(length - i - 1); result = (letterToInt(letter) + 1) * ((int) Math.pow(26, i)) + result; } return result; } private ExcelUtils(); }
|
ExcelUtils { public static int convertColumnNameToIndex(String columnName) { Assert.notBlank(columnName); String theColumn = columnName.toUpperCase(); int length = theColumn.length(); int result = letterToInt(theColumn.charAt(length - 1)); if (length == 1) { return result; } for (int i = 1; i < length; i++) { int letter = theColumn.charAt(length - i - 1); result = (letterToInt(letter) + 1) * ((int) Math.pow(26, i)) + result; } return result; } private ExcelUtils(); static int convertColumnNameToIndex(String columnName); static Double getDouble(Object data); static Integer getInt(Object data); static Long getLong(Object data); static Boolean getBoolean(Object data); static String getString(Object data); static Date getDate(Object data, Version version, boolean isDate1904); }
|
ExcelUtils { public static int convertColumnNameToIndex(String columnName) { Assert.notBlank(columnName); String theColumn = columnName.toUpperCase(); int length = theColumn.length(); int result = letterToInt(theColumn.charAt(length - 1)); if (length == 1) { return result; } for (int i = 1; i < length; i++) { int letter = theColumn.charAt(length - i - 1); result = (letterToInt(letter) + 1) * ((int) Math.pow(26, i)) + result; } return result; } private ExcelUtils(); static int convertColumnNameToIndex(String columnName); static Double getDouble(Object data); static Integer getInt(Object data); static Long getLong(Object data); static Boolean getBoolean(Object data); static String getString(Object data); static Date getDate(Object data, Version version, boolean isDate1904); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.