public List<T> findAll(Integer number, Integer offset, String orderByPropertyName, boolean asc) {
Session session = openSession(true);
List<T> results = Lists.newArrayList();
try {
Criteria criteria = criteria().setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
if (number != 1) {
criteria.setFirstResult(number - 1);
}
if (offset != 0) {
criteria.setMaxResults(offset);
}
if (asc) {
criteria.addOrder(Order.asc(orderByPropertyName));
} else {
criteria.addOrder(Order.desc(orderByPropertyName));
}
results = list(criteria);
for (T result : results) {
result.init();
}
commitTransaction(session, true);
} catch (Exception e) {
rollbackTransaction(session, true);
} finally {
closeSession(session);
}
return results;
}
@Override
public T instantiateDummy(final Relationship entity, final String entityType)
throws FrameworkException {
Map<String, Class<? extends RelationshipInterface>> entities =
StructrApp.getConfiguration().getRelationshipEntities();
Class<T> relClass = (Class<T>) entities.get(entityType);
T newRel = null;
if (relClass != null) {
try {
newRel = relClass.newInstance();
newRel.init(factoryProfile.getSecurityContext(), entity);
// let rel. know of its instantiation so it can cache its start- and end node ID.
newRel.onRelationshipInstantiation();
} catch (Throwable t) {
newRel = null;
}
}
return newRel;
}
public List<T> namedQueryListResult(
String namedQuery, int maxSize, Map<String, Object> parameters) {
Session session = openSession(true);
List<T> results = Lists.newArrayList();
try {
Query query = namedQuery(namedQuery);
for (Map.Entry<String, Object> entry : parameters.entrySet()) {
query.setParameter(entry.getKey(), entry.getValue());
}
if (maxSize != -1) {
query.setMaxResults(maxSize);
}
results = query.list();
for (T result : results) {
if (result != null) {
result.init();
}
}
commitTransaction(session, true);
} catch (Exception e) {
rollbackTransaction(session, true);
} finally {
closeSession(session);
}
return results;
}
<T extends FramedElement> T frameElement(Element e, Class<T> kind) {
Class<T> frameType =
(kind == TVertex.class || kind == TEdge.class) ? kind : resolver.resolve(e, kind);
T framedElement = builder.create(e, frameType);
framedElement.init(this, e);
return framedElement;
}
/** {@inheritDoc} */
public void init(final SpacecraftState s0, final AbsoluteDate t) {
// delegate to raw detector
rawDetector.init(s0, t);
// initialize events triggering logic
forward = t.compareTo(s0.getDate()) >= 0;
extremeT = forward ? AbsoluteDate.PAST_INFINITY : AbsoluteDate.FUTURE_INFINITY;
extremeG = Double.NaN;
Arrays.fill(transformers, Transformer.UNINITIALIZED);
Arrays.fill(updates, extremeT);
}
@Override
public void onSurfaceChanged(SurfaceHolder holder, int format, int width, int height) {
super.onSurfaceChanged(holder, format, width, height);
if (mRs != null) {
mRs.setSurface(holder, width, height);
}
if (mRenderer == null) {
mRenderer = createScene(width, height);
mRenderer.init(mRs, getResources(), isPreview());
mRenderer.start();
} else {
mRenderer.resize(width, height);
}
}
private <T extends MapControls> T init(final T c, FrameLayout parent, int gravity) {
c.setGravity(gravity);
c.init(parent);
allControls.add(c);
c.setNotifyClick(
new Runnable() {
@Override
public void run() {
notifyClicked(c);
}
});
return c;
}
public T findById(S id) {
Session session = openSession(true);
T entity = null;
try {
entity = get(id);
if (entity != null) {
entity.init();
}
commitTransaction(session, true);
} catch (Exception e) {
rollbackTransaction(session, true);
} finally {
closeSession(session);
}
return entity;
}
public List<T> list(Query query) {
Session session = openSession(true);
List<T> results = Lists.newArrayList();
try {
results = query.list();
for (T result : results) {
result.init();
}
commitTransaction(session, true);
} catch (Exception e) {
rollbackTransaction(session, true);
} finally {
closeSession(session);
}
return results;
}
@Override
public void addingEntries(Bundle bundle, List<String> resources) {
for (String fileName : resources) {
// extract the format from the file name
File file = new File(fileName);
String format = file.getName().substring(0, file.getName().lastIndexOf("."));
Hashtable<String, String> properties = new Hashtable<String, String>();
LOGGER.debug("Found started bundle with name: {}", fileName);
// setup the properties for the service
properties.put(Constants.SERVICE_SHORTNAME, format);
properties.put(
Constants.SERVICE_TITLE,
"View as " + (format.length() > 4 ? capitalize(format) : format.toUpperCase()) + "...");
properties.put(Constants.SERVICE_DESCRIPTION, "Transforms query results into " + format);
// define a transformer object that points to the xsl
T xmt = null;
try {
xmt = transformerClass.newInstance();
xmt.init(bundle, fileName);
} catch (InstantiationException e) {
LOGGER.debug("InstantiationException", e);
continue;
} catch (IllegalAccessException e) {
LOGGER.debug("IllegalAccessException", e);
continue;
}
// register the service
ServiceRegistration sr = bundleContext.registerService(publishedInterface, xmt, properties);
// store the service registration object
if (serviceRegistrationMap.containsKey(bundle)) {
// if it's already in the map, add the sr to the appropriate
// list
serviceRegistrationMap.get(bundle).add(sr);
} else {
// if it's not in the map, make the initial list and put it in
// the map
List<ServiceRegistration> srList = new ArrayList<ServiceRegistration>();
srList.add(sr);
serviceRegistrationMap.put(bundle, srList);
}
}
}
public T update(T entity) {
Session session = openSession(false);
try {
T original = get(entity.getId());
if (original != null) {
original.init();
}
if (original instanceof MergeSupport) {
((MergeSupport) original).merge((MergeSupport) entity, sessionFactory);
}
original.beforeUpdate();
entity = persist(original);
commitTransaction(session, false);
} catch (Exception e) {
rollbackTransaction(session, false);
} finally {
closeSession(session);
}
return entity;
}
public T namedQueryUniqueResult(String namedQuery, Map<String, Object> parameters) {
Session session = openSession(true);
T result = null;
try {
Query query = namedQuery(namedQuery);
for (Map.Entry<String, Object> entry : parameters.entrySet()) {
query.setParameter(entry.getKey(), entry.getValue());
}
result = (T) query.uniqueResult();
if (result != null) {
result.init();
}
commitTransaction(session, true);
} catch (Exception e) {
rollbackTransaction(session, true);
} finally {
closeSession(session);
}
return result;
}
/**
* Initializes and returns page class instance
*
* @param page - page class
* @throws PageObjectException
*/
protected <T extends AbstractPageObject> T initPage(T page) throws PageObjectException {
// get locators
Locale locale;
try {
locale = new Locale(AutomationMain.getConfigProperties().getContentLanguage());
} catch (AutomationFrameworkException e) {
throw new PageObjectException("Main factory initialization exception.", e);
}
try {
Browser browser = Browser.getCurrentBrowser();
LOG.info("Current URL: " + getCurrentUrl());
if (StringUtils.isNotBlank(page.getPageUrl())
&& !browser.getCurrentUrl().contains(page.getPageUrl())) {
LOG.error("Navigate to URL: " + page.getPageUrl());
throw new PageObjectException(
"Page validation exception. Expected page URL is "
+ page.getPageUrl()
+ " URL in fact "
+ getCurrentUrl());
}
page.setPageFactory(this);
page.init(browser, locale);
LOG.info(page.getClass().getName() + " page created.");
} catch (Exception e) {
throw new PageObjectException(
"Unable initialize "
+ page.getClass().getName()
+ " page by URL: "
+ page.getPageUrl()
+ "\n"
+ e.getMessage(),
e);
}
return page;
}
@Override
public T instantiateWithType(
final Relationship relationship, final Class<T> relClass, final boolean isCreation)
throws FrameworkException {
logger.log(Level.FINEST, "Instantiate relationship with type {0}", relClass.getName());
SecurityContext securityContext = factoryProfile.getSecurityContext();
T newRel = null;
try {
newRel = relClass.newInstance();
} catch (Throwable t) {
newRel = null;
}
if (newRel == null) {
newRel = (T) StructrApp.getConfiguration().getFactoryDefinition().createGenericRelationship();
}
newRel.init(securityContext, relationship);
// try to set correct type property on relationship entity
final String type = newRel.getProperty(GraphObject.type);
if (type == null || (type != null && !type.equals(relClass.getSimpleName()))) {
newRel.unlockReadOnlyPropertiesOnce();
newRel.setProperty(GraphObject.type, relClass.getSimpleName());
}
newRel.onRelationshipInstantiation();
return newRel;
}
/**
* Creates a new entity of the specified type with the optionally specified initial parameters.
* This method actually inserts a row into the table represented by the entity type and returns
* the entity instance which corresponds to that row.
*
* <p>The {@link DBParam} object parameters are designed to allow the creation of entities which
* have non-null fields which have no defalut or auto-generated value. Insertion of a row without
* such field values would of course fail, thus the need for db params. The db params can also be
* used to set the values for any field in the row, leading to more compact code under certain
* circumstances.
*
* <p>Unless within a transaction, this method will commit to the database immediately and exactly
* once per call. Thus, care should be taken in the creation of large numbers of entities. There
* doesn't seem to be a more efficient way to create large numbers of entities, however one should
* still be aware of the performance implications.
*
* <p>This method delegates the action INSERT action to {@link
* DatabaseProvider#insertReturningKey(EntityManager, Connection, Class, String, boolean, String,
* DBParam...)}. This is necessary because not all databases support the JDBC <code>
* RETURN_GENERATED_KEYS</code> constant (e.g. PostgreSQL and HSQLDB). Thus, the database provider
* itself is responsible for handling INSERTion and retrieval of the correct primary key value.
*
* @param type The type of the entity to INSERT.
* @param params An optional varargs array of initial values for the fields in the row. These
* values will be passed to the database within the INSERT statement.
* @return The new entity instance corresponding to the INSERTed row.
* @see net.java.ao.DBParam
* @see net.java.ao.DatabaseProvider#insertReturningKey(EntityManager, Connection, Class, String,
* boolean, String, DBParam...)
*/
public <T extends RawEntity<K>, K> T create(Class<T> type, DBParam... params)
throws SQLException {
T back = null;
String table = null;
tableNameConverterLock.readLock().lock();
try {
table = tableNameConverter.getName(type);
} finally {
tableNameConverterLock.readLock().unlock();
}
Set<DBParam> listParams = new HashSet<DBParam>();
listParams.addAll(Arrays.asList(params));
fieldNameConverterLock.readLock().lock();
try {
for (Method method : MethodFinder.getInstance().findAnnotation(Generator.class, type)) {
Generator genAnno = method.getAnnotation(Generator.class);
String field = fieldNameConverter.getName(method);
ValueGenerator<?> generator;
valGenCacheLock.writeLock().lock();
try {
if (valGenCache.containsKey(genAnno.value())) {
generator = valGenCache.get(genAnno.value());
} else {
generator = genAnno.value().newInstance();
valGenCache.put(genAnno.value(), generator);
}
} catch (InstantiationException e) {
continue;
} catch (IllegalAccessException e) {
continue;
} finally {
valGenCacheLock.writeLock().unlock();
}
listParams.add(new DBParam(field, generator.generateValue(this)));
}
// <ian>
Version version = type.getAnnotation(Version.class);
if (version != null) {
// Initialize version upon creation.
String field = version.value();
int initial = version.initial();
listParams.add(new DBParam(field, initial));
}
// </ian>
} finally {
fieldNameConverterLock.readLock().unlock();
}
Connection conn = getProvider().getConnection();
try {
Method pkMethod = Common.getPrimaryKeyMethod(type);
back =
peer(
type,
provider.insertReturningKey(
this,
conn,
Common.getPrimaryKeyClassType(type),
Common.getPrimaryKeyField(type, getFieldNameConverter()),
pkMethod.getAnnotation(AutoIncrement.class) != null,
table,
listParams.toArray(new DBParam[listParams.size()])));
} finally {
conn.close();
}
relationsCache.remove(type);
back.init();
return back;
}
/**
* Add a vertex to the graph
*
* @param kind The kind of the frame.
* @return The framed vertex.
*/
public <T extends FramedVertex> T addVertex(Class<T> kind) {
T framedVertex = frameNewElement(delegate.addVertex(null), kind);
framedVertex.init();
return framedVertex;
}
