code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
private boolean isSpecial(final char chr) {
return ((chr == '.') || (chr == '?') || (chr == '*') || (chr == '^') || (chr == '$') || (chr == '+')
|| (chr == '[') || (chr == ']') || (chr == '(') || (chr == ')') || (chr == '|') || (chr == '\\')
|| (chr == '&'));
} | java |
private String fixSpecials(final String inString) {
StringBuilder tmp = new StringBuilder();
for (int i = 0; i < inString.length(); i++) {
char chr = inString.charAt(i);
if (isSpecial(chr)) {
tmp.append(this.escape);
tmp.append(chr);
} else {
tmp.append(chr);
}
}
return tmp.toString();
} | java |
protected PreparedStatement prepareStatement(Connection con,
String sql,
boolean scrollable,
boolean createPreparedStatement,
int explicitFetchSizeHint)
throws SQLException
{
PreparedStatement result;
// if a JDBC1.0 driver is used the signature
// prepareStatement(String, int, int) is not defined.
// we then call the JDBC1.0 variant prepareStatement(String)
try
{
// if necessary use JDB1.0 methods
if (!FORCEJDBC1_0)
{
if (createPreparedStatement)
{
result =
con.prepareStatement(
sql,
scrollable
? ResultSet.TYPE_SCROLL_INSENSITIVE
: ResultSet.TYPE_FORWARD_ONLY,
ResultSet.CONCUR_READ_ONLY);
afterJdbc2CapableStatementCreate(result, explicitFetchSizeHint);
}
else
{
result =
con.prepareCall(
sql,
scrollable
? ResultSet.TYPE_SCROLL_INSENSITIVE
: ResultSet.TYPE_FORWARD_ONLY,
ResultSet.CONCUR_READ_ONLY);
}
}
else
{
if (createPreparedStatement)
{
result = con.prepareStatement(sql);
}
else
{
result = con.prepareCall(sql);
}
}
}
catch (AbstractMethodError err)
{
// this exception is raised if Driver is not JDBC 2.0 compliant
log.warn("Used driver seems not JDBC 2.0 compatible, use the JDBC 1.0 mode", err);
if (createPreparedStatement)
{
result = con.prepareStatement(sql);
}
else
{
result = con.prepareCall(sql);
}
FORCEJDBC1_0 = true;
}
catch (SQLException eSql)
{
// there are JDBC Driver that nominally implement JDBC 2.0, but
// throw DriverNotCapableExceptions. If we catch one of these
// we force usage of JDBC 1.0
if (eSql
.getClass()
.getName()
.equals("interbase.interclient.DriverNotCapableException"))
{
log.warn("JDBC 2.0 problems with this interbase driver, we use the JDBC 1.0 mode");
if (createPreparedStatement)
{
result = con.prepareStatement(sql);
}
else
{
result = con.prepareCall(sql);
}
FORCEJDBC1_0 = true;
}
else
{
throw eSql;
}
}
try
{
if (!ProxyHelper.isNormalOjbProxy(result)) // tomdz: What about VirtualProxy
{
platform.afterStatementCreate(result);
}
}
catch (PlatformException e)
{
log.error("Platform dependend failure", e);
}
return result;
} | java |
private Statement createStatement(Connection con, boolean scrollable, int explicitFetchSizeHint)
throws java.sql.SQLException
{
Statement result;
try
{
// if necessary use JDBC1.0 methods
if (!FORCEJDBC1_0)
{
result =
con.createStatement(
scrollable
? ResultSet.TYPE_SCROLL_INSENSITIVE
: ResultSet.TYPE_FORWARD_ONLY,
ResultSet.CONCUR_READ_ONLY);
afterJdbc2CapableStatementCreate(result, explicitFetchSizeHint);
}
else
{
result = con.createStatement();
}
}
catch (AbstractMethodError err)
{
// if a JDBC1.0 driver is used, the signature
// createStatement(int, int) is not defined.
// we then call the JDBC1.0 variant createStatement()
log.warn("Used driver seems not JDBC 2.0 compatible, use the JDBC 1.0 mode", err);
result = con.createStatement();
FORCEJDBC1_0 = true;
}
catch (SQLException eSql)
{
// there are JDBC Driver that nominally implement JDBC 2.0, but
// throw DriverNotCapableExceptions. If we catch one of these
// we force usage of JDBC 1.0
if (eSql.getClass().getName()
.equals("interbase.interclient.DriverNotCapableException"))
{
log.warn("JDBC 2.0 problems with this interbase driver, we use the JDBC 1.0 mode");
FORCEJDBC1_0 = true;
result = con.createStatement();
}
else
{
throw eSql;
}
}
try
{
platform.afterStatementCreate(result);
}
catch (PlatformException e)
{
log.error("Platform dependend failure", e);
}
return result;
} | java |
public int compareTo(InternalFeature o) {
if (null == o) {
return -1; // avoid NPE, put null objects at the end
}
if (null != styleDefinition && null != o.getStyleInfo()) {
if (styleDefinition.getIndex() > o.getStyleInfo().getIndex()) {
return 1;
}
if (styleDefinition.getIndex() < o.getStyleInfo().getIndex()) {
return -1;
}
}
return 0;
} | java |
public final void begin() {
this.file = this.getAppender().getIoFile();
if (this.file == null) {
this.getAppender().getErrorHandler()
.error("Scavenger not started: missing log file name");
return;
}
if (this.getProperties().getScavengeInterval() > -1) {
final Thread thread = new Thread(this, "Log4J File Scavenger");
thread.setDaemon(true);
thread.start();
this.threadRef = thread;
}
} | java |
public final void end() {
final Thread thread = threadRef;
if (thread != null) {
thread.interrupt();
try {
thread.join();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
this.threadRef = null;
} | java |
public static boolean isPropertyAllowed(Class defClass, String propertyName)
{
HashMap props = (HashMap)_properties.get(defClass);
return (props == null ? true : props.containsKey(propertyName));
} | java |
public static boolean toBoolean(String value, boolean defaultValue)
{
return "true".equals(value) ? true : ("false".equals(value) ? false : defaultValue);
} | java |
protected FieldDescriptor getFieldDescriptor(TableAlias aTableAlias, PathInfo aPathInfo)
{
FieldDescriptor fld = null;
String colName = aPathInfo.column;
if (aTableAlias != null)
{
fld = aTableAlias.cld.getFieldDescriptorByName(colName);
if (fld == null)
{
ObjectReferenceDescriptor ord = aTableAlias.cld.getObjectReferenceDescriptorByName(colName);
if (ord != null)
{
fld = getFldFromReference(aTableAlias, ord);
}
else
{
fld = getFldFromJoin(aTableAlias, colName);
}
}
}
return fld;
} | java |
private FieldDescriptor getFldFromJoin(TableAlias aTableAlias, String aColName)
{
FieldDescriptor fld = null;
// Search Join Structure for attribute
if (aTableAlias.joins != null)
{
Iterator itr = aTableAlias.joins.iterator();
while (itr.hasNext())
{
Join join = (Join) itr.next();
ClassDescriptor cld = join.right.cld;
if (cld != null)
{
fld = cld.getFieldDescriptorByName(aColName);
if (fld != null)
{
break;
}
}
}
}
return fld;
} | java |
private FieldDescriptor getFldFromReference(TableAlias aTableAlias, ObjectReferenceDescriptor anOrd)
{
FieldDescriptor fld = null;
if (aTableAlias == getRoot())
{
// no path expression
FieldDescriptor[] fk = anOrd.getForeignKeyFieldDescriptors(aTableAlias.cld);
if (fk.length > 0)
{
fld = fk[0];
}
}
else
{
// attribute with path expression
/**
* MBAIRD
* potentially people are referring to objects, not to the object's primary key,
* and then we need to take the primary key attribute of the referenced object
* to help them out.
*/
ClassDescriptor cld = aTableAlias.cld.getRepository().getDescriptorFor(anOrd.getItemClass());
if (cld != null)
{
fld = aTableAlias.cld.getFieldDescriptorByName(cld.getPkFields()[0].getPersistentField().getName());
}
}
return fld;
} | java |
protected void ensureColumns(List columns, List existingColumns)
{
if (columns == null || columns.isEmpty())
{
return;
}
Iterator iter = columns.iterator();
while (iter.hasNext())
{
FieldHelper cf = (FieldHelper) iter.next();
if (!existingColumns.contains(cf.name))
{
getAttributeInfo(cf.name, false, null, getQuery().getPathClasses());
}
}
} | java |
protected void appendWhereClause(StringBuffer where, Criteria crit, StringBuffer stmt)
{
if (where.length() == 0)
{
where = null;
}
if (where != null || (crit != null && !crit.isEmpty()))
{
stmt.append(" WHERE ");
appendClause(where, crit, stmt);
}
} | java |
protected void appendHavingClause(StringBuffer having, Criteria crit, StringBuffer stmt)
{
if (having.length() == 0)
{
having = null;
}
if (having != null || crit != null)
{
stmt.append(" HAVING ");
appendClause(having, crit, stmt);
}
} | java |
private void appendBetweenCriteria(TableAlias alias, PathInfo pathInfo, BetweenCriteria c, StringBuffer buf)
{
appendColName(alias, pathInfo, c.isTranslateAttribute(), buf);
buf.append(c.getClause());
appendParameter(c.getValue(), buf);
buf.append(" AND ");
appendParameter(c.getValue2(), buf);
} | java |
private String getIndirectionTableColName(TableAlias mnAlias, String path)
{
int dotIdx = path.lastIndexOf(".");
String column = path.substring(dotIdx);
return mnAlias.alias + column;
} | java |
private void appendLikeCriteria(TableAlias alias, PathInfo pathInfo, LikeCriteria c, StringBuffer buf)
{
appendColName(alias, pathInfo, c.isTranslateAttribute(), buf);
buf.append(c.getClause());
appendParameter(c.getValue(), buf);
buf.append(m_platform.getEscapeClause(c));
} | java |
protected void appendSQLClause(SelectionCriteria c, StringBuffer buf)
{
// BRJ : handle SqlCriteria
if (c instanceof SqlCriteria)
{
buf.append(c.getAttribute());
return;
}
// BRJ : criteria attribute is a query
if (c.getAttribute() instanceof Query)
{
Query q = (Query) c.getAttribute();
buf.append("(");
buf.append(getSubQuerySQL(q));
buf.append(")");
buf.append(c.getClause());
appendParameter(c.getValue(), buf);
return;
}
AttributeInfo attrInfo = getAttributeInfo((String) c.getAttribute(), false, c.getUserAlias(), c.getPathClasses());
TableAlias alias = attrInfo.tableAlias;
if (alias != null)
{
boolean hasExtents = alias.hasExtents();
if (hasExtents)
{
// BRJ : surround with braces if alias has extents
buf.append("(");
appendCriteria(alias, attrInfo.pathInfo, c, buf);
c.setNumberOfExtentsToBind(alias.extents.size());
Iterator iter = alias.iterateExtents();
while (iter.hasNext())
{
TableAlias tableAlias = (TableAlias) iter.next();
buf.append(" OR ");
appendCriteria(tableAlias, attrInfo.pathInfo, c, buf);
}
buf.append(")");
}
else
{
// no extents
appendCriteria(alias, attrInfo.pathInfo, c, buf);
}
}
else
{
// alias null
appendCriteria(alias, attrInfo.pathInfo, c, buf);
}
} | java |
private void appendParameter(Object value, StringBuffer buf)
{
if (value instanceof Query)
{
appendSubQuery((Query) value, buf);
}
else
{
buf.append("?");
}
} | java |
private void appendSubQuery(Query subQuery, StringBuffer buf)
{
buf.append(" (");
buf.append(getSubQuerySQL(subQuery));
buf.append(") ");
} | java |
private String getSubQuerySQL(Query subQuery)
{
ClassDescriptor cld = getRoot().cld.getRepository().getDescriptorFor(subQuery.getSearchClass());
String sql;
if (subQuery instanceof QueryBySQL)
{
sql = ((QueryBySQL) subQuery).getSql();
}
else
{
sql = new SqlSelectStatement(this, m_platform, cld, subQuery, m_logger).getStatement();
}
return sql;
} | java |
private void addJoin(TableAlias left, Object[] leftKeys, TableAlias right, Object[] rightKeys, boolean outer,
String name)
{
TableAlias extAlias, rightCopy;
left.addJoin(new Join(left, leftKeys, right, rightKeys, outer, name));
// build join between left and extents of right
if (right.hasExtents())
{
for (int i = 0; i < right.extents.size(); i++)
{
extAlias = (TableAlias) right.extents.get(i);
FieldDescriptor[] extKeys = getExtentFieldDescriptors(extAlias, (FieldDescriptor[]) rightKeys);
left.addJoin(new Join(left, leftKeys, extAlias, extKeys, true, name));
}
}
// we need to copy the alias on the right for each extent on the left
if (left.hasExtents())
{
for (int i = 0; i < left.extents.size(); i++)
{
extAlias = (TableAlias) left.extents.get(i);
FieldDescriptor[] extKeys = getExtentFieldDescriptors(extAlias, (FieldDescriptor[]) leftKeys);
rightCopy = right.copy("C" + i);
// copies are treated like normal extents
right.extents.add(rightCopy);
right.extents.addAll(rightCopy.extents);
addJoin(extAlias, extKeys, rightCopy, rightKeys, true, name);
}
}
} | java |
private FieldDescriptor[] getExtentFieldDescriptors(TableAlias extAlias, FieldDescriptor[] fds)
{
FieldDescriptor[] result = new FieldDescriptor[fds.length];
for (int i = 0; i < fds.length; i++)
{
result[i] = extAlias.cld.getFieldDescriptorByName(fds[i].getAttributeName());
}
return result;
} | java |
private TableAlias createTableAlias(String aTable, String aPath, String aUserAlias)
{
if (aUserAlias == null)
{
return createTableAlias(aTable, aPath);
}
else
{
return createTableAlias(aTable, aUserAlias + ALIAS_SEPARATOR + aPath);
}
} | java |
private TableAlias getTableAliasForPath(String aPath, List hintClasses)
{
return (TableAlias) m_pathToAlias.get(buildAliasKey(aPath, hintClasses));
} | java |
private void setTableAliasForPath(String aPath, List hintClasses, TableAlias anAlias)
{
m_pathToAlias.put(buildAliasKey(aPath, hintClasses), anAlias);
} | java |
private String buildAliasKey(String aPath, List hintClasses)
{
if (hintClasses == null || hintClasses.isEmpty())
{
return aPath;
}
StringBuffer buf = new StringBuffer(aPath);
for (Iterator iter = hintClasses.iterator(); iter.hasNext();)
{
Class hint = (Class) iter.next();
buf.append(" ");
buf.append(hint.getName());
}
return buf.toString();
} | java |
private void setTableAliasForClassDescriptor(ClassDescriptor aCld, TableAlias anAlias)
{
if (m_cldToAlias.get(aCld) == null)
{
m_cldToAlias.put(aCld, anAlias);
}
} | java |
private TableAlias getTableAliasForPath(String aPath, String aUserAlias, List hintClasses)
{
if (aUserAlias == null)
{
return getTableAliasForPath(aPath, hintClasses);
}
else
{
return getTableAliasForPath(aUserAlias + ALIAS_SEPARATOR + aPath, hintClasses);
}
} | java |
protected void appendGroupByClause(List groupByFields, StringBuffer buf)
{
if (groupByFields == null || groupByFields.size() == 0)
{
return;
}
buf.append(" GROUP BY ");
for (int i = 0; i < groupByFields.size(); i++)
{
FieldHelper cf = (FieldHelper) groupByFields.get(i);
if (i > 0)
{
buf.append(",");
}
appendColName(cf.name, false, null, buf);
}
} | java |
protected void appendTableWithJoins(TableAlias alias, StringBuffer where, StringBuffer buf)
{
int stmtFromPos = 0;
byte joinSyntax = getJoinSyntaxType();
if (joinSyntax == SQL92_JOIN_SYNTAX)
{
stmtFromPos = buf.length(); // store position of join (by: Terry Dexter)
}
if (alias == getRoot())
{
// BRJ: also add indirection table to FROM-clause for MtoNQuery
if (getQuery() instanceof MtoNQuery)
{
MtoNQuery mnQuery = (MtoNQuery)m_query;
buf.append(getTableAliasForPath(mnQuery.getIndirectionTable(), null).getTableAndAlias());
buf.append(", ");
}
buf.append(alias.getTableAndAlias());
}
else if (joinSyntax != SQL92_NOPAREN_JOIN_SYNTAX)
{
buf.append(alias.getTableAndAlias());
}
if (!alias.hasJoins())
{
return;
}
for (Iterator it = alias.iterateJoins(); it.hasNext();)
{
Join join = (Join) it.next();
if (joinSyntax == SQL92_JOIN_SYNTAX)
{
appendJoinSQL92(join, where, buf);
if (it.hasNext())
{
buf.insert(stmtFromPos, "(");
buf.append(")");
}
}
else if (joinSyntax == SQL92_NOPAREN_JOIN_SYNTAX)
{
appendJoinSQL92NoParen(join, where, buf);
}
else
{
appendJoin(where, buf, join);
}
}
} | java |
private void appendJoin(StringBuffer where, StringBuffer buf, Join join)
{
buf.append(",");
appendTableWithJoins(join.right, where, buf);
if (where.length() > 0)
{
where.append(" AND ");
}
join.appendJoinEqualities(where);
} | java |
private void appendJoinSQL92(Join join, StringBuffer where, StringBuffer buf)
{
if (join.isOuter)
{
buf.append(" LEFT OUTER JOIN ");
}
else
{
buf.append(" INNER JOIN ");
}
if (join.right.hasJoins())
{
buf.append("(");
appendTableWithJoins(join.right, where, buf);
buf.append(")");
}
else
{
appendTableWithJoins(join.right, where, buf);
}
buf.append(" ON ");
join.appendJoinEqualities(buf);
} | java |
private void appendJoinSQL92NoParen(Join join, StringBuffer where, StringBuffer buf)
{
if (join.isOuter)
{
buf.append(" LEFT OUTER JOIN ");
}
else
{
buf.append(" INNER JOIN ");
}
buf.append(join.right.getTableAndAlias());
buf.append(" ON ");
join.appendJoinEqualities(buf);
appendTableWithJoins(join.right, where, buf);
} | java |
private void buildJoinTree(Criteria crit)
{
Enumeration e = crit.getElements();
while (e.hasMoreElements())
{
Object o = e.nextElement();
if (o instanceof Criteria)
{
buildJoinTree((Criteria) o);
}
else
{
SelectionCriteria c = (SelectionCriteria) o;
// BRJ skip SqlCriteria
if (c instanceof SqlCriteria)
{
continue;
}
// BRJ: Outer join for OR
boolean useOuterJoin = (crit.getType() == Criteria.OR);
// BRJ: do not build join tree for subQuery attribute
if (c.getAttribute() != null && c.getAttribute() instanceof String)
{
//buildJoinTreeForColumn((String) c.getAttribute(), useOuterJoin, c.getAlias(), c.getPathClasses());
buildJoinTreeForColumn((String) c.getAttribute(), useOuterJoin, c.getUserAlias(), c.getPathClasses());
}
if (c instanceof FieldCriteria)
{
FieldCriteria cc = (FieldCriteria) c;
buildJoinTreeForColumn((String) cc.getValue(), useOuterJoin, c.getUserAlias(), c.getPathClasses());
}
}
}
} | java |
protected void buildSuperJoinTree(TableAlias left, ClassDescriptor cld, String name, boolean useOuterJoin)
{
ClassDescriptor superCld = cld.getSuperClassDescriptor();
if (superCld != null)
{
SuperReferenceDescriptor superRef = cld.getSuperReference();
FieldDescriptor[] leftFields = superRef.getForeignKeyFieldDescriptors(cld);
TableAlias base_alias = getTableAliasForPath(name, null, null);
String aliasName = String.valueOf(getAliasChar()) + m_aliasCount++;
TableAlias right = new TableAlias(superCld, aliasName, useOuterJoin, null);
Join join1to1 = new Join(left, leftFields, right, superCld.getPkFields(), useOuterJoin, "superClass");
base_alias.addJoin(join1to1);
buildSuperJoinTree(right, superCld, name, useOuterJoin);
}
} | java |
private void buildMultiJoinTree(TableAlias left, ClassDescriptor cld, String name, boolean useOuterJoin)
{
DescriptorRepository repository = cld.getRepository();
Class[] multiJoinedClasses = repository.getSubClassesMultipleJoinedTables(cld, false);
for (int i = 0; i < multiJoinedClasses.length; i++)
{
ClassDescriptor subCld = repository.getDescriptorFor(multiJoinedClasses[i]);
SuperReferenceDescriptor srd = subCld.getSuperReference();
if (srd != null)
{
FieldDescriptor[] leftFields = subCld.getPkFields();
FieldDescriptor[] rightFields = srd.getForeignKeyFieldDescriptors(subCld);
TableAlias base_alias = getTableAliasForPath(name, null, null);
String aliasName = String.valueOf(getAliasChar()) + m_aliasCount++;
TableAlias right = new TableAlias(subCld, aliasName, false, null);
Join join1to1 = new Join(left, leftFields, right, rightFields, useOuterJoin, "subClass");
base_alias.addJoin(join1to1);
buildMultiJoinTree(right, subCld, name, useOuterJoin);
}
}
} | java |
protected void splitCriteria()
{
Criteria whereCrit = getQuery().getCriteria();
Criteria havingCrit = getQuery().getHavingCriteria();
if (whereCrit == null || whereCrit.isEmpty())
{
getJoinTreeToCriteria().put(getRoot(), null);
}
else
{
// TODO: parameters list shold be modified when the form is reduced to DNF.
getJoinTreeToCriteria().put(getRoot(), whereCrit);
buildJoinTree(whereCrit);
}
if (havingCrit != null && !havingCrit.isEmpty())
{
buildJoinTree(havingCrit);
}
} | java |
private Filter getFilter(String layerFilter, String[] featureIds) throws GeomajasException {
Filter filter = null;
if (null != layerFilter) {
filter = filterService.parseFilter(layerFilter);
}
if (null != featureIds) {
Filter fidFilter = filterService.createFidFilter(featureIds);
if (null == filter) {
filter = fidFilter;
} else {
filter = filterService.createAndFilter(filter, fidFilter);
}
}
return filter;
} | java |
public static String resolveProxyUrl(String relativeUrl, TileMap tileMap, String baseTmsUrl) {
TileCode tc = parseTileCode(relativeUrl);
return buildUrl(tc, tileMap, baseTmsUrl);
} | java |
public AbstractGraph getModuleGraph(final String moduleId) {
final ModuleHandler moduleHandler = new ModuleHandler(repoHandler);
final DbModule module = moduleHandler.getModule(moduleId);
final DbOrganization organization = moduleHandler.getOrganization(module);
filters.setCorporateFilter(new CorporateFilter(organization));
final AbstractGraph graph = new ModuleGraph();
addModuleToGraph(module, graph, 0);
return graph;
} | java |
private void addModuleToGraph(final DbModule module, final AbstractGraph graph, final int depth) {
if (graph.isTreated(graph.getId(module))) {
return;
}
final String moduleElementId = graph.getId(module);
graph.addElement(moduleElementId, module.getVersion(), depth == 0);
if (filters.getDepthHandler().shouldGoDeeper(depth)) {
for (final DbDependency dep : DataUtils.getAllDbDependencies(module)) {
if(filters.shouldBeInReport(dep)){
addDependencyToGraph(dep, graph, depth + 1, moduleElementId);
}
}
}
} | java |
private void addDependencyToGraph(final DbDependency dependency, final AbstractGraph graph, final int depth, final String parentId) {
// In that case of Axway artifact we will add a module to the graph
if (filters.getCorporateFilter().filter(dependency)) {
final DbModule dbTarget = repoHandler.getModuleOf(dependency.getTarget());
// if there is no module, add the artifact to the graph
if(dbTarget == null){
LOG.error("Got missing reference: " + dependency.getTarget());
final DbArtifact dbArtifact = DataUtils.createDbArtifact(dependency.getTarget());
final String targetElementId = graph.getId(dbArtifact);
graph.addElement(targetElementId, dbArtifact.getVersion(), false);
graph.addDependency(parentId, targetElementId, dependency.getScope());
return;
}
// Add the element to the graph
addModuleToGraph(dbTarget, graph, depth + 1);
//Add the dependency to the graph
final String moduleElementId = graph.getId(dbTarget);
graph.addDependency(parentId, moduleElementId, dependency.getScope());
}
// In case a third-party we will add an artifact
else {
final DbArtifact dbTarget = repoHandler.getArtifact(dependency.getTarget());
if(dbTarget == null){
LOG.error("Got missing artifact: " + dependency.getTarget());
return;
}
if(!graph.isTreated(graph.getId(dbTarget))){
final ModelMapper modelMapper = new ModelMapper(repoHandler);
final Artifact target = modelMapper.getArtifact(dbTarget);
final String targetElementId = graph.getId(target);
graph.addElement(targetElementId, target.getVersion(), false);
graph.addDependency(parentId, targetElementId, dependency.getScope());
}
}
} | java |
public TreeNode getModuleTree(final String moduleId) {
final ModuleHandler moduleHandler = new ModuleHandler(repoHandler);
final DbModule module = moduleHandler.getModule(moduleId);
final TreeNode tree = new TreeNode();
tree.setName(module.getName());
// Add submodules
for (final DbModule submodule : module.getSubmodules()) {
addModuleToTree(submodule, tree);
}
return tree;
} | java |
private void addModuleToTree(final DbModule module, final TreeNode tree) {
final TreeNode subTree = new TreeNode();
subTree.setName(module.getName());
tree.addChild(subTree);
// Add SubsubModules
for (final DbModule subsubmodule : module.getSubmodules()) {
addModuleToTree(subsubmodule, subTree);
}
} | java |
public static void main(String[] args) throws Exception {
Logger logger = Logger.getLogger("MASReader.main");
Properties beastConfigProperties = new Properties();
String beastConfigPropertiesFile = null;
if (args.length > 0) {
beastConfigPropertiesFile = args[0];
beastConfigProperties.load(new FileInputStream(
beastConfigPropertiesFile));
logger.info("Properties file selected -> "
+ beastConfigPropertiesFile);
} else {
logger.severe("No properties file found. Set the path of properties file as argument.");
throw new BeastException(
"No properties file found. Set the path of properties file as argument.");
}
String loggerConfigPropertiesFile;
if (args.length > 1) {
Properties loggerConfigProperties = new Properties();
loggerConfigPropertiesFile = args[1];
try {
FileInputStream loggerConfigFile = new FileInputStream(
loggerConfigPropertiesFile);
loggerConfigProperties.load(loggerConfigFile);
LogManager.getLogManager().readConfiguration(loggerConfigFile);
logger.info("Logging properties configured successfully. Logger config file: "
+ loggerConfigPropertiesFile);
} catch (IOException ex) {
logger.warning("WARNING: Could not open configuration file");
logger.warning("WARNING: Logging not configured (console output only)");
}
} else {
loggerConfigPropertiesFile = null;
}
MASReader.generateJavaFiles(
beastConfigProperties.getProperty("requirementsFolder"), "\""
+ beastConfigProperties.getProperty("MASPlatform")
+ "\"",
beastConfigProperties.getProperty("srcTestRootFolder"),
beastConfigProperties.getProperty("storiesPackage"),
beastConfigProperties.getProperty("caseManagerPackage"),
loggerConfigPropertiesFile,
beastConfigProperties.getProperty("specificationPhase"));
} | java |
private synchronized Constructor getIndirectionHandlerConstructor()
{
if(_indirectionHandlerConstructor == null)
{
Class[] paramType = {PBKey.class, Identity.class};
try
{
_indirectionHandlerConstructor = getIndirectionHandlerClass().getConstructor(paramType);
}
catch(NoSuchMethodException ex)
{
throw new MetadataException("The class "
+ _indirectionHandlerClass.getName()
+ " specified for IndirectionHandlerClass"
+ " is required to have a public constructor with signature ("
+ PBKey.class.getName()
+ ", "
+ Identity.class.getName()
+ ").");
}
}
return _indirectionHandlerConstructor;
} | java |
public void setIndirectionHandlerClass(Class indirectionHandlerClass)
{
if(indirectionHandlerClass == null)
{
//throw new MetadataException("No IndirectionHandlerClass specified.");
/**
* andrew.clute
* Allow the default IndirectionHandler for the given ProxyFactory implementation
* when the parameter is not given
*/
indirectionHandlerClass = getDefaultIndirectionHandlerClass();
}
if(indirectionHandlerClass.isInterface()
|| Modifier.isAbstract(indirectionHandlerClass.getModifiers())
|| !getIndirectionHandlerBaseClass().isAssignableFrom(indirectionHandlerClass))
{
throw new MetadataException("Illegal class "
+ indirectionHandlerClass.getName()
+ " specified for IndirectionHandlerClass. Must be a concrete subclass of "
+ getIndirectionHandlerBaseClass().getName());
}
_indirectionHandlerClass = indirectionHandlerClass;
} | java |
public IndirectionHandler createIndirectionHandler(PBKey brokerKey, Identity id)
{
Object args[] = {brokerKey, id};
try
{
return (IndirectionHandler) getIndirectionHandlerConstructor().newInstance(args);
}
catch(InvocationTargetException ex)
{
throw new PersistenceBrokerException("Exception while creating a new indirection handler instance", ex);
}
catch(InstantiationException ex)
{
throw new PersistenceBrokerException("Exception while creating a new indirection handler instance", ex);
}
catch(IllegalAccessException ex)
{
throw new PersistenceBrokerException("Exception while creating a new indirection handler instance", ex);
}
} | java |
private static Constructor retrieveCollectionProxyConstructor(Class proxyClass, Class baseType, String typeDesc)
{
if(proxyClass == null)
{
throw new MetadataException("No " + typeDesc + " specified.");
}
if(proxyClass.isInterface() || Modifier.isAbstract(proxyClass.getModifiers()) || !baseType.isAssignableFrom(proxyClass))
{
throw new MetadataException("Illegal class "
+ proxyClass.getName()
+ " specified for "
+ typeDesc
+ ". Must be a concrete subclass of "
+ baseType.getName());
}
Class[] paramType = {PBKey.class, Class.class, Query.class};
try
{
return proxyClass.getConstructor(paramType);
}
catch(NoSuchMethodException ex)
{
throw new MetadataException("The class "
+ proxyClass.getName()
+ " specified for "
+ typeDesc
+ " is required to have a public constructor with signature ("
+ PBKey.class.getName()
+ ", "
+ Class.class.getName()
+ ", "
+ Query.class.getName()
+ ").");
}
} | java |
public ManageableCollection createCollectionProxy(PBKey brokerKey, Query query, Class collectionClass)
{
Object args[] = {brokerKey, collectionClass, query};
try
{
return (ManageableCollection) getCollectionProxyConstructor(collectionClass).newInstance(args);
}
catch(InstantiationException ex)
{
throw new PersistenceBrokerException("Exception while creating a new collection proxy instance", ex);
}
catch(InvocationTargetException ex)
{
throw new PersistenceBrokerException("Exception while creating a new collection proxy instance", ex);
}
catch(IllegalAccessException ex)
{
throw new PersistenceBrokerException("Exception while creating a new collection proxy instance", ex);
}
} | java |
public final Object getRealObject(Object objectOrProxy)
{
if(isNormalOjbProxy(objectOrProxy))
{
String msg;
try
{
return getIndirectionHandler(objectOrProxy).getRealSubject();
}
catch(ClassCastException e)
{
// shouldn't happen but still ...
msg = "The InvocationHandler for the provided Proxy was not an instance of " + IndirectionHandler.class.getName();
log.error(msg);
throw new PersistenceBrokerException(msg, e);
}
catch(IllegalArgumentException e)
{
msg = "Could not retrieve real object for given Proxy: " + objectOrProxy;
log.error(msg);
throw new PersistenceBrokerException(msg, e);
}
catch(PersistenceBrokerException e)
{
log.error("Could not retrieve real object for given Proxy: " + objectOrProxy);
throw e;
}
}
else if(isVirtualOjbProxy(objectOrProxy))
{
try
{
return ((VirtualProxy) objectOrProxy).getRealSubject();
}
catch(PersistenceBrokerException e)
{
log.error("Could not retrieve real object for VirtualProxy: " + objectOrProxy);
throw e;
}
}
else
{
return objectOrProxy;
}
} | java |
public Object getRealObjectIfMaterialized(Object objectOrProxy)
{
if(isNormalOjbProxy(objectOrProxy))
{
String msg;
try
{
IndirectionHandler handler = getIndirectionHandler(objectOrProxy);
return handler.alreadyMaterialized() ? handler.getRealSubject() : null;
}
catch(ClassCastException e)
{
// shouldn't happen but still ...
msg = "The InvocationHandler for the provided Proxy was not an instance of " + IndirectionHandler.class.getName();
log.error(msg);
throw new PersistenceBrokerException(msg, e);
}
catch(IllegalArgumentException e)
{
msg = "Could not retrieve real object for given Proxy: " + objectOrProxy;
log.error(msg);
throw new PersistenceBrokerException(msg, e);
}
catch(PersistenceBrokerException e)
{
log.error("Could not retrieve real object for given Proxy: " + objectOrProxy);
throw e;
}
}
else if(isVirtualOjbProxy(objectOrProxy))
{
try
{
VirtualProxy proxy = (VirtualProxy) objectOrProxy;
return proxy.alreadyMaterialized() ? proxy.getRealSubject() : null;
}
catch(PersistenceBrokerException e)
{
log.error("Could not retrieve real object for VirtualProxy: " + objectOrProxy);
throw e;
}
}
else
{
return objectOrProxy;
}
} | java |
public Class getRealClass(Object objectOrProxy)
{
IndirectionHandler handler;
if(isNormalOjbProxy(objectOrProxy))
{
String msg;
try
{
handler = getIndirectionHandler(objectOrProxy);
/*
arminw:
think we should return the real class
*/
// return handler.getIdentity().getObjectsTopLevelClass();
return handler.getIdentity().getObjectsRealClass();
}
catch(ClassCastException e)
{
// shouldn't happen but still ...
msg = "The InvocationHandler for the provided Proxy was not an instance of " + IndirectionHandler.class.getName();
log.error(msg);
throw new PersistenceBrokerException(msg, e);
}
catch(IllegalArgumentException e)
{
msg = "Could not retrieve real object for given Proxy: " + objectOrProxy;
log.error(msg);
throw new PersistenceBrokerException(msg, e);
}
}
else if(isVirtualOjbProxy(objectOrProxy))
{
handler = VirtualProxy.getIndirectionHandler((VirtualProxy) objectOrProxy);
/*
arminw:
think we should return the real class
*/
// return handler.getIdentity().getObjectsTopLevelClass();
return handler.getIdentity().getObjectsRealClass();
}
else
{
return objectOrProxy.getClass();
}
} | java |
public IndirectionHandler getIndirectionHandler(Object obj)
{
if(obj == null)
{
return null;
}
else if(isNormalOjbProxy(obj))
{
return getDynamicIndirectionHandler(obj);
}
else if(isVirtualOjbProxy(obj))
{
return VirtualProxy.getIndirectionHandler((VirtualProxy) obj);
}
else
{
return null;
}
} | java |
public boolean isMaterialized(Object object)
{
IndirectionHandler handler = getIndirectionHandler(object);
return handler == null || handler.alreadyMaterialized();
} | java |
public DbOrganization getOrganization(final String organizationId) {
final DbOrganization dbOrganization = repositoryHandler.getOrganization(organizationId);
if(dbOrganization == null){
throw new WebApplicationException(Response.status(Response.Status.NOT_FOUND)
.entity("Organization " + organizationId + " does not exist.").build());
}
return dbOrganization;
} | java |
public void deleteOrganization(final String organizationId) {
final DbOrganization dbOrganization = getOrganization(organizationId);
repositoryHandler.deleteOrganization(dbOrganization.getName());
repositoryHandler.removeModulesOrganization(dbOrganization);
} | java |
public List<String> getCorporateGroupIds(final String organizationId) {
final DbOrganization dbOrganization = getOrganization(organizationId);
return dbOrganization.getCorporateGroupIdPrefixes();
} | java |
public void addCorporateGroupId(final String organizationId, final String corporateGroupId) {
final DbOrganization dbOrganization = getOrganization(organizationId);
if(!dbOrganization.getCorporateGroupIdPrefixes().contains(corporateGroupId)){
dbOrganization.getCorporateGroupIdPrefixes().add(corporateGroupId);
repositoryHandler.store(dbOrganization);
}
repositoryHandler.addModulesOrganization(corporateGroupId, dbOrganization);
} | java |
public void removeCorporateGroupId(final String organizationId, final String corporateGroupId) {
final DbOrganization dbOrganization = getOrganization(organizationId);
if(dbOrganization.getCorporateGroupIdPrefixes().contains(corporateGroupId)){
dbOrganization.getCorporateGroupIdPrefixes().remove(corporateGroupId);
repositoryHandler.store(dbOrganization);
}
repositoryHandler.removeModulesOrganization(corporateGroupId, dbOrganization);
} | java |
public DbOrganization getMatchingOrganization(final DbModule dbModule) {
if(dbModule.getOrganization() != null
&& !dbModule.getOrganization().isEmpty()){
return getOrganization(dbModule.getOrganization());
}
for(final DbOrganization organization: repositoryHandler.getAllOrganizations()){
final CorporateFilter corporateFilter = new CorporateFilter(organization);
if(corporateFilter.matches(dbModule)){
return organization;
}
}
return null;
} | java |
public void executeDelete(ClassDescriptor cld, Object obj) throws PersistenceBrokerException
{
if (logger.isDebugEnabled())
{
logger.debug("executeDelete: " + obj);
}
final StatementManagerIF sm = broker.serviceStatementManager();
PreparedStatement stmt = null;
try
{
stmt = sm.getDeleteStatement(cld);
if (stmt == null)
{
logger.error("getDeleteStatement returned a null statement");
throw new PersistenceBrokerException("JdbcAccessImpl: getDeleteStatement returned a null statement");
}
sm.bindDelete(stmt, cld, obj);
if (logger.isDebugEnabled())
logger.debug("executeDelete: " + stmt);
// @todo: clearify semantics
// thma: the following check is not secure. The object could be deleted *or* changed.
// if it was deleted it makes no sense to throw an OL exception.
// does is make sense to throw an OL exception if the object was changed?
if (stmt.executeUpdate() == 0 && cld.isLocking()) //BRJ
{
/**
* Kuali Foundation modification -- 6/19/2009
*/
String objToString = "";
try {
objToString = obj.toString();
} catch (Exception ex) {}
throw new OptimisticLockException("Object has been modified or deleted by someone else: " + objToString, obj);
/**
* End of Kuali Foundation modification
*/
}
// Harvest any return values.
harvestReturnValues(cld.getDeleteProcedure(), obj, stmt);
}
catch (OptimisticLockException e)
{
// Don't log as error
if (logger.isDebugEnabled())
logger.debug("OptimisticLockException during the execution of delete: "
+ e.getMessage(), e);
throw e;
}
catch (PersistenceBrokerException e)
{
logger.error("PersistenceBrokerException during the execution of delete: "
+ e.getMessage(), e);
throw e;
}
catch (SQLException e)
{
final String sql = broker.serviceSqlGenerator().getPreparedDeleteStatement(cld).getStatement();
throw ExceptionHelper.generateException(e, sql, cld, logger, obj);
}
finally
{
sm.closeResources(stmt, null);
}
} | java |
public void executeInsert(ClassDescriptor cld, Object obj) throws PersistenceBrokerException
{
if (logger.isDebugEnabled())
{
logger.debug("executeInsert: " + obj);
}
final StatementManagerIF sm = broker.serviceStatementManager();
PreparedStatement stmt = null;
try
{
stmt = sm.getInsertStatement(cld);
if (stmt == null)
{
logger.error("getInsertStatement returned a null statement");
throw new PersistenceBrokerException("getInsertStatement returned a null statement");
}
// before bind values perform autoincrement sequence columns
assignAutoincrementSequences(cld, obj);
sm.bindInsert(stmt, cld, obj);
if (logger.isDebugEnabled())
logger.debug("executeInsert: " + stmt);
stmt.executeUpdate();
// after insert read and assign identity columns
assignAutoincrementIdentityColumns(cld, obj);
// Harvest any return values.
harvestReturnValues(cld.getInsertProcedure(), obj, stmt);
}
catch (PersistenceBrokerException e)
{
logger.error("PersistenceBrokerException during the execution of the insert: " + e.getMessage(), e);
throw e;
}
catch(SequenceManagerException e)
{
throw new PersistenceBrokerException("Error while try to assign identity value", e);
}
catch (SQLException e)
{
final String sql = broker.serviceSqlGenerator().getPreparedInsertStatement(cld).getStatement();
throw ExceptionHelper.generateException(e, sql, cld, logger, obj);
}
finally
{
sm.closeResources(stmt, null);
}
} | java |
public ResultSetAndStatement executeQuery(Query query, ClassDescriptor cld) throws PersistenceBrokerException
{
if (logger.isDebugEnabled())
{
logger.debug("executeQuery: " + query);
}
/*
* MBAIRD: we should create a scrollable resultset if the start at
* index or end at index is set
*/
boolean scrollable = ((query.getStartAtIndex() > Query.NO_START_AT_INDEX) || (query.getEndAtIndex() > Query.NO_END_AT_INDEX));
/*
* OR if the prefetching of relationships is being used.
*/
if (query != null && query.getPrefetchedRelationships() != null && !query.getPrefetchedRelationships().isEmpty())
{
scrollable = true;
}
final StatementManagerIF sm = broker.serviceStatementManager();
final SelectStatement sql = broker.serviceSqlGenerator().getPreparedSelectStatement(query, cld);
PreparedStatement stmt = null;
ResultSet rs = null;
try
{
final int queryFetchSize = query.getFetchSize();
final boolean isStoredProcedure = isStoredProcedure(sql.getStatement());
stmt = sm.getPreparedStatement(cld, sql.getStatement() ,
scrollable, queryFetchSize, isStoredProcedure);
if (isStoredProcedure)
{
// Query implemented as a stored procedure, which must return a result set.
// Query sytax is: { ?= call PROCEDURE_NAME(?,...,?)}
getPlatform().registerOutResultSet((CallableStatement) stmt, 1);
sm.bindStatement(stmt, query, cld, 2);
if (logger.isDebugEnabled())
logger.debug("executeQuery: " + stmt);
stmt.execute();
rs = (ResultSet) ((CallableStatement) stmt).getObject(1);
}
else
{
sm.bindStatement(stmt, query, cld, 1);
if (logger.isDebugEnabled())
logger.debug("executeQuery: " + stmt);
rs = stmt.executeQuery();
}
return new ResultSetAndStatement(sm, stmt, rs, sql);
}
catch (PersistenceBrokerException e)
{
// release resources on exception
sm.closeResources(stmt, rs);
logger.error("PersistenceBrokerException during the execution of the query: " + e.getMessage(), e);
throw e;
}
catch (SQLException e)
{
// release resources on exception
sm.closeResources(stmt, rs);
throw ExceptionHelper.generateException(e, sql.getStatement(), null, logger, null);
}
} | java |
public ResultSetAndStatement executeSQL(
final String sql,
ClassDescriptor cld,
ValueContainer[] values,
boolean scrollable)
throws PersistenceBrokerException
{
if (logger.isDebugEnabled()) logger.debug("executeSQL: " + sql);
final boolean isStoredprocedure = isStoredProcedure(sql);
final StatementManagerIF sm = broker.serviceStatementManager();
PreparedStatement stmt = null;
ResultSet rs = null;
try
{
stmt = sm.getPreparedStatement(cld, sql,
scrollable, StatementManagerIF.FETCH_SIZE_NOT_EXPLICITLY_SET, isStoredprocedure);
if (isStoredprocedure)
{
// Query implemented as a stored procedure, which must return a result set.
// Query sytax is: { ?= call PROCEDURE_NAME(?,...,?)}
getPlatform().registerOutResultSet((CallableStatement) stmt, 1);
sm.bindValues(stmt, values, 2);
stmt.execute();
rs = (ResultSet) ((CallableStatement) stmt).getObject(1);
}
else
{
sm.bindValues(stmt, values, 1);
rs = stmt.executeQuery();
}
// as we return the resultset for further operations, we cannot release the statement yet.
// that has to be done by the JdbcAccess-clients (i.e. RsIterator, ProxyRsIterator and PkEnumeration.)
return new ResultSetAndStatement(sm, stmt, rs, new SelectStatement()
{
public Query getQueryInstance()
{
return null;
}
public int getColumnIndex(FieldDescriptor fld)
{
return JdbcType.MIN_INT;
}
public String getStatement()
{
return sql;
}
});
}
catch (PersistenceBrokerException e)
{
// release resources on exception
sm.closeResources(stmt, rs);
logger.error("PersistenceBrokerException during the execution of the SQL query: " + e.getMessage(), e);
throw e;
}
catch (SQLException e)
{
// release resources on exception
sm.closeResources(stmt, rs);
throw ExceptionHelper.generateException(e, sql, cld, values, logger, null);
}
} | java |
public int executeUpdateSQL(
String sqlStatement,
ClassDescriptor cld,
ValueContainer[] values1,
ValueContainer[] values2)
throws PersistenceBrokerException
{
if (logger.isDebugEnabled())
logger.debug("executeUpdateSQL: " + sqlStatement);
int result;
int index;
PreparedStatement stmt = null;
final StatementManagerIF sm = broker.serviceStatementManager();
try
{
stmt = sm.getPreparedStatement(cld, sqlStatement,
Query.NOT_SCROLLABLE, StatementManagerIF.FETCH_SIZE_NOT_APPLICABLE, isStoredProcedure(sqlStatement));
index = sm.bindValues(stmt, values1, 1);
sm.bindValues(stmt, values2, index);
result = stmt.executeUpdate();
}
catch (PersistenceBrokerException e)
{
logger.error("PersistenceBrokerException during the execution of the Update SQL query: " + e.getMessage(), e);
throw e;
}
catch (SQLException e)
{
ValueContainer[] tmp = addValues(values1, values2);
throw ExceptionHelper.generateException(e, sqlStatement, cld, tmp, logger, null);
}
finally
{
sm.closeResources(stmt, null);
}
return result;
} | java |
public void executeUpdate(ClassDescriptor cld, Object obj) throws PersistenceBrokerException
{
if (logger.isDebugEnabled())
{
logger.debug("executeUpdate: " + obj);
}
// obj with nothing but key fields is not updated
if (cld.getNonPkRwFields().length == 0)
{
return;
}
final StatementManagerIF sm = broker.serviceStatementManager();
PreparedStatement stmt = null;
// BRJ: preserve current locking values
// locking values will be restored in case of exception
ValueContainer[] oldLockingValues;
oldLockingValues = cld.getCurrentLockingValues(obj);
try
{
stmt = sm.getUpdateStatement(cld);
if (stmt == null)
{
logger.error("getUpdateStatement returned a null statement");
throw new PersistenceBrokerException("getUpdateStatement returned a null statement");
}
sm.bindUpdate(stmt, cld, obj);
if (logger.isDebugEnabled())
logger.debug("executeUpdate: " + stmt);
if ((stmt.executeUpdate() == 0) && cld.isLocking()) //BRJ
{
/**
* Kuali Foundation modification -- 6/19/2009
*/
String objToString = "";
try {
objToString = obj.toString();
} catch (Exception ex) {}
throw new OptimisticLockException("Object has been modified by someone else: " + objToString, obj);
/**
* End of Kuali Foundation modification
*/
}
// Harvest any return values.
harvestReturnValues(cld.getUpdateProcedure(), obj, stmt);
}
catch (OptimisticLockException e)
{
// Don't log as error
if (logger.isDebugEnabled())
logger.debug(
"OptimisticLockException during the execution of update: " + e.getMessage(),
e);
throw e;
}
catch (PersistenceBrokerException e)
{
// BRJ: restore old locking values
setLockingValues(cld, obj, oldLockingValues);
logger.error(
"PersistenceBrokerException during the execution of the update: " + e.getMessage(),
e);
throw e;
}
catch (SQLException e)
{
final String sql = broker.serviceSqlGenerator().getPreparedUpdateStatement(cld).getStatement();
throw ExceptionHelper.generateException(e, sql, cld, logger, obj);
}
finally
{
sm.closeResources(stmt, null);
}
} | java |
public Object materializeObject(ClassDescriptor cld, Identity oid)
throws PersistenceBrokerException
{
final StatementManagerIF sm = broker.serviceStatementManager();
final SelectStatement sql = broker.serviceSqlGenerator().getPreparedSelectByPkStatement(cld);
Object result = null;
PreparedStatement stmt = null;
ResultSet rs = null;
try
{
stmt = sm.getSelectByPKStatement(cld);
if (stmt == null)
{
logger.error("getSelectByPKStatement returned a null statement");
throw new PersistenceBrokerException("getSelectByPKStatement returned a null statement");
}
/*
arminw: currently a select by PK could never be a stored procedure,
thus we can always set 'false'. Is this correct??
*/
sm.bindSelect(stmt, oid, cld, false);
rs = stmt.executeQuery();
// data available read object, else return null
ResultSetAndStatement rs_stmt = new ResultSetAndStatement(broker.serviceStatementManager(), stmt, rs, sql);
if (rs.next())
{
Map row = new HashMap();
cld.getRowReader().readObjectArrayFrom(rs_stmt, row);
result = cld.getRowReader().readObjectFrom(row);
}
// close resources
rs_stmt.close();
}
catch (PersistenceBrokerException e)
{
// release resources on exception
sm.closeResources(stmt, rs);
logger.error("PersistenceBrokerException during the execution of materializeObject: " + e.getMessage(), e);
throw e;
}
catch (SQLException e)
{
// release resources on exception
sm.closeResources(stmt, rs);
throw ExceptionHelper.generateException(e, sql.getStatement(), cld, logger, null);
}
return result;
} | java |
private void setLockingValues(ClassDescriptor cld, Object obj, ValueContainer[] oldLockingValues)
{
FieldDescriptor fields[] = cld.getLockingFields();
for (int i=0; i<fields.length; i++)
{
PersistentField field = fields[i].getPersistentField();
Object lockVal = oldLockingValues[i].getValue();
field.set(obj, lockVal);
}
} | java |
private void harvestReturnValues(
ProcedureDescriptor proc,
Object obj,
PreparedStatement stmt)
throws PersistenceBrokerSQLException
{
// If the procedure descriptor is null or has no return values or
// if the statement is not a callable statment, then we're done.
if ((proc == null) || (!proc.hasReturnValues()))
{
return;
}
// Set up the callable statement
CallableStatement callable = (CallableStatement) stmt;
// This is the index that we'll use to harvest the return value(s).
int index = 0;
// If the proc has a return value, then try to harvest it.
if (proc.hasReturnValue())
{
// Increment the index
index++;
// Harvest the value.
this.harvestReturnValue(obj, callable, proc.getReturnValueFieldRef(), index);
}
// Check each argument. If it's returned by the procedure,
// then harvest the value.
Iterator iter = proc.getArguments().iterator();
while (iter.hasNext())
{
index++;
ArgumentDescriptor arg = (ArgumentDescriptor) iter.next();
if (arg.getIsReturnedByProcedure())
{
this.harvestReturnValue(obj, callable, arg.getFieldRef(), index);
}
}
} | java |
private void harvestReturnValue(
Object obj,
CallableStatement callable,
FieldDescriptor fmd,
int index)
throws PersistenceBrokerSQLException
{
try
{
// If we have a field descriptor, then we can harvest
// the return value.
if ((callable != null) && (fmd != null) && (obj != null))
{
// Get the value and convert it to it's appropriate
// java type.
Object value = fmd.getJdbcType().getObjectFromColumn(callable, index);
// Set the value of the persistent field.
fmd.getPersistentField().set(obj, fmd.getFieldConversion().sqlToJava(value));
}
}
catch (SQLException e)
{
String msg = "SQLException during the execution of harvestReturnValue"
+ " class="
+ obj.getClass().getName()
+ ","
+ " field="
+ fmd.getAttributeName()
+ " : "
+ e.getMessage();
logger.error(msg,e);
throw new PersistenceBrokerSQLException(msg, e);
}
} | java |
protected boolean isStoredProcedure(String sql)
{
/*
Stored procedures start with
{?= call <procedure-name>[<arg1>,<arg2>, ...]}
or
{call <procedure-name>[<arg1>,<arg2>, ...]}
but also statements with white space like
{ ?= call <procedure-name>[<arg1>,<arg2>, ...]}
are possible.
*/
int k = 0, i = 0;
char c;
while(k < 3 && i < sql.length())
{
c = sql.charAt(i);
if(c != ' ')
{
switch (k)
{
case 0:
if(c != '{') return false;
break;
case 1:
if(c != '?' && c != 'c') return false;
break;
case 2:
if(c != '=' && c != 'a') return false;
break;
}
k++;
}
i++;
}
return true;
} | java |
public String get() {
synchronized (LOCK) {
if (!initialised) {
// generate the random number
Random rnd = new Random(); // @todo need a different seed, this is now time based and I
// would prefer something different, like an object address
// get the random number, instead of getting an integer and converting that to base64 later,
// we get a string and narrow that down to base64, use the top 6 bits of the characters
// as they are more random than the bottom ones...
rnd.nextBytes(value); // get some random characters
value[3] = BASE64[((value[3] >> 2) & BITS_6)]; // NOSONAR
value[4] = BASE64[((value[4] >> 2) & BITS_6)]; // NOSONAR
value[5] = BASE64[((value[5] >> 2) & BITS_6)]; // NOSONAR
value[6] = BASE64[((value[6] >> 2) & BITS_6)]; // NOSONAR
value[7] = BASE64[((value[7] >> 2) & BITS_6)]; // NOSONAR
// complete the time part in the HIGH value of the token
// this also sets the initial low value
completeToken(rnd);
initialised = true;
}
// fill in LOW value in id
int l = low;
value[0] = BASE64[(l & BITS_6)];
l >>= SHIFT_6;
value[1] = BASE64[(l & BITS_6)];
l >>= SHIFT_6;
value[2] = BASE64[(l & BITS_6)];
String res = new String(value);
// increment LOW
low++;
if (low == LOW_MAX) {
low = 0;
}
if (low == lowLast) {
time = System.currentTimeMillis();
completeToken();
}
return res;
}
} | java |
public boolean removeReader(Object key, Object resourceId)
{
boolean result = false;
ObjectLocks objectLocks = null;
synchronized(locktable)
{
objectLocks = (ObjectLocks) locktable.get(resourceId);
if(objectLocks != null)
{
/**
* MBAIRD, last one out, close the door and turn off the lights.
* if no locks (readers or writers) exist for this object, let's remove
* it from the locktable.
*/
Map readers = objectLocks.getReaders();
result = readers.remove(key) != null;
if((objectLocks.getWriter() == null) && (readers.size() == 0))
{
locktable.remove(resourceId);
}
}
}
return result;
} | java |
public boolean removeWriter(Object key, Object resourceId)
{
boolean result = false;
ObjectLocks objectLocks = null;
synchronized(locktable)
{
objectLocks = (ObjectLocks) locktable.get(resourceId);
if(objectLocks != null)
{
/**
* MBAIRD, last one out, close the door and turn off the lights.
* if no locks (readers or writers) exist for this object, let's remove
* it from the locktable.
*/
LockEntry entry = objectLocks.getWriter();
if(entry != null && entry.isOwnedBy(key))
{
objectLocks.setWriter(null);
result = true;
// no need to check if writer is null, we just set it.
if(objectLocks.getReaders().size() == 0)
{
locktable.remove(resourceId);
}
}
}
}
return result;
} | java |
private List<StyleFilter> initStyleFilters(List<FeatureStyleInfo> styleDefinitions) throws GeomajasException {
List<StyleFilter> styleFilters = new ArrayList<StyleFilter>();
if (styleDefinitions == null || styleDefinitions.size() == 0) {
styleFilters.add(new StyleFilterImpl()); // use default.
} else {
for (FeatureStyleInfo styleDef : styleDefinitions) {
StyleFilterImpl styleFilterImpl = null;
String formula = styleDef.getFormula();
if (null != formula && formula.length() > 0) {
styleFilterImpl = new StyleFilterImpl(filterService.parseFilter(formula), styleDef);
} else {
styleFilterImpl = new StyleFilterImpl(Filter.INCLUDE, styleDef);
}
styleFilters.add(styleFilterImpl);
}
}
return styleFilters;
} | java |
public static List<Artifact> getAllArtifacts(final Module module){
final List<Artifact> artifacts = new ArrayList<Artifact>();
for(final Module subModule: module.getSubmodules()){
artifacts.addAll(getAllArtifacts(subModule));
}
artifacts.addAll(module.getArtifacts());
return artifacts;
} | java |
public static List<Dependency> getAllDependencies(final Module module) {
final Set<Dependency> dependencies = new HashSet<Dependency>();
final List<String> producedArtifacts = new ArrayList<String>();
for(final Artifact artifact: getAllArtifacts(module)){
producedArtifacts.add(artifact.getGavc());
}
dependencies.addAll(getAllDependencies(module, producedArtifacts));
return new ArrayList<Dependency>(dependencies);
} | java |
public static Set<Dependency> getAllDependencies(final Module module, final List<String> producedArtifacts) {
final Set<Dependency> dependencies = new HashSet<Dependency>();
for(final Dependency dependency: module.getDependencies()){
if(!producedArtifacts.contains(dependency.getTarget().getGavc())){
dependencies.add(dependency);
}
}
for(final Module subModule: module.getSubmodules()){
dependencies.addAll(getAllDependencies(subModule, producedArtifacts));
}
return dependencies;
} | java |
public static List<Dependency> getCorporateDependencies(final Module module, final List<String> corporateFilters) {
final List<Dependency> corporateDependencies = new ArrayList<Dependency>();
final Pattern corporatePattern = generateCorporatePattern(corporateFilters);
for(final Dependency dependency: getAllDependencies(module)){
if(dependency.getTarget().getGavc().matches(corporatePattern.pattern())){
corporateDependencies.add(dependency);
}
}
return corporateDependencies;
} | java |
protected boolean _load ()
{
java.sql.ResultSet rs = null;
try
{
// This synchronization is necessary for Oracle JDBC drivers 8.1.7, 9.0.1, 9.2.0.1
// The documentation says synchronization is done within the driver, but they
// must have overlooked something. Without the lock we'd get mysterious error
// messages.
synchronized(getDbMeta())
{
getDbMetaTreeModel().setStatusBarMessage("Reading columns for table " + getSchema().getCatalog().getCatalogName() + "." + getSchema().getSchemaName() + "." + getTableName());
rs = getDbMeta().getColumns(getSchema().getCatalog().getCatalogName(),
getSchema().getSchemaName(),
getTableName(), "%");
final java.util.ArrayList alNew = new java.util.ArrayList();
while (rs.next())
{
alNew.add(new DBMetaColumnNode(getDbMeta(), getDbMetaTreeModel(), DBMetaTableNode.this, rs.getString("COLUMN_NAME")));
}
alChildren = alNew;
javax.swing.SwingUtilities.invokeLater(new Runnable()
{
public void run()
{
getDbMetaTreeModel().nodeStructureChanged(DBMetaTableNode.this);
}
});
rs.close();
}
}
catch (java.sql.SQLException sqlEx)
{
this.getDbMetaTreeModel().reportSqlError("Error retrieving columns", sqlEx);
try
{
if (rs != null) rs.close ();
}
catch (java.sql.SQLException sqlEx2)
{
this.getDbMetaTreeModel().reportSqlError("Error retrieving columns", sqlEx2);
}
return false;
}
return true;
} | java |
private void configureCaching(HttpServletResponse response, int seconds) {
// HTTP 1.0 header
response.setDateHeader(HTTP_EXPIRES_HEADER, System.currentTimeMillis() + seconds * 1000L);
if (seconds > 0) {
// HTTP 1.1 header
response.setHeader(HTTP_CACHE_CONTROL_HEADER, "max-age=" + seconds);
} else {
// HTTP 1.1 header
response.setHeader(HTTP_CACHE_CONTROL_HEADER, "no-cache");
}
} | java |
public int compare(Object objA, Object objB)
{
String idAStr = ((FieldDescriptorDef)_fields.get(objA)).getProperty("id");
String idBStr = ((FieldDescriptorDef)_fields.get(objB)).getProperty("id");
int idA;
int idB;
try
{
idA = Integer.parseInt(idAStr);
}
catch (Exception ex)
{
return 1;
}
try
{
idB = Integer.parseInt(idBStr);
}
catch (Exception ex)
{
return -1;
}
return idA < idB ? -1 : (idA > idB ? 1 : 0);
} | java |
public boolean hasMoreElements()
{
try
{
if (!hasCalledCheck)
{
hasCalledCheck = true;
hasNext = resultSetAndStatment.m_rs.next();
}
}
catch (SQLException e)
{
LoggerFactory.getDefaultLogger().error(e);
//releaseDbResources();
hasNext = false;
}
finally
{
if(!hasNext)
{
releaseDbResources();
}
}
return hasNext;
} | java |
@RequestMapping(value = "/legendgraphic", method = RequestMethod.GET)
public ModelAndView getGraphic(@RequestParam("layerId") String layerId,
@RequestParam(value = "styleName", required = false) String styleName,
@RequestParam(value = "ruleIndex", required = false) Integer ruleIndex,
@RequestParam(value = "format", required = false) String format,
@RequestParam(value = "width", required = false) Integer width,
@RequestParam(value = "height", required = false) Integer height,
@RequestParam(value = "scale", required = false) Double scale,
@RequestParam(value = "allRules", required = false) Boolean allRules, HttpServletRequest request)
throws GeomajasException {
if (!allRules) {
return getGraphic(layerId, styleName, ruleIndex, format, width, height, scale);
} else {
return getGraphics(layerId, styleName, format, width, height, scale);
}
} | java |
public boolean checkRead(TransactionImpl tx, Object obj)
{
if (hasReadLock(tx, obj))
{
return true;
}
LockEntry writer = getWriter(obj);
if (writer.isOwnedBy(tx))
{
return true;
}
return false;
} | java |
public boolean checkWrite(TransactionImpl tx, Object obj)
{
LockEntry writer = getWriter(obj);
if (writer == null)
return false;
else if (writer.isOwnedBy(tx))
return true;
else
return false;
} | java |
private Class getDynamicProxyClass(Class baseClass) {
Class[] m_dynamicProxyClassInterfaces;
if (foundInterfaces.containsKey(baseClass)) {
m_dynamicProxyClassInterfaces = (Class[])foundInterfaces.get(baseClass);
} else {
m_dynamicProxyClassInterfaces = getInterfaces(baseClass);
foundInterfaces.put(baseClass, m_dynamicProxyClassInterfaces);
}
// return dynymic Proxy Class implementing all interfaces
Class proxyClazz = Proxy.getProxyClass(baseClass.getClassLoader(), m_dynamicProxyClassInterfaces);
return proxyClazz;
} | java |
private Class[] getInterfaces(Class clazz) {
Class superClazz = clazz;
Class[] interfaces = clazz.getInterfaces();
// clazz can be an interface itself and when getInterfaces()
// is called on an interface it returns only the extending
// interfaces, not the interface itself.
if (clazz.isInterface()) {
Class[] tempInterfaces = new Class[interfaces.length + 1];
tempInterfaces[0] = clazz;
System.arraycopy(interfaces, 0, tempInterfaces, 1, interfaces.length);
interfaces = tempInterfaces;
}
// add all interfaces implemented by superclasses to the interfaces array
while ((superClazz = superClazz.getSuperclass()) != null) {
Class[] superInterfaces = superClazz.getInterfaces();
Class[] combInterfaces = new Class[interfaces.length + superInterfaces.length];
System.arraycopy(interfaces, 0, combInterfaces, 0, interfaces.length);
System.arraycopy(superInterfaces, 0, combInterfaces, interfaces.length, superInterfaces.length);
interfaces = combInterfaces;
}
/**
* Must remove duplicate interfaces before calling Proxy.getProxyClass().
* Duplicates can occur if a subclass re-declares that it implements
* the same interface as one of its ancestor classes.
**/
HashMap unique = new HashMap();
for (int i = 0; i < interfaces.length; i++) {
unique.put(interfaces[i].getName(), interfaces[i]);
}
/* Add the OJBProxy interface as well */
unique.put(OJBProxy.class.getName(), OJBProxy.class);
interfaces = (Class[])unique.values().toArray(new Class[unique.size()]);
return interfaces;
} | java |
public Object getRealKey()
{
if(keyRealSubject != null)
{
return keyRealSubject;
}
else
{
TransactionExt tx = getTransaction();
if((tx != null) && tx.isOpen())
{
prepareKeyRealSubject(tx.getBroker());
}
else
{
if(getPBKey() != null)
{
PBCapsule capsule = new PBCapsule(getPBKey(), null);
try
{
prepareKeyRealSubject(capsule.getBroker());
}
finally
{
capsule.destroy();
}
}
else
{
getLog().warn("No tx, no PBKey - can't materialise key with Identity " + getKeyOid());
}
}
}
return keyRealSubject;
} | java |
public Object getRealValue()
{
if(valueRealSubject != null)
{
return valueRealSubject;
}
else
{
TransactionExt tx = getTransaction();
if((tx != null) && tx.isOpen())
{
prepareValueRealSubject(tx.getBroker());
}
else
{
if(getPBKey() != null)
{
PBCapsule capsule = new PBCapsule(getPBKey(), null);
try
{
prepareValueRealSubject(capsule.getBroker());
}
finally
{
capsule.destroy();
}
}
else
{
getLog().warn("No tx, no PBKey - can't materialise value with Identity " + getKeyOid());
}
}
}
return valueRealSubject;
} | java |
private Object readMetadataFromXML(InputSource source, Class target)
throws MalformedURLException, ParserConfigurationException, SAXException, IOException
{
// TODO: make this configurable
boolean validate = false;
// get a xml reader instance:
SAXParserFactory factory = SAXParserFactory.newInstance();
log.info("RepositoryPersistor using SAXParserFactory : " + factory.getClass().getName());
if (validate)
{
factory.setValidating(true);
}
SAXParser p = factory.newSAXParser();
XMLReader reader = p.getXMLReader();
if (validate)
{
reader.setErrorHandler(new OJBErrorHandler());
}
Object result;
if (DescriptorRepository.class.equals(target))
{
// create an empty repository:
DescriptorRepository repository = new DescriptorRepository();
// create handler for building the repository structure
ContentHandler handler = new RepositoryXmlHandler(repository);
// tell parser to use our handler:
reader.setContentHandler(handler);
reader.parse(source);
result = repository;
}
else if (ConnectionRepository.class.equals(target))
{
// create an empty repository:
ConnectionRepository repository = new ConnectionRepository();
// create handler for building the repository structure
ContentHandler handler = new ConnectionDescriptorXmlHandler(repository);
// tell parser to use our handler:
reader.setContentHandler(handler);
reader.parse(source);
//LoggerFactory.getBootLogger().info("loading XML took " + (stop - start) + " msecs");
result = repository;
}
else
throw new MetadataException("Could not build a repository instance for '" + target +
"', using source " + source);
return result;
} | java |
public Criteria copy(boolean includeGroupBy, boolean includeOrderBy, boolean includePrefetchedRelationships)
{
Criteria copy = new Criteria();
copy.m_criteria = new Vector(this.m_criteria);
copy.m_negative = this.m_negative;
if (includeGroupBy)
{
copy.groupby = this.groupby;
}
if (includeOrderBy)
{
copy.orderby = this.orderby;
}
if (includePrefetchedRelationships)
{
copy.prefetchedRelationships = this.prefetchedRelationships;
}
return copy;
} | java |
protected List splitInCriteria(Object attribute, Collection values, boolean negative, int inLimit)
{
List result = new ArrayList();
Collection inCollection = new ArrayList();
if (values == null || values.isEmpty())
{
// OQL creates empty Criteria for late binding
result.add(buildInCriteria(attribute, negative, values));
}
else
{
Iterator iter = values.iterator();
while (iter.hasNext())
{
inCollection.add(iter.next());
if (inCollection.size() == inLimit || !iter.hasNext())
{
result.add(buildInCriteria(attribute, negative, inCollection));
inCollection = new ArrayList();
}
}
}
return result;
} | java |
List getOrderby()
{
List result = _getOrderby();
Iterator iter = getCriteria().iterator();
Object crit;
while (iter.hasNext())
{
crit = iter.next();
if (crit instanceof Criteria)
{
result.addAll(((Criteria) crit).getOrderby());
}
}
return result;
} | java |
public void addColumnIsNull(String column)
{
// PAW
//SelectionCriteria c = ValueCriteria.buildNullCriteria(column, getAlias());
SelectionCriteria c = ValueCriteria.buildNullCriteria(column, getUserAlias(column));
c.setTranslateAttribute(false);
addSelectionCriteria(c);
} | java |
public void addColumnNotNull(String column)
{
// PAW
// SelectionCriteria c = ValueCriteria.buildNotNullCriteria(column, getAlias());
SelectionCriteria c = ValueCriteria.buildNotNullCriteria(column, getUserAlias(column));
c.setTranslateAttribute(false);
addSelectionCriteria(c);
} | java |
public void addBetween(Object attribute, Object value1, Object value2)
{
// PAW
// addSelectionCriteria(ValueCriteria.buildBeweenCriteria(attribute, value1, value2, getAlias()));
addSelectionCriteria(ValueCriteria.buildBeweenCriteria(attribute, value1, value2, getUserAlias(attribute)));
} | java |