_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q9200 | GraphsHandler.addDependencyToGraph | train | 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 | {
"resource": ""
} |
q9201 | GraphsHandler.getModuleTree | train | 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 | {
"resource": ""
} |
q9202 | GraphsHandler.addModuleToTree | train | 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 | {
"resource": ""
} |
q9203 | MASReader.main | train | 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 | {
"resource": ""
} |
q9204 | AbstractProxyFactory.getIndirectionHandlerConstructor | train | 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 | {
"resource": ""
} |
q9205 | AbstractProxyFactory.setIndirectionHandlerClass | train | 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 | {
"resource": ""
} |
q9206 | AbstractProxyFactory.createIndirectionHandler | train | 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 | {
"resource": ""
} |
q9207 | AbstractProxyFactory.retrieveCollectionProxyConstructor | train | 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 | {
"resource": ""
} |
q9208 | AbstractProxyFactory.createCollectionProxy | train | 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 | {
"resource": ""
} |
q9209 | AbstractProxyFactory.getRealObject | train | 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 | {
"resource": ""
} |
q9210 | AbstractProxyFactory.getRealObjectIfMaterialized | train | 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 | {
"resource": ""
} |
q9211 | AbstractProxyFactory.getRealClass | train | 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 | {
"resource": ""
} |
q9212 | AbstractProxyFactory.getIndirectionHandler | train | 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 | {
"resource": ""
} |
q9213 | AbstractProxyFactory.isMaterialized | train | public boolean isMaterialized(Object object)
{
IndirectionHandler handler = getIndirectionHandler(object);
return handler == null || handler.alreadyMaterialized();
} | java | {
"resource": ""
} |
q9214 | OrganizationHandler.getOrganization | train | 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 | {
"resource": ""
} |
q9215 | OrganizationHandler.deleteOrganization | train | public void deleteOrganization(final String organizationId) {
final DbOrganization dbOrganization = getOrganization(organizationId);
repositoryHandler.deleteOrganization(dbOrganization.getName());
repositoryHandler.removeModulesOrganization(dbOrganization);
} | java | {
"resource": ""
} |
q9216 | OrganizationHandler.getCorporateGroupIds | train | public List<String> getCorporateGroupIds(final String organizationId) {
final DbOrganization dbOrganization = getOrganization(organizationId);
return dbOrganization.getCorporateGroupIdPrefixes();
} | java | {
"resource": ""
} |
q9217 | OrganizationHandler.addCorporateGroupId | train | 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 | {
"resource": ""
} |
q9218 | OrganizationHandler.removeCorporateGroupId | train | 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 | {
"resource": ""
} |
q9219 | OrganizationHandler.getMatchingOrganization | train | 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 | {
"resource": ""
} |
q9220 | JdbcAccessImpl.executeDelete | train | 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 | {
"resource": ""
} |
q9221 | JdbcAccessImpl.executeInsert | train | 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 | {
"resource": ""
} |
q9222 | JdbcAccessImpl.executeQuery | train | 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 | {
"resource": ""
} |
q9223 | JdbcAccessImpl.executeSQL | train | 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 | {
"resource": ""
} |
q9224 | JdbcAccessImpl.executeUpdateSQL | train | 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 | {
"resource": ""
} |
q9225 | JdbcAccessImpl.executeUpdate | train | 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 | {
"resource": ""
} |
q9226 | JdbcAccessImpl.materializeObject | train | 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 | {
"resource": ""
} |
q9227 | JdbcAccessImpl.setLockingValues | train | 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 | {
"resource": ""
} |
q9228 | JdbcAccessImpl.harvestReturnValues | train | 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 | {
"resource": ""
} |
q9229 | JdbcAccessImpl.harvestReturnValue | train | 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 | {
"resource": ""
} |
q9230 | JdbcAccessImpl.isStoredProcedure | train | 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 | {
"resource": ""
} |
q9231 | AuthenticationTokenGeneratorService.get | train | 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 | {
"resource": ""
} |
q9232 | LockManagerInMemoryImpl.removeReader | train | 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 | {
"resource": ""
} |
q9233 | LockManagerInMemoryImpl.removeWriter | train | 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 | {
"resource": ""
} |
q9234 | GetFeaturesStyleStep.initStyleFilters | train | 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 | {
"resource": ""
} |
q9235 | ModuleUtils.getAllArtifacts | train | 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 | {
"resource": ""
} |
q9236 | ModuleUtils.getAllDependencies | train | 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 | {
"resource": ""
} |
q9237 | ModuleUtils.getAllDependencies | train | 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 | {
"resource": ""
} |
q9238 | ModuleUtils.getCorporateDependencies | train | 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 | {
"resource": ""
} |
q9239 | DBMetaTableNode._load | train | 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 | {
"resource": ""
} |
q9240 | ResourceServlet.configureCaching | train | 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 | {
"resource": ""
} |
q9241 | FieldWithIdComparator.compare | train | 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 | {
"resource": ""
} |
q9242 | PkEnumeration.hasMoreElements | train | 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 | {
"resource": ""
} |
q9243 | LegendGraphicController.getGraphic | train | @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 | {
"resource": ""
} |
q9244 | ReadCommittedStrategy.checkRead | train | 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 | {
"resource": ""
} |
q9245 | ReadCommittedStrategy.checkWrite | train | 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 | {
"resource": ""
} |
q9246 | ProxyFactoryJDKImpl.getDynamicProxyClass | train | 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 | {
"resource": ""
} |
q9247 | ProxyFactoryJDKImpl.getInterfaces | train | 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 | {
"resource": ""
} |
q9248 | DMapEntry.getRealKey | train | 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 | {
"resource": ""
} |
q9249 | DMapEntry.getRealValue | train | 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 | {
"resource": ""
} |
q9250 | RepositoryPersistor.readMetadataFromXML | train | 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 | {
"resource": ""
} |
q9251 | Criteria.copy | train | 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 | {
"resource": ""
} |
q9252 | Criteria.splitInCriteria | train | 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 | {
"resource": ""
} |
q9253 | Criteria.getOrderby | train | 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 | {
"resource": ""
} |
q9254 | Criteria.addColumnIsNull | train | 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 | {
"resource": ""
} |
q9255 | Criteria.addColumnNotNull | train | 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 | {
"resource": ""
} |
q9256 | Criteria.addBetween | train | 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 | {
"resource": ""
} |
q9257 | Criteria.addNotBetween | train | public void addNotBetween(Object attribute, Object value1, Object value2)
{
// PAW
// addSelectionCriteria(ValueCriteria.buildNotBeweenCriteria(attribute, value1, value2, getAlias()));
addSelectionCriteria(ValueCriteria.buildNotBeweenCriteria(attribute, value1, value2, getUserAlias(attribute)));
} | java | {
"resource": ""
} |
q9258 | Criteria.addIn | train | public void addIn(Object attribute, Query subQuery)
{
// PAW
// addSelectionCriteria(ValueCriteria.buildInCriteria(attribute, subQuery, getAlias()));
addSelectionCriteria(ValueCriteria.buildInCriteria(attribute, subQuery, getUserAlias(attribute)));
} | java | {
"resource": ""
} |
q9259 | Criteria.addNotIn | train | public void addNotIn(String attribute, Query subQuery)
{
// PAW
// addSelectionCriteria(ValueCriteria.buildNotInCriteria(attribute, subQuery, getAlias()));
addSelectionCriteria(ValueCriteria.buildNotInCriteria(attribute, subQuery, getUserAlias(attribute)));
} | java | {
"resource": ""
} |
q9260 | Criteria.getGroupby | train | List getGroupby()
{
List result = _getGroupby();
Iterator iter = getCriteria().iterator();
Object crit;
while (iter.hasNext())
{
crit = iter.next();
if (crit instanceof Criteria)
{
result.addAll(((Criteria) crit).getGroupby());
}
}
return result;
} | java | {
"resource": ""
} |
q9261 | Criteria.addGroupBy | train | public void addGroupBy(String[] fieldNames)
{
for (int i = 0; i < fieldNames.length; i++)
{
addGroupBy(fieldNames[i]);
}
} | java | {
"resource": ""
} |
q9262 | Criteria.getSqlInLimit | train | private static int getSqlInLimit()
{
try
{
PersistenceBrokerConfiguration config = (PersistenceBrokerConfiguration) PersistenceBrokerFactory
.getConfigurator().getConfigurationFor(null);
return config.getSqlInLimit();
}
catch (ConfigurationException e)
{
return 200;
}
} | java | {
"resource": ""
} |
q9263 | Criteria.getUserAlias | train | private UserAlias getUserAlias(Object attribute)
{
if (m_userAlias != null)
{
return m_userAlias;
}
if (!(attribute instanceof String))
{
return null;
}
if (m_alias == null)
{
return null;
}
if (m_aliasPath == null)
{
boolean allPathsAliased = true;
return new UserAlias(m_alias, (String)attribute, allPathsAliased);
}
return new UserAlias(m_alias, (String)attribute, m_aliasPath);
} | java | {
"resource": ""
} |
q9264 | Criteria.setAlias | train | public void setAlias(String alias)
{
if (alias == null || alias.trim().equals(""))
{
m_alias = null;
}
else
{
m_alias = alias;
}
// propagate to SelectionCriteria,not to Criteria
for (int i = 0; i < m_criteria.size(); i++)
{
if (!(m_criteria.elementAt(i) instanceof Criteria))
{
((SelectionCriteria) m_criteria.elementAt(i)).setAlias(m_alias);
}
}
} | java | {
"resource": ""
} |
q9265 | Criteria.setAlias | train | public void setAlias(UserAlias userAlias)
{
m_alias = userAlias.getName();
// propagate to SelectionCriteria,not to Criteria
for (int i = 0; i < m_criteria.size(); i++)
{
if (!(m_criteria.elementAt(i) instanceof Criteria))
{
((SelectionCriteria) m_criteria.elementAt(i)).setAlias(userAlias);
}
}
} | java | {
"resource": ""
} |
q9266 | Criteria.getPathClasses | train | public Map getPathClasses()
{
if (m_pathClasses.isEmpty())
{
if (m_parentCriteria == null)
{
if (m_query == null)
{
return m_pathClasses;
}
else
{
return m_query.getPathClasses();
}
}
else
{
return m_parentCriteria.getPathClasses();
}
}
else
{
return m_pathClasses;
}
} | java | {
"resource": ""
} |
q9267 | PlatformWLOracle9iImpl.beforeBatch | train | public void beforeBatch(PreparedStatement stmt) throws PlatformException
{
// Check for Oracle batching support
final Method methodSetExecuteBatch;
final Method methodSendBatch;
methodSetExecuteBatch = ClassHelper.getMethod(stmt, "setExecuteBatch", PARAM_TYPE_INTEGER);
methodSendBatch = ClassHelper.getMethod(stmt, "sendBatch", null);
final boolean statementBatchingSupported = methodSetExecuteBatch != null && methodSendBatch != null;
if (statementBatchingSupported)
{
try
{
// Set number of statements per batch
methodSetExecuteBatch.invoke(stmt, PARAM_STATEMENT_BATCH_SIZE);
m_batchStatementsInProgress.put(stmt, methodSendBatch);
}
catch (Exception e)
{
throw new PlatformException(e.getLocalizedMessage(), e);
}
}
else
{
super.beforeBatch(stmt);
}
} | java | {
"resource": ""
} |
q9268 | PlatformWLOracle9iImpl.addBatch | train | public void addBatch(PreparedStatement stmt) throws PlatformException
{
// Check for Oracle batching support
final boolean statementBatchingSupported = m_batchStatementsInProgress.containsKey(stmt);
if (statementBatchingSupported)
{
try
{
stmt.executeUpdate();
}
catch (SQLException e)
{
throw new PlatformException(e.getLocalizedMessage(), e);
}
}
else
{
super.addBatch(stmt);
}
} | java | {
"resource": ""
} |
q9269 | PlatformWLOracle9iImpl.executeBatch | train | public int[] executeBatch(PreparedStatement stmt) throws PlatformException
{
// Check for Oracle batching support
final Method methodSendBatch = (Method) m_batchStatementsInProgress.remove(stmt);
final boolean statementBatchingSupported = methodSendBatch != null;
int[] retval = null;
if (statementBatchingSupported)
{
try
{
// sendBatch() returns total row count as an Integer
methodSendBatch.invoke(stmt, null);
}
catch (Exception e)
{
throw new PlatformException(e.getLocalizedMessage(), e);
}
}
else
{
retval = super.executeBatch(stmt);
}
return retval;
} | java | {
"resource": ""
} |
q9270 | BeanDefinitionDtoConverterServiceImpl.toInternal | train | public BeanDefinition toInternal(BeanDefinitionInfo beanDefinitionInfo) {
if (beanDefinitionInfo instanceof GenericBeanDefinitionInfo) {
GenericBeanDefinitionInfo genericInfo = (GenericBeanDefinitionInfo) beanDefinitionInfo;
GenericBeanDefinition def = new GenericBeanDefinition();
def.setBeanClassName(genericInfo.getClassName());
if (genericInfo.getPropertyValues() != null) {
MutablePropertyValues propertyValues = new MutablePropertyValues();
for (Entry<String, BeanMetadataElementInfo> entry : genericInfo.getPropertyValues().entrySet()) {
BeanMetadataElementInfo info = entry.getValue();
propertyValues.add(entry.getKey(), toInternal(info));
}
def.setPropertyValues(propertyValues);
}
return def;
} else if (beanDefinitionInfo instanceof ObjectBeanDefinitionInfo) {
ObjectBeanDefinitionInfo objectInfo = (ObjectBeanDefinitionInfo) beanDefinitionInfo;
return createBeanDefinitionByIntrospection(objectInfo.getObject());
} else {
throw new IllegalArgumentException("Conversion to internal of " + beanDefinitionInfo.getClass().getName()
+ " not implemented");
}
} | java | {
"resource": ""
} |
q9271 | BeanDefinitionDtoConverterServiceImpl.toDto | train | public BeanDefinitionInfo toDto(BeanDefinition beanDefinition) {
if (beanDefinition instanceof GenericBeanDefinition) {
GenericBeanDefinitionInfo info = new GenericBeanDefinitionInfo();
info.setClassName(beanDefinition.getBeanClassName());
if (beanDefinition.getPropertyValues() != null) {
Map<String, BeanMetadataElementInfo> propertyValues = new HashMap<String, BeanMetadataElementInfo>();
for (PropertyValue value : beanDefinition.getPropertyValues().getPropertyValueList()) {
Object obj = value.getValue();
if (obj instanceof BeanMetadataElement) {
propertyValues.put(value.getName(), toDto((BeanMetadataElement) obj));
} else {
throw new IllegalArgumentException("Type " + obj.getClass().getName()
+ " is not a BeanMetadataElement for property: " + value.getName());
}
}
info.setPropertyValues(propertyValues);
}
return info;
} else {
throw new IllegalArgumentException("Conversion to DTO of " + beanDefinition.getClass().getName()
+ " not implemented");
}
} | java | {
"resource": ""
} |
q9272 | BeanDefinitionDtoConverterServiceImpl.validate | train | private void validate(Object object) {
Set<ConstraintViolation<Object>> viols = validator.validate(object);
for (ConstraintViolation<Object> constraintViolation : viols) {
if (Null.class.isAssignableFrom(constraintViolation.getConstraintDescriptor().getAnnotation().getClass())) {
Object o = constraintViolation.getLeafBean();
Iterator<Node> iterator = constraintViolation.getPropertyPath().iterator();
String propertyName = null;
while (iterator.hasNext()) {
propertyName = iterator.next().getName();
}
if (propertyName != null) {
try {
PropertyDescriptor descriptor = BeanUtils.getPropertyDescriptor(o.getClass(), propertyName);
descriptor.getWriteMethod().invoke(o, new Object[] { null });
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
} | java | {
"resource": ""
} |
q9273 | ConnectionFactoryAbstractImpl.initializeJdbcConnection | train | protected void initializeJdbcConnection(Connection con, JdbcConnectionDescriptor jcd)
throws LookupException
{
try
{
PlatformFactory.getPlatformFor(jcd).initializeJdbcConnection(jcd, con);
}
catch (PlatformException e)
{
throw new LookupException("Platform dependent initialization of connection failed", e);
}
} | java | {
"resource": ""
} |
q9274 | ConnectionFactoryAbstractImpl.newConnectionFromDataSource | train | protected Connection newConnectionFromDataSource(JdbcConnectionDescriptor jcd)
throws LookupException
{
Connection retval = null;
// use JNDI lookup
DataSource ds = jcd.getDataSource();
if (ds == null)
{
// [tomdz] Would it suffice to store the datasources only at the JCDs ?
// Only possible problem would be serialization of the JCD because
// the data source object in the JCD does not 'survive' this
ds = (DataSource) dataSourceCache.get(jcd.getDatasourceName());
}
try
{
if (ds == null)
{
/**
* this synchronization block won't be a big deal as we only look up
* new datasources not found in the map.
*/
synchronized (dataSourceCache)
{
InitialContext ic = new InitialContext();
ds = (DataSource) ic.lookup(jcd.getDatasourceName());
/**
* cache the datasource lookup.
*/
dataSourceCache.put(jcd.getDatasourceName(), ds);
}
}
if (jcd.getUserName() == null)
{
retval = ds.getConnection();
}
else
{
retval = ds.getConnection(jcd.getUserName(), jcd.getPassWord());
}
}
catch (SQLException sqlEx)
{
log.error("SQLException thrown while trying to get Connection from Datasource (" +
jcd.getDatasourceName() + ")", sqlEx);
throw new LookupException("SQLException thrown while trying to get Connection from Datasource (" +
jcd.getDatasourceName() + ")", sqlEx);
}
catch (NamingException namingEx)
{
log.error("Naming Exception while looking up DataSource (" + jcd.getDatasourceName() + ")", namingEx);
throw new LookupException("Naming Exception while looking up DataSource (" + jcd.getDatasourceName() +
")", namingEx);
}
// initialize connection
initializeJdbcConnection(retval, jcd);
if(log.isDebugEnabled()) log.debug("Create new connection using DataSource: "+retval);
return retval;
} | java | {
"resource": ""
} |
q9275 | ConnectionFactoryAbstractImpl.newConnectionFromDriverManager | train | protected Connection newConnectionFromDriverManager(JdbcConnectionDescriptor jcd)
throws LookupException
{
Connection retval = null;
// use JDBC DriverManager
final String driver = jcd.getDriver();
final String url = getDbURL(jcd);
try
{
// loads the driver - NB call to newInstance() added to force initialisation
ClassHelper.getClass(driver, true);
final String user = jcd.getUserName();
final String password = jcd.getPassWord();
final Properties properties = getJdbcProperties(jcd, user, password);
if (properties.isEmpty())
{
if (user == null)
{
retval = DriverManager.getConnection(url);
}
else
{
retval = DriverManager.getConnection(url, user, password);
}
}
else
{
retval = DriverManager.getConnection(url, properties);
}
}
catch (SQLException sqlEx)
{
log.error("Error getting Connection from DriverManager with url (" + url + ") and driver (" + driver + ")", sqlEx);
throw new LookupException("Error getting Connection from DriverManager with url (" + url + ") and driver (" + driver + ")", sqlEx);
}
catch (ClassNotFoundException cnfEx)
{
log.error(cnfEx);
throw new LookupException("A class was not found", cnfEx);
}
catch (Exception e)
{
log.error("Instantiation of jdbc driver failed", e);
throw new LookupException("Instantiation of jdbc driver failed", e);
}
// initialize connection
initializeJdbcConnection(retval, jcd);
if(log.isDebugEnabled()) log.debug("Create new connection using DriverManager: "+retval);
return retval;
} | java | {
"resource": ""
} |
q9276 | PreparedModel.prepareModel | train | private void prepareModel(DescriptorRepository model)
{
TreeMap result = new TreeMap();
for (Iterator it = model.getDescriptorTable().values().iterator(); it.hasNext();)
{
ClassDescriptor classDesc = (ClassDescriptor)it.next();
if (classDesc.getFullTableName() == null)
{
// not mapped to a database table
continue;
}
String elementName = getElementName(classDesc);
Table mappedTable = getTableFor(elementName);
Map columnsMap = getColumnsFor(elementName);
Map requiredAttributes = getRequiredAttributes(elementName);
List classDescs = getClassDescriptorsMappingTo(elementName);
if (mappedTable == null)
{
mappedTable = _schema.findTable(classDesc.getFullTableName());
if (mappedTable == null)
{
continue;
}
columnsMap = new TreeMap();
requiredAttributes = new HashMap();
classDescs = new ArrayList();
_elementToTable.put(elementName, mappedTable);
_elementToClassDescriptors.put(elementName, classDescs);
_elementToColumnMap.put(elementName, columnsMap);
_elementToRequiredAttributesMap.put(elementName, requiredAttributes);
}
classDescs.add(classDesc);
extractAttributes(classDesc, mappedTable, columnsMap, requiredAttributes);
}
extractIndirectionTables(model, _schema);
} | java | {
"resource": ""
} |
q9277 | FoundationFileRollingAppender.subAppend | train | @Override
protected final void subAppend(final LoggingEvent event) {
if (event instanceof ScheduledFileRollEvent) {
// the scheduled append() call has been made by a different thread
synchronized (this) {
if (this.closed) {
// just consume the event
return;
}
this.rollFile(event);
}
} else if (event instanceof FileRollEvent) {
// definitely want to avoid rolling here whilst a file roll event is still being handled
super.subAppend(event);
} else {
if(event instanceof FoundationLof4jLoggingEvent){
FoundationLof4jLoggingEvent foundationLof4jLoggingEvent = (FoundationLof4jLoggingEvent)event;
foundationLof4jLoggingEvent.setAppenderName(this.getName());
}
this.rollFile(event);
super.subAppend(event);
}
} | java | {
"resource": ""
} |
q9278 | BridgeMockAgent.updateIntegerBelief | train | public void updateIntegerBelief(String name, int value) {
introspector.storeBeliefValue(this, name, getIntegerBelief(name) + value);
} | java | {
"resource": ""
} |
q9279 | BridgeMockAgent.getIntegerBelief | train | public int getIntegerBelief(String name){
Object belief = introspector.getBeliefBase(this).get(name);
int count = 0;
if (belief!=null) {
count = (Integer) belief;
}
return (Integer) count;
} | java | {
"resource": ""
} |
q9280 | ExcelService.fromExcel | train | @Programmatic
public <T> List<T> fromExcel(
final Blob excelBlob,
final Class<T> cls,
final String sheetName) throws ExcelService.Exception {
return fromExcel(excelBlob, new WorksheetSpec(cls, sheetName));
} | java | {
"resource": ""
} |
q9281 | LocalTxManager.getCurrentTransaction | train | public TransactionImpl getCurrentTransaction()
{
TransactionImpl tx = tx_table.get(Thread.currentThread());
if(tx == null)
{
throw new TransactionNotInProgressException("Calling method needed transaction, but no transaction found for current thread :-(");
}
return tx;
} | java | {
"resource": ""
} |
q9282 | ClassDescriptorDef.getDefaultTableName | train | public String getDefaultTableName()
{
String name = getName();
int lastDotPos = name.lastIndexOf('.');
int lastDollarPos = name.lastIndexOf('$');
return lastDollarPos > lastDotPos ? name.substring(lastDollarPos + 1) : name.substring(lastDotPos + 1);
} | java | {
"resource": ""
} |
q9283 | ClassDescriptorDef.sortFields | train | private void sortFields()
{
HashMap fields = new HashMap();
ArrayList fieldsWithId = new ArrayList();
ArrayList fieldsWithoutId = new ArrayList();
FieldDescriptorDef fieldDef;
for (Iterator it = getFields(); it.hasNext(); )
{
fieldDef = (FieldDescriptorDef)it.next();
fields.put(fieldDef.getName(), fieldDef);
if (fieldDef.hasProperty(PropertyHelper.OJB_PROPERTY_ID))
{
fieldsWithId.add(fieldDef.getName());
}
else
{
fieldsWithoutId.add(fieldDef.getName());
}
}
Collections.sort(fieldsWithId, new FieldWithIdComparator(fields));
ArrayList result = new ArrayList();
for (Iterator it = fieldsWithId.iterator(); it.hasNext();)
{
result.add(getField((String)it.next()));
}
for (Iterator it = fieldsWithoutId.iterator(); it.hasNext();)
{
result.add(getField((String)it.next()));
}
_fields = result;
} | java | {
"resource": ""
} |
q9284 | ClassDescriptorDef.checkConstraints | train | public void checkConstraints(String checkLevel) throws ConstraintException
{
// now checking constraints
FieldDescriptorConstraints fieldConstraints = new FieldDescriptorConstraints();
ReferenceDescriptorConstraints refConstraints = new ReferenceDescriptorConstraints();
CollectionDescriptorConstraints collConstraints = new CollectionDescriptorConstraints();
for (Iterator it = getFields(); it.hasNext();)
{
fieldConstraints.check((FieldDescriptorDef)it.next(), checkLevel);
}
for (Iterator it = getReferences(); it.hasNext();)
{
refConstraints.check((ReferenceDescriptorDef)it.next(), checkLevel);
}
for (Iterator it = getCollections(); it.hasNext();)
{
collConstraints.check((CollectionDescriptorDef)it.next(), checkLevel);
}
new ClassDescriptorConstraints().check(this, checkLevel);
} | java | {
"resource": ""
} |
q9285 | ClassDescriptorDef.contains | train | private boolean contains(ArrayList defs, DefBase obj)
{
for (Iterator it = defs.iterator(); it.hasNext();)
{
if (obj.getName().equals(((DefBase)it.next()).getName()))
{
return true;
}
}
return false;
} | java | {
"resource": ""
} |
q9286 | ClassDescriptorDef.cloneField | train | private FieldDescriptorDef cloneField(FieldDescriptorDef fieldDef, String prefix)
{
FieldDescriptorDef copyFieldDef = new FieldDescriptorDef(fieldDef, prefix);
copyFieldDef.setOwner(this);
// we remove properties that are only relevant to the class the features are declared in
copyFieldDef.setProperty(PropertyHelper.OJB_PROPERTY_IGNORE, null);
Properties mod = getModification(copyFieldDef.getName());
if (mod != null)
{
if (!PropertyHelper.toBoolean(mod.getProperty(PropertyHelper.OJB_PROPERTY_IGNORE), false) &&
hasFeature(copyFieldDef.getName()))
{
LogHelper.warn(true,
ClassDescriptorDef.class,
"process",
"Class "+getName()+" has a feature that has the same name as its included field "+
copyFieldDef.getName()+" from class "+fieldDef.getOwner().getName());
}
copyFieldDef.applyModifications(mod);
}
return copyFieldDef;
} | java | {
"resource": ""
} |
q9287 | ClassDescriptorDef.cloneReference | train | private ReferenceDescriptorDef cloneReference(ReferenceDescriptorDef refDef, String prefix)
{
ReferenceDescriptorDef copyRefDef = new ReferenceDescriptorDef(refDef, prefix);
copyRefDef.setOwner(this);
// we remove properties that are only relevant to the class the features are declared in
copyRefDef.setProperty(PropertyHelper.OJB_PROPERTY_IGNORE, null);
Properties mod = getModification(copyRefDef.getName());
if (mod != null)
{
if (!PropertyHelper.toBoolean(mod.getProperty(PropertyHelper.OJB_PROPERTY_IGNORE), false) &&
hasFeature(copyRefDef.getName()))
{
LogHelper.warn(true,
ClassDescriptorDef.class,
"process",
"Class "+getName()+" has a feature that has the same name as its included reference "+
copyRefDef.getName()+" from class "+refDef.getOwner().getName());
}
copyRefDef.applyModifications(mod);
}
return copyRefDef;
} | java | {
"resource": ""
} |
q9288 | ClassDescriptorDef.cloneCollection | train | private CollectionDescriptorDef cloneCollection(CollectionDescriptorDef collDef, String prefix)
{
CollectionDescriptorDef copyCollDef = new CollectionDescriptorDef(collDef, prefix);
copyCollDef.setOwner(this);
// we remove properties that are only relevant to the class the features are declared in
copyCollDef.setProperty(PropertyHelper.OJB_PROPERTY_IGNORE, null);
Properties mod = getModification(copyCollDef.getName());
if (mod != null)
{
if (!PropertyHelper.toBoolean(mod.getProperty(PropertyHelper.OJB_PROPERTY_IGNORE), false) &&
hasFeature(copyCollDef.getName()))
{
LogHelper.warn(true,
ClassDescriptorDef.class,
"process",
"Class "+getName()+" has a feature that has the same name as its included collection "+
copyCollDef.getName()+" from class "+collDef.getOwner().getName());
}
copyCollDef.applyModifications(mod);
}
return copyCollDef;
} | java | {
"resource": ""
} |
q9289 | ClassDescriptorDef.getAllBaseTypes | train | public Iterator getAllBaseTypes()
{
ArrayList baseTypes = new ArrayList();
baseTypes.addAll(_directBaseTypes.values());
for (int idx = baseTypes.size() - 1; idx >= 0; idx--)
{
ClassDescriptorDef curClassDef = (ClassDescriptorDef)baseTypes.get(idx);
for (Iterator it = curClassDef.getDirectBaseTypes(); it.hasNext();)
{
ClassDescriptorDef curBaseTypeDef = (ClassDescriptorDef)it.next();
if (!baseTypes.contains(curBaseTypeDef))
{
baseTypes.add(0, curBaseTypeDef);
idx++;
}
}
}
return baseTypes.iterator();
} | java | {
"resource": ""
} |
q9290 | ClassDescriptorDef.getAllExtentClasses | train | public Iterator getAllExtentClasses()
{
ArrayList subTypes = new ArrayList();
subTypes.addAll(_extents);
for (int idx = 0; idx < subTypes.size(); idx++)
{
ClassDescriptorDef curClassDef = (ClassDescriptorDef)subTypes.get(idx);
for (Iterator it = curClassDef.getExtentClasses(); it.hasNext();)
{
ClassDescriptorDef curSubTypeDef = (ClassDescriptorDef)it.next();
if (!subTypes.contains(curSubTypeDef))
{
subTypes.add(curSubTypeDef);
}
}
}
return subTypes.iterator();
} | java | {
"resource": ""
} |
q9291 | ClassDescriptorDef.getField | train | public FieldDescriptorDef getField(String name)
{
FieldDescriptorDef fieldDef = null;
for (Iterator it = _fields.iterator(); it.hasNext(); )
{
fieldDef = (FieldDescriptorDef)it.next();
if (fieldDef.getName().equals(name))
{
return fieldDef;
}
}
return null;
} | java | {
"resource": ""
} |
q9292 | ClassDescriptorDef.getFields | train | public ArrayList getFields(String fieldNames) throws NoSuchFieldException
{
ArrayList result = new ArrayList();
FieldDescriptorDef fieldDef;
String name;
for (CommaListIterator it = new CommaListIterator(fieldNames); it.hasNext();)
{
name = it.getNext();
fieldDef = getField(name);
if (fieldDef == null)
{
throw new NoSuchFieldException(name);
}
result.add(fieldDef);
}
return result;
} | java | {
"resource": ""
} |
q9293 | ClassDescriptorDef.getPrimaryKeys | train | public ArrayList getPrimaryKeys()
{
ArrayList result = new ArrayList();
FieldDescriptorDef fieldDef;
for (Iterator it = getFields(); it.hasNext();)
{
fieldDef = (FieldDescriptorDef)it.next();
if (fieldDef.getBooleanProperty(PropertyHelper.OJB_PROPERTY_PRIMARYKEY, false))
{
result.add(fieldDef);
}
}
return result;
} | java | {
"resource": ""
} |
q9294 | ClassDescriptorDef.getReference | train | public ReferenceDescriptorDef getReference(String name)
{
ReferenceDescriptorDef refDef;
for (Iterator it = _references.iterator(); it.hasNext(); )
{
refDef = (ReferenceDescriptorDef)it.next();
if (refDef.getName().equals(name))
{
return refDef;
}
}
return null;
} | java | {
"resource": ""
} |
q9295 | ClassDescriptorDef.getCollection | train | public CollectionDescriptorDef getCollection(String name)
{
CollectionDescriptorDef collDef = null;
for (Iterator it = _collections.iterator(); it.hasNext(); )
{
collDef = (CollectionDescriptorDef)it.next();
if (collDef.getName().equals(name))
{
return collDef;
}
}
return null;
} | java | {
"resource": ""
} |
q9296 | ClassDescriptorDef.getNested | train | public NestedDef getNested(String name)
{
NestedDef nestedDef = null;
for (Iterator it = _nested.iterator(); it.hasNext(); )
{
nestedDef = (NestedDef)it.next();
if (nestedDef.getName().equals(name))
{
return nestedDef;
}
}
return null;
} | java | {
"resource": ""
} |
q9297 | ClassDescriptorDef.getIndexDescriptor | train | public IndexDescriptorDef getIndexDescriptor(String name)
{
IndexDescriptorDef indexDef = null;
for (Iterator it = _indexDescriptors.iterator(); it.hasNext(); )
{
indexDef = (IndexDescriptorDef)it.next();
if (indexDef.getName().equals(name))
{
return indexDef;
}
}
return null;
} | java | {
"resource": ""
} |
q9298 | ClassDescriptorDef.addProcedure | train | public void addProcedure(ProcedureDef procDef)
{
procDef.setOwner(this);
_procedures.put(procDef.getName(), procDef);
} | java | {
"resource": ""
} |
q9299 | ClassDescriptorDef.addProcedureArgument | train | public void addProcedureArgument(ProcedureArgumentDef argDef)
{
argDef.setOwner(this);
_procedureArguments.put(argDef.getName(), argDef);
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.