_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q9300 | OjbTagsHandler.processClass | train | public void processClass(String template, Properties attributes) throws XDocletException
{
if (!_model.hasClass(getCurrentClass().getQualifiedName()))
{
// we only want to output the log message once
LogHelper.debug(true, OjbTagsHandler.class, "processClass", "Type "+getCurrentClass().getQualifiedName());
}
ClassDescriptorDef classDef = ensureClassDef(getCurrentClass());
String attrName;
for (Enumeration attrNames = attributes.propertyNames(); attrNames.hasMoreElements(); )
{
attrName = (String)attrNames.nextElement();
classDef.setProperty(attrName, attributes.getProperty(attrName));
}
_curClassDef = classDef;
generate(template);
_curClassDef = null;
} | java | {
"resource": ""
} |
q9301 | OjbTagsHandler.forAllClassDefinitions | train | public void forAllClassDefinitions(String template, Properties attributes) throws XDocletException
{
for (Iterator it = _model.getClasses(); it.hasNext(); )
{
_curClassDef = (ClassDescriptorDef)it.next();
generate(template);
}
_curClassDef = null;
LogHelper.debug(true, OjbTagsHandler.class, "forAllClassDefinitions", "Processed "+_model.getNumClasses()+" types");
} | java | {
"resource": ""
} |
q9302 | OjbTagsHandler.originalClass | train | public void originalClass(String template, Properties attributes) throws XDocletException
{
pushCurrentClass(_curClassDef.getOriginalClass());
generate(template);
popCurrentClass();
} | java | {
"resource": ""
} |
q9303 | OjbTagsHandler.addExtent | train | public String addExtent(Properties attributes) throws XDocletException
{
String name = attributes.getProperty(ATTRIBUTE_NAME);
if (!_model.hasClass(name))
{
throw new XDocletException(Translator.getString(XDocletModulesOjbMessages.class,
XDocletModulesOjbMessages.COULD_NOT_FIND_TYPE,
new String[]{name}));
}
_curClassDef.addExtentClass(_model.getClass(name));
return "";
} | java | {
"resource": ""
} |
q9304 | OjbTagsHandler.forAllExtents | train | public void forAllExtents(String template, Properties attributes) throws XDocletException
{
for (Iterator it = _curClassDef.getExtentClasses(); it.hasNext(); )
{
_curExtent = (ClassDescriptorDef)it.next();
generate(template);
}
_curExtent = null;
} | java | {
"resource": ""
} |
q9305 | OjbTagsHandler.processIndexDescriptor | train | public String processIndexDescriptor(Properties attributes) throws XDocletException
{
String name = attributes.getProperty(ATTRIBUTE_NAME);
IndexDescriptorDef indexDef = _curClassDef.getIndexDescriptor(name);
String attrName;
if (indexDef == null)
{
indexDef = new IndexDescriptorDef(name);
_curClassDef.addIndexDescriptor(indexDef);
}
if ((indexDef.getName() == null) || (indexDef.getName().length() == 0))
{
throw new XDocletException(Translator.getString(XDocletModulesOjbMessages.class,
XDocletModulesOjbMessages.INDEX_NAME_MISSING,
new String[]{_curClassDef.getName()}));
}
attributes.remove(ATTRIBUTE_NAME);
for (Enumeration attrNames = attributes.propertyNames(); attrNames.hasMoreElements(); )
{
attrName = (String)attrNames.nextElement();
indexDef.setProperty(attrName, attributes.getProperty(attrName));
}
return "";
} | java | {
"resource": ""
} |
q9306 | OjbTagsHandler.forAllIndexDescriptorDefinitions | train | public void forAllIndexDescriptorDefinitions(String template, Properties attributes) throws XDocletException
{
for (Iterator it = _curClassDef.getIndexDescriptors(); it.hasNext(); )
{
_curIndexDescriptorDef = (IndexDescriptorDef)it.next();
generate(template);
}
_curIndexDescriptorDef = null;
} | java | {
"resource": ""
} |
q9307 | OjbTagsHandler.forAllIndexDescriptorColumns | train | public void forAllIndexDescriptorColumns(String template, Properties attributes) throws XDocletException
{
String fields = _curIndexDescriptorDef.getProperty(PropertyHelper.OJB_PROPERTY_FIELDS);
FieldDescriptorDef fieldDef;
String name;
for (CommaListIterator it = new CommaListIterator(fields); it.hasNext();)
{
name = it.getNext();
fieldDef = _curClassDef.getField(name);
if (fieldDef == null)
{
throw new XDocletException(Translator.getString(XDocletModulesOjbMessages.class,
XDocletModulesOjbMessages.INDEX_FIELD_MISSING,
new String[]{name, _curIndexDescriptorDef.getName(), _curClassDef.getName()}));
}
_curIndexColumn = fieldDef.getProperty(PropertyHelper.OJB_PROPERTY_COLUMN);
generate(template);
}
_curIndexColumn = null;
} | java | {
"resource": ""
} |
q9308 | OjbTagsHandler.processObjectCache | train | public String processObjectCache(Properties attributes) throws XDocletException
{
ObjectCacheDef objCacheDef = _curClassDef.setObjectCache(attributes.getProperty(ATTRIBUTE_CLASS));
String attrName;
attributes.remove(ATTRIBUTE_CLASS);
for (Enumeration attrNames = attributes.propertyNames(); attrNames.hasMoreElements(); )
{
attrName = (String)attrNames.nextElement();
objCacheDef.setProperty(attrName, attributes.getProperty(attrName));
}
return "";
} | java | {
"resource": ""
} |
q9309 | OjbTagsHandler.forObjectCache | train | public void forObjectCache(String template, Properties attributes) throws XDocletException
{
_curObjectCacheDef = _curClassDef.getObjectCache();
if (_curObjectCacheDef != null)
{
generate(template);
_curObjectCacheDef = null;
}
} | java | {
"resource": ""
} |
q9310 | OjbTagsHandler.processProcedure | train | public String processProcedure(Properties attributes) throws XDocletException
{
String type = attributes.getProperty(ATTRIBUTE_TYPE);
ProcedureDef procDef = _curClassDef.getProcedure(type);
String attrName;
if (procDef == null)
{
procDef = new ProcedureDef(type);
_curClassDef.addProcedure(procDef);
}
for (Enumeration attrNames = attributes.propertyNames(); attrNames.hasMoreElements(); )
{
attrName = (String)attrNames.nextElement();
procDef.setProperty(attrName, attributes.getProperty(attrName));
}
return "";
} | java | {
"resource": ""
} |
q9311 | OjbTagsHandler.forAllProcedures | train | public void forAllProcedures(String template, Properties attributes) throws XDocletException
{
for (Iterator it = _curClassDef.getProcedures(); it.hasNext(); )
{
_curProcedureDef = (ProcedureDef)it.next();
generate(template);
}
_curProcedureDef = null;
} | java | {
"resource": ""
} |
q9312 | OjbTagsHandler.processProcedureArgument | train | public String processProcedureArgument(Properties attributes) throws XDocletException
{
String id = attributes.getProperty(ATTRIBUTE_NAME);
ProcedureArgumentDef argDef = _curClassDef.getProcedureArgument(id);
String attrName;
if (argDef == null)
{
argDef = new ProcedureArgumentDef(id);
_curClassDef.addProcedureArgument(argDef);
}
attributes.remove(ATTRIBUTE_NAME);
for (Enumeration attrNames = attributes.propertyNames(); attrNames.hasMoreElements(); )
{
attrName = (String)attrNames.nextElement();
argDef.setProperty(attrName, attributes.getProperty(attrName));
}
return "";
} | java | {
"resource": ""
} |
q9313 | OjbTagsHandler.forAllProcedureArguments | train | public void forAllProcedureArguments(String template, Properties attributes) throws XDocletException
{
String argNameList = _curProcedureDef.getProperty(PropertyHelper.OJB_PROPERTY_ARGUMENTS);
for (CommaListIterator it = new CommaListIterator(argNameList); it.hasNext();)
{
_curProcedureArgumentDef = _curClassDef.getProcedureArgument(it.getNext());
generate(template);
}
_curProcedureArgumentDef = null;
} | java | {
"resource": ""
} |
q9314 | OjbTagsHandler.processAnonymousField | train | public void processAnonymousField(Properties attributes) throws XDocletException
{
if (!attributes.containsKey(ATTRIBUTE_NAME))
{
throw new XDocletException(Translator.getString(XDocletModulesOjbMessages.class,
XDocletModulesOjbMessages.PARAMETER_IS_REQUIRED,
new String[]{ATTRIBUTE_NAME}));
}
String name = attributes.getProperty(ATTRIBUTE_NAME);
FieldDescriptorDef fieldDef = _curClassDef.getField(name);
String attrName;
if (fieldDef == null)
{
fieldDef = new FieldDescriptorDef(name);
_curClassDef.addField(fieldDef);
}
fieldDef.setAnonymous();
LogHelper.debug(false, OjbTagsHandler.class, "processAnonymousField", " Processing anonymous field "+fieldDef.getName());
attributes.remove(ATTRIBUTE_NAME);
for (Enumeration attrNames = attributes.propertyNames(); attrNames.hasMoreElements(); )
{
attrName = (String)attrNames.nextElement();
fieldDef.setProperty(attrName, attributes.getProperty(attrName));
}
fieldDef.setProperty(PropertyHelper.OJB_PROPERTY_ACCESS, "anonymous");
} | java | {
"resource": ""
} |
q9315 | OjbTagsHandler.processField | train | public void processField(String template, Properties attributes) throws XDocletException
{
String name = OjbMemberTagsHandler.getMemberName();
String defaultType = getDefaultJdbcTypeForCurrentMember();
String defaultConversion = getDefaultJdbcConversionForCurrentMember();
FieldDescriptorDef fieldDef = _curClassDef.getField(name);
String attrName;
if (fieldDef == null)
{
fieldDef = new FieldDescriptorDef(name);
_curClassDef.addField(fieldDef);
}
LogHelper.debug(false, OjbTagsHandler.class, "processField", " Processing field "+fieldDef.getName());
for (Enumeration attrNames = attributes.propertyNames(); attrNames.hasMoreElements(); )
{
attrName = (String)attrNames.nextElement();
fieldDef.setProperty(attrName, attributes.getProperty(attrName));
}
// storing additional info for later use
fieldDef.setProperty(PropertyHelper.OJB_PROPERTY_JAVA_TYPE,
OjbMemberTagsHandler.getMemberType().getQualifiedName());
fieldDef.setProperty(PropertyHelper.OJB_PROPERTY_DEFAULT_JDBC_TYPE, defaultType);
if (defaultConversion != null)
{
fieldDef.setProperty(PropertyHelper.OJB_PROPERTY_DEFAULT_CONVERSION, defaultConversion);
}
_curFieldDef = fieldDef;
generate(template);
_curFieldDef = null;
} | java | {
"resource": ""
} |
q9316 | OjbTagsHandler.processAnonymousReference | train | public void processAnonymousReference(Properties attributes) throws XDocletException
{
ReferenceDescriptorDef refDef = _curClassDef.getReference("super");
String attrName;
if (refDef == null)
{
refDef = new ReferenceDescriptorDef("super");
_curClassDef.addReference(refDef);
}
refDef.setAnonymous();
LogHelper.debug(false, OjbTagsHandler.class, "processAnonymousReference", " Processing anonymous reference");
for (Enumeration attrNames = attributes.propertyNames(); attrNames.hasMoreElements(); )
{
attrName = (String)attrNames.nextElement();
refDef.setProperty(attrName, attributes.getProperty(attrName));
}
} | java | {
"resource": ""
} |
q9317 | OjbTagsHandler.processReference | train | public void processReference(String template, Properties attributes) throws XDocletException
{
String name = OjbMemberTagsHandler.getMemberName();
XClass type = OjbMemberTagsHandler.getMemberType();
int dim = OjbMemberTagsHandler.getMemberDimension();
ReferenceDescriptorDef refDef = _curClassDef.getReference(name);
String attrName;
if (refDef == null)
{
refDef = new ReferenceDescriptorDef(name);
_curClassDef.addReference(refDef);
}
LogHelper.debug(false, OjbTagsHandler.class, "processReference", " Processing reference "+refDef.getName());
for (Enumeration attrNames = attributes.propertyNames(); attrNames.hasMoreElements(); )
{
attrName = (String)attrNames.nextElement();
refDef.setProperty(attrName, attributes.getProperty(attrName));
}
// storing default info for later use
if (type == null)
{
throw new XDocletException(Translator.getString(XDocletModulesOjbMessages.class,
XDocletModulesOjbMessages.COULD_NOT_DETERMINE_TYPE_OF_MEMBER,
new String[]{name}));
}
if (dim > 0)
{
throw new XDocletException(Translator.getString(XDocletModulesOjbMessages.class,
XDocletModulesOjbMessages.MEMBER_CANNOT_BE_A_REFERENCE,
new String[]{name, _curClassDef.getName()}));
}
refDef.setProperty(PropertyHelper.OJB_PROPERTY_VARIABLE_TYPE, type.getQualifiedName());
// searching for default type
String typeName = searchForPersistentSubType(type);
if (typeName != null)
{
refDef.setProperty(PropertyHelper.OJB_PROPERTY_DEFAULT_CLASS_REF, typeName);
}
_curReferenceDef = refDef;
generate(template);
_curReferenceDef = null;
} | java | {
"resource": ""
} |
q9318 | OjbTagsHandler.forAllReferenceDefinitions | train | public void forAllReferenceDefinitions(String template, Properties attributes) throws XDocletException
{
for (Iterator it = _curClassDef.getReferences(); it.hasNext(); )
{
_curReferenceDef = (ReferenceDescriptorDef)it.next();
// first we check whether it is an inherited anonymous reference
if (_curReferenceDef.isAnonymous() && (_curReferenceDef.getOwner() != _curClassDef))
{
continue;
}
if (!isFeatureIgnored(LEVEL_REFERENCE) &&
!_curReferenceDef.getBooleanProperty(PropertyHelper.OJB_PROPERTY_IGNORE, false))
{
generate(template);
}
}
_curReferenceDef = null;
} | java | {
"resource": ""
} |
q9319 | OjbTagsHandler.processCollection | train | public void processCollection(String template, Properties attributes) throws XDocletException
{
String name = OjbMemberTagsHandler.getMemberName();
CollectionDescriptorDef collDef = _curClassDef.getCollection(name);
String attrName;
if (collDef == null)
{
collDef = new CollectionDescriptorDef(name);
_curClassDef.addCollection(collDef);
}
LogHelper.debug(false, OjbTagsHandler.class, "processCollection", " Processing collection "+collDef.getName());
for (Enumeration attrNames = attributes.propertyNames(); attrNames.hasMoreElements(); )
{
attrName = (String)attrNames.nextElement();
collDef.setProperty(attrName, attributes.getProperty(attrName));
}
if (OjbMemberTagsHandler.getMemberDimension() > 0)
{
// we store the array-element type for later use
collDef.setProperty(PropertyHelper.OJB_PROPERTY_ARRAY_ELEMENT_CLASS_REF,
OjbMemberTagsHandler.getMemberType().getQualifiedName());
}
else
{
collDef.setProperty(PropertyHelper.OJB_PROPERTY_VARIABLE_TYPE,
OjbMemberTagsHandler.getMemberType().getQualifiedName());
}
_curCollectionDef = collDef;
generate(template);
_curCollectionDef = null;
} | java | {
"resource": ""
} |
q9320 | OjbTagsHandler.forAllCollectionDefinitions | train | public void forAllCollectionDefinitions(String template, Properties attributes) throws XDocletException
{
for (Iterator it = _curClassDef.getCollections(); it.hasNext(); )
{
_curCollectionDef = (CollectionDescriptorDef)it.next();
if (!isFeatureIgnored(LEVEL_COLLECTION) &&
!_curCollectionDef.getBooleanProperty(PropertyHelper.OJB_PROPERTY_IGNORE, false))
{
generate(template);
}
}
_curCollectionDef = null;
} | java | {
"resource": ""
} |
q9321 | OjbTagsHandler.processNested | train | public String processNested(Properties attributes) throws XDocletException
{
String name = OjbMemberTagsHandler.getMemberName();
XClass type = OjbMemberTagsHandler.getMemberType();
int dim = OjbMemberTagsHandler.getMemberDimension();
NestedDef nestedDef = _curClassDef.getNested(name);
if (type == null)
{
throw new XDocletException(Translator.getString(XDocletModulesOjbMessages.class,
XDocletModulesOjbMessages.COULD_NOT_DETERMINE_TYPE_OF_MEMBER,
new String[]{name}));
}
if (dim > 0)
{
throw new XDocletException(Translator.getString(XDocletModulesOjbMessages.class,
XDocletModulesOjbMessages.MEMBER_CANNOT_BE_NESTED,
new String[]{name, _curClassDef.getName()}));
}
ClassDescriptorDef nestedTypeDef = _model.getClass(type.getQualifiedName());
if (nestedTypeDef == null)
{
throw new XDocletException(Translator.getString(XDocletModulesOjbMessages.class,
XDocletModulesOjbMessages.COULD_NOT_DETERMINE_TYPE_OF_MEMBER,
new String[]{name}));
}
if (nestedDef == null)
{
nestedDef = new NestedDef(name, nestedTypeDef);
_curClassDef.addNested(nestedDef);
}
LogHelper.debug(false, OjbTagsHandler.class, "processNested", " Processing nested object "+nestedDef.getName()+" of type "+nestedTypeDef.getName());
String attrName;
for (Enumeration attrNames = attributes.propertyNames(); attrNames.hasMoreElements(); )
{
attrName = (String)attrNames.nextElement();
nestedDef.setProperty(attrName, attributes.getProperty(attrName));
}
return "";
} | java | {
"resource": ""
} |
q9322 | OjbTagsHandler.createTorqueSchema | train | public String createTorqueSchema(Properties attributes) throws XDocletException
{
String dbName = (String)getDocletContext().getConfigParam(CONFIG_PARAM_DATABASENAME);
_torqueModel = new TorqueModelDef(dbName, _model);
return "";
} | java | {
"resource": ""
} |
q9323 | OjbTagsHandler.forAllTables | train | public void forAllTables(String template, Properties attributes) throws XDocletException
{
for (Iterator it = _torqueModel.getTables(); it.hasNext(); )
{
_curTableDef = (TableDef)it.next();
generate(template);
}
_curTableDef = null;
} | java | {
"resource": ""
} |
q9324 | OjbTagsHandler.forAllColumns | train | public void forAllColumns(String template, Properties attributes) throws XDocletException
{
for (Iterator it = _curTableDef.getColumns(); it.hasNext(); )
{
_curColumnDef = (ColumnDef)it.next();
generate(template);
}
_curColumnDef = null;
} | java | {
"resource": ""
} |
q9325 | OjbTagsHandler.forAllForeignkeys | train | public void forAllForeignkeys(String template, Properties attributes) throws XDocletException
{
for (Iterator it = _curTableDef.getForeignkeys(); it.hasNext(); )
{
_curForeignkeyDef = (ForeignkeyDef)it.next();
generate(template);
}
_curForeignkeyDef = null;
} | java | {
"resource": ""
} |
q9326 | OjbTagsHandler.forAllForeignkeyColumnPairs | train | public void forAllForeignkeyColumnPairs(String template, Properties attributes) throws XDocletException
{
for (int idx = 0; idx < _curForeignkeyDef.getNumColumnPairs(); idx++)
{
_curPairLeft = _curForeignkeyDef.getLocalColumn(idx);
_curPairRight = _curForeignkeyDef.getRemoteColumn(idx);
generate(template);
}
_curPairLeft = null;
_curPairRight = null;
} | java | {
"resource": ""
} |
q9327 | OjbTagsHandler.forAllIndices | train | public void forAllIndices(String template, Properties attributes) throws XDocletException
{
boolean processUnique = TypeConversionUtil.stringToBoolean(attributes.getProperty(ATTRIBUTE_UNIQUE), false);
// first the default index
_curIndexDef = _curTableDef.getIndex(null);
if ((_curIndexDef != null) && (processUnique == _curIndexDef.isUnique()))
{
generate(template);
}
for (Iterator it = _curTableDef.getIndices(); it.hasNext(); )
{
_curIndexDef = (IndexDef)it.next();
if (!_curIndexDef.isDefault() && (processUnique == _curIndexDef.isUnique()))
{
generate(template);
}
}
_curIndexDef = null;
} | java | {
"resource": ""
} |
q9328 | OjbTagsHandler.forAllIndexColumns | train | public void forAllIndexColumns(String template, Properties attributes) throws XDocletException
{
for (Iterator it = _curIndexDef.getColumns(); it.hasNext(); )
{
_curColumnDef = _curTableDef.getColumn((String)it.next());
generate(template);
}
_curColumnDef = null;
} | java | {
"resource": ""
} |
q9329 | OjbTagsHandler.name | train | public String name(Properties attributes) throws XDocletException
{
return getDefForLevel(attributes.getProperty(ATTRIBUTE_LEVEL)).getName();
} | java | {
"resource": ""
} |
q9330 | OjbTagsHandler.ifHasName | train | public void ifHasName(String template, Properties attributes) throws XDocletException
{
String name = getDefForLevel(attributes.getProperty(ATTRIBUTE_LEVEL)).getName();
if ((name != null) && (name.length() > 0))
{
generate(template);
}
} | java | {
"resource": ""
} |
q9331 | OjbTagsHandler.ifHasProperty | train | public void ifHasProperty(String template, Properties attributes) throws XDocletException
{
String value = getPropertyValue(attributes.getProperty(ATTRIBUTE_LEVEL), attributes.getProperty(ATTRIBUTE_NAME));
if (value != null)
{
generate(template);
}
} | java | {
"resource": ""
} |
q9332 | OjbTagsHandler.propertyValue | train | public String propertyValue(Properties attributes) throws XDocletException
{
String value = getPropertyValue(attributes.getProperty(ATTRIBUTE_LEVEL), attributes.getProperty(ATTRIBUTE_NAME));
if (value == null)
{
value = attributes.getProperty(ATTRIBUTE_DEFAULT);
}
return value;
} | java | {
"resource": ""
} |
q9333 | OjbTagsHandler.ifPropertyValueEquals | train | public void ifPropertyValueEquals(String template, Properties attributes) throws XDocletException
{
String value = getPropertyValue(attributes.getProperty(ATTRIBUTE_LEVEL), attributes.getProperty(ATTRIBUTE_NAME));
String expected = attributes.getProperty(ATTRIBUTE_VALUE);
if (value == null)
{
value = attributes.getProperty(ATTRIBUTE_DEFAULT);
}
if (expected.equals(value))
{
generate(template);
}
} | java | {
"resource": ""
} |
q9334 | OjbTagsHandler.forAllValuePairs | train | public void forAllValuePairs(String template, Properties attributes) throws XDocletException
{
String name = attributes.getProperty(ATTRIBUTE_NAME, "attributes");
String defaultValue = attributes.getProperty(ATTRIBUTE_DEFAULT_RIGHT, "");
String attributePairs = getPropertyValue(attributes.getProperty(ATTRIBUTE_LEVEL), name);
if ((attributePairs == null) || (attributePairs.length() == 0))
{
return;
}
String token;
int pos;
for (CommaListIterator it = new CommaListIterator(attributePairs); it.hasNext();)
{
token = it.getNext();
pos = token.indexOf('=');
if (pos >= 0)
{
_curPairLeft = token.substring(0, pos);
_curPairRight = (pos < token.length() - 1 ? token.substring(pos + 1) : defaultValue);
}
else
{
_curPairLeft = token;
_curPairRight = defaultValue;
}
if (_curPairLeft.length() > 0)
{
generate(template);
}
}
_curPairLeft = null;
_curPairRight = null;
} | java | {
"resource": ""
} |
q9335 | OjbTagsHandler.ensureClassDef | train | private ClassDescriptorDef ensureClassDef(XClass original)
{
String name = original.getQualifiedName();
ClassDescriptorDef classDef = _model.getClass(name);
if (classDef == null)
{
classDef = new ClassDescriptorDef(original);
_model.addClass(classDef);
}
return classDef;
} | java | {
"resource": ""
} |
q9336 | OjbTagsHandler.addDirectSubTypes | train | private void addDirectSubTypes(XClass type, ArrayList subTypes)
{
if (type.isInterface())
{
if (type.getExtendingInterfaces() != null)
{
subTypes.addAll(type.getExtendingInterfaces());
}
// we have to traverse the implementing classes as these array contains all classes that
// implement the interface, not only those who have an "implement" declaration
// note that for whatever reason the declared interfaces are not exported via the XClass interface
// so we have to get them via the underlying class which is hopefully a subclass of AbstractClass
if (type.getImplementingClasses() != null)
{
Collection declaredInterfaces = null;
XClass subType;
for (Iterator it = type.getImplementingClasses().iterator(); it.hasNext(); )
{
subType = (XClass)it.next();
if (subType instanceof AbstractClass)
{
declaredInterfaces = ((AbstractClass)subType).getDeclaredInterfaces();
if ((declaredInterfaces != null) && declaredInterfaces.contains(type))
{
subTypes.add(subType);
}
}
else
{
// Otherwise we have to live with the bug
subTypes.add(subType);
}
}
}
}
else
{
subTypes.addAll(type.getDirectSubclasses());
}
} | java | {
"resource": ""
} |
q9337 | OjbTagsHandler.searchForPersistentSubType | train | private String searchForPersistentSubType(XClass type)
{
ArrayList queue = new ArrayList();
XClass subType;
queue.add(type);
while (!queue.isEmpty())
{
subType = (XClass)queue.get(0);
queue.remove(0);
if (_model.hasClass(subType.getQualifiedName()))
{
return subType.getQualifiedName();
}
addDirectSubTypes(subType, queue);
}
return null;
} | java | {
"resource": ""
} |
q9338 | OjbTagsHandler.getDefForLevel | train | private DefBase getDefForLevel(String level)
{
if (LEVEL_CLASS.equals(level))
{
return _curClassDef;
}
else if (LEVEL_FIELD.equals(level))
{
return _curFieldDef;
}
else if (LEVEL_REFERENCE.equals(level))
{
return _curReferenceDef;
}
else if (LEVEL_COLLECTION.equals(level))
{
return _curCollectionDef;
}
else if (LEVEL_OBJECT_CACHE.equals(level))
{
return _curObjectCacheDef;
}
else if (LEVEL_INDEX_DESC.equals(level))
{
return _curIndexDescriptorDef;
}
else if (LEVEL_TABLE.equals(level))
{
return _curTableDef;
}
else if (LEVEL_COLUMN.equals(level))
{
return _curColumnDef;
}
else if (LEVEL_FOREIGNKEY.equals(level))
{
return _curForeignkeyDef;
}
else if (LEVEL_INDEX.equals(level))
{
return _curIndexDef;
}
else if (LEVEL_PROCEDURE.equals(level))
{
return _curProcedureDef;
}
else if (LEVEL_PROCEDURE_ARGUMENT.equals(level))
{
return _curProcedureArgumentDef;
}
else
{
return null;
}
} | java | {
"resource": ""
} |
q9339 | OjbTagsHandler.getPropertyValue | train | private String getPropertyValue(String level, String name)
{
return getDefForLevel(level).getProperty(name);
} | java | {
"resource": ""
} |
q9340 | LogFileCompressionStrategy.compress | train | final void compress(final File backupFile,
final AppenderRollingProperties properties) {
if (this.isCompressed(backupFile)) {
LogLog.debug("Backup log file " + backupFile.getName()
+ " is already compressed");
return; // try not to do unnecessary work
}
final long lastModified = backupFile.lastModified();
if (0L == lastModified) {
LogLog.debug("Backup log file " + backupFile.getName()
+ " may have been scavenged");
return; // backup file may have been scavenged
}
final File deflatedFile = this.createDeflatedFile(backupFile);
if (deflatedFile == null) {
LogLog.debug("Backup log file " + backupFile.getName()
+ " may have been scavenged");
return; // an error occurred creating the file
}
if (this.compress(backupFile, deflatedFile, properties)) {
deflatedFile.setLastModified(lastModified);
FileHelper.getInstance().deleteExisting(backupFile);
LogLog.debug("Compressed backup log file to " + deflatedFile.getName());
} else {
FileHelper.getInstance().deleteExisting(deflatedFile); // clean up
LogLog
.debug("Unable to compress backup log file " + backupFile.getName());
}
} | java | {
"resource": ""
} |
q9341 | PersistenceBrokerFactory.createPersistenceBroker | train | public static PersistenceBroker createPersistenceBroker(String jcdAlias,
String user,
String password) throws PBFactoryException
{
return PersistenceBrokerFactoryFactory.instance().
createPersistenceBroker(jcdAlias, user, password);
} | java | {
"resource": ""
} |
q9342 | MediatorConfig.setRegistrationConfig | train | public void setRegistrationConfig(RegistrationConfig registrationConfig) {
this.registrationConfig = registrationConfig;
if (registrationConfig.getDefaultConfig()!=null) {
for (String key : registrationConfig.getDefaultConfig().keySet()) {
dynamicConfig.put(key, registrationConfig.getDefaultConfig().get(key));
}
}
} | java | {
"resource": ""
} |
q9343 | RepositoryXmlHandler.characters | train | public void characters(char ch[], int start, int length)
{
if (m_CurrentString == null)
m_CurrentString = new String(ch, start, length);
else
m_CurrentString += new String(ch, start, length);
} | java | {
"resource": ""
} |
q9344 | RsIterator.hasNext | train | public synchronized boolean hasNext()
{
try
{
if (!isHasCalledCheck())
{
setHasCalledCheck(true);
setHasNext(getRsAndStmt().m_rs.next());
if (!getHasNext())
{
autoReleaseDbResources();
}
}
}
catch (Exception ex)
{
setHasNext(false);
autoReleaseDbResources();
if(ex instanceof ResourceClosedException)
{
throw (ResourceClosedException)ex;
}
if(ex instanceof SQLException)
{
throw new PersistenceBrokerSQLException("Calling ResultSet.next() failed", (SQLException) ex);
}
else
{
throw new PersistenceBrokerException("Can't get next row from ResultSet", ex);
}
}
if (logger.isDebugEnabled())
logger.debug("hasNext() -> " + getHasNext());
return getHasNext();
} | java | {
"resource": ""
} |
q9345 | RsIterator.next | train | public synchronized Object next() throws NoSuchElementException
{
try
{
if (!isHasCalledCheck())
{
hasNext();
}
setHasCalledCheck(false);
if (getHasNext())
{
Object obj = getObjectFromResultSet();
m_current_row++;
// Invoke events on PersistenceBrokerAware instances and listeners
// set target object
if (!disableLifeCycleEvents)
{
getAfterLookupEvent().setTarget(obj);
getBroker().fireBrokerEvent(getAfterLookupEvent());
getAfterLookupEvent().setTarget(null);
}
return obj;
}
else
{
throw new NoSuchElementException("inner hasNext was false");
}
}
catch (ResourceClosedException ex)
{
autoReleaseDbResources();
throw ex;
}
catch (NoSuchElementException ex)
{
autoReleaseDbResources();
logger.error("Error while iterate ResultSet for query " + m_queryObject, ex);
throw new NoSuchElementException("Could not obtain next object: " + ex.getMessage());
}
} | java | {
"resource": ""
} |
q9346 | RsIterator.getOwnerObjects | train | private Collection getOwnerObjects()
{
Collection owners = new Vector();
while (hasNext())
{
owners.add(next());
}
return owners;
} | java | {
"resource": ""
} |
q9347 | RsIterator.prefetchRelationships | train | private void prefetchRelationships(Query query)
{
List prefetchedRel;
Collection owners;
String relName;
RelationshipPrefetcher[] prefetchers;
if (query == null || query.getPrefetchedRelationships() == null || query.getPrefetchedRelationships().isEmpty())
{
return;
}
if (!supportsAdvancedJDBCCursorControl())
{
logger.info("prefetching relationships requires JDBC level 2.0");
return;
}
// prevent releasing of DBResources
setInBatchedMode(true);
prefetchedRel = query.getPrefetchedRelationships();
prefetchers = new RelationshipPrefetcher[prefetchedRel.size()];
// disable auto retrieve for all prefetched relationships
for (int i = 0; i < prefetchedRel.size(); i++)
{
relName = (String) prefetchedRel.get(i);
prefetchers[i] = getBroker().getRelationshipPrefetcherFactory()
.createRelationshipPrefetcher(getQueryObject().getClassDescriptor(), relName);
prefetchers[i].prepareRelationshipSettings();
}
// materialize ALL owners of this Iterator
owners = getOwnerObjects();
// prefetch relationships and associate with owners
for (int i = 0; i < prefetchedRel.size(); i++)
{
prefetchers[i].prefetchRelationship(owners);
}
// reset auto retrieve for all prefetched relationships
for (int i = 0; i < prefetchedRel.size(); i++)
{
prefetchers[i].restoreRelationshipSettings();
}
try
{
getRsAndStmt().m_rs.beforeFirst(); // reposition resultset jdbc 2.0
}
catch (SQLException e)
{
logger.error("beforeFirst failed !", e);
}
setInBatchedMode(false);
setHasCalledCheck(false);
} | java | {
"resource": ""
} |
q9348 | RsIterator.getProxyFromResultSet | train | protected Object getProxyFromResultSet() throws PersistenceBrokerException
{
// 1. get Identity of current row:
Identity oid = getIdentityFromResultSet();
// 2. return a Proxy instance:
return getBroker().createProxy(getItemProxyClass(), oid);
} | java | {
"resource": ""
} |
q9349 | RsIterator.countedSize | train | protected int countedSize() throws PersistenceBrokerException
{
Query countQuery = getBroker().serviceBrokerHelper().getCountQuery(getQueryObject().getQuery());
ResultSetAndStatement rsStmt;
ClassDescriptor cld = getQueryObject().getClassDescriptor();
int count = 0;
// BRJ: do not use broker.getCount() because it's extent-aware
// the count we need here must not include extents !
if (countQuery instanceof QueryBySQL)
{
String countSql = ((QueryBySQL) countQuery).getSql();
rsStmt = getBroker().serviceJdbcAccess().executeSQL(countSql, cld, Query.NOT_SCROLLABLE);
}
else
{
rsStmt = getBroker().serviceJdbcAccess().executeQuery(countQuery, cld);
}
try
{
if (rsStmt.m_rs.next())
{
count = rsStmt.m_rs.getInt(1);
}
}
catch (SQLException e)
{
throw new PersistenceBrokerException(e);
}
finally
{
rsStmt.close();
}
return count;
} | java | {
"resource": ""
} |
q9350 | RsIterator.absolute | train | public boolean absolute(int row) throws PersistenceBrokerException
{
boolean retval;
if (supportsAdvancedJDBCCursorControl())
{
retval = absoluteAdvanced(row);
}
else
{
retval = absoluteBasic(row);
}
return retval;
} | java | {
"resource": ""
} |
q9351 | RsIterator.absoluteBasic | train | private boolean absoluteBasic(int row)
{
boolean retval = false;
if (row > m_current_row)
{
try
{
while (m_current_row < row && getRsAndStmt().m_rs.next())
{
m_current_row++;
}
if (m_current_row == row)
{
retval = true;
}
else
{
setHasCalledCheck(true);
setHasNext(false);
retval = false;
autoReleaseDbResources();
}
}
catch (Exception ex)
{
setHasCalledCheck(true);
setHasNext(false);
retval = false;
}
}
else
{
logger.info("Your driver does not support advanced JDBC Functionality, " +
"you cannot call absolute() with a position < current");
}
return retval;
} | java | {
"resource": ""
} |
q9352 | RsIterator.absoluteAdvanced | train | private boolean absoluteAdvanced(int row)
{
boolean retval = false;
try
{
if (getRsAndStmt().m_rs != null)
{
if (row == 0)
{
getRsAndStmt().m_rs.beforeFirst();
}
else
{
retval = getRsAndStmt().m_rs.absolute(row);
}
m_current_row = row;
setHasCalledCheck(false);
}
}
catch (SQLException e)
{
advancedJDBCSupport = false;
}
return retval;
} | java | {
"resource": ""
} |
q9353 | CommonsLoggerImpl.safeToString | train | private String safeToString(Object obj)
{
String toString = null;
if (obj != null)
{
try
{
toString = obj.toString();
}
catch (Throwable ex)
{
toString = "BAD toString() impl for " + obj.getClass().getName();
}
}
return toString;
} | java | {
"resource": ""
} |
q9354 | ClassDescriptor.setRowReader | train | public void setRowReader(String newReaderClassName)
{
try
{
m_rowReader =
(RowReader) ClassHelper.newInstance(
newReaderClassName,
ClassDescriptor.class,
this);
}
catch (Exception e)
{
throw new MetadataException("Instantiating of current set RowReader failed", e);
}
} | java | {
"resource": ""
} |
q9355 | ClassDescriptor.setClassOfObject | train | public void setClassOfObject(Class c)
{
m_Class = c;
isAbstract = Modifier.isAbstract(m_Class.getModifiers());
// TODO : Shouldn't the HashMap in DescriptorRepository be updated as well?
} | java | {
"resource": ""
} |
q9356 | ClassDescriptor.addFieldDescriptor | train | public void addFieldDescriptor(FieldDescriptor fld)
{
fld.setClassDescriptor(this); // BRJ
if (m_FieldDescriptions == null)
{
m_FieldDescriptions = new FieldDescriptor[1];
m_FieldDescriptions[0] = fld;
}
else
{
int size = m_FieldDescriptions.length;
FieldDescriptor[] tmpArray = new FieldDescriptor[size + 1];
System.arraycopy(m_FieldDescriptions, 0, tmpArray, 0, size);
tmpArray[size] = fld;
m_FieldDescriptions = tmpArray;
// 2. Sort fields according to their getOrder() Property
Arrays.sort(m_FieldDescriptions, FieldDescriptor.getComparator());
}
m_fieldDescriptorNameMap = null;
m_PkFieldDescriptors = null;
m_nonPkFieldDescriptors = null;
m_lockingFieldDescriptors = null;
m_RwFieldDescriptors = null;
m_RwNonPkFieldDescriptors = null;
} | java | {
"resource": ""
} |
q9357 | ClassDescriptor.getObjectReferenceDescriptorByName | train | public ObjectReferenceDescriptor getObjectReferenceDescriptorByName(String name)
{
ObjectReferenceDescriptor ord = (ObjectReferenceDescriptor)
getObjectReferenceDescriptorsNameMap().get(name);
//
// BRJ: if the ReferenceDescriptor is not found
// look in the ClassDescriptor referenced by 'super' for it
//
if (ord == null)
{
ClassDescriptor superCld = getSuperClassDescriptor();
if (superCld != null)
{
ord = superCld.getObjectReferenceDescriptorByName(name);
}
}
return ord;
} | java | {
"resource": ""
} |
q9358 | ClassDescriptor.getCollectionDescriptorByName | train | public CollectionDescriptor getCollectionDescriptorByName(String name)
{
if (name == null)
{
return null;
}
CollectionDescriptor cod = (CollectionDescriptor) getCollectionDescriptorNameMap().get(name);
//
// BRJ: if the CollectionDescriptor is not found
// look in the ClassDescriptor referenced by 'super' for it
//
if (cod == null)
{
ClassDescriptor superCld = getSuperClassDescriptor();
if (superCld != null)
{
cod = superCld.getCollectionDescriptorByName(name);
}
}
return cod;
} | java | {
"resource": ""
} |
q9359 | ClassDescriptor.getSuperClassDescriptor | train | public ClassDescriptor getSuperClassDescriptor()
{
if (!m_superCldSet)
{
if(getBaseClass() != null)
{
m_superCld = getRepository().getDescriptorFor(getBaseClass());
if(m_superCld.isAbstract() || m_superCld.isInterface())
{
throw new MetadataException("Super class mapping only work for real class, but declared super class" +
" is an interface or is abstract. Declared class: " + m_superCld.getClassNameOfObject());
}
}
m_superCldSet = true;
}
return m_superCld;
} | java | {
"resource": ""
} |
q9360 | ClassDescriptor.addExtentClass | train | public void addExtentClass(String newExtentClassName)
{
extentClassNames.add(newExtentClassName);
if(m_repository != null) m_repository.addExtent(newExtentClassName, this);
} | java | {
"resource": ""
} |
q9361 | ClassDescriptor.setProxyClass | train | public void setProxyClass(Class newProxyClass)
{
proxyClass = newProxyClass;
if (proxyClass == null)
{
setProxyClassName(null);
}
else
{
proxyClassName = proxyClass.getName();
}
} | java | {
"resource": ""
} |
q9362 | ClassDescriptor.getAutoIncrementField | train | public FieldDescriptor getAutoIncrementField()
{
if (m_autoIncrementField == null)
{
FieldDescriptor[] fds = getPkFields();
for (int i = 0; i < fds.length; i++)
{
FieldDescriptor fd = fds[i];
if (fd.isAutoIncrement())
{
m_autoIncrementField = fd;
break;
}
}
}
if (m_autoIncrementField == null)
{
LoggerFactory.getDefaultLogger().warn(
this.getClass().getName()
+ ": "
+ "Could not find autoincrement attribute for class: "
+ this.getClassNameOfObject());
}
return m_autoIncrementField;
} | java | {
"resource": ""
} |
q9363 | ClassDescriptor.getCurrentLockingValues | train | public ValueContainer[] getCurrentLockingValues(Object o) throws PersistenceBrokerException
{
FieldDescriptor[] fields = getLockingFields();
ValueContainer[] result = new ValueContainer[fields.length];
for (int i = 0; i < result.length; i++)
{
result[i] = new ValueContainer(fields[i].getPersistentField().get(o), fields[i].getJdbcType());
}
return result;
} | java | {
"resource": ""
} |
q9364 | ClassDescriptor.updateLockingValues | train | public void updateLockingValues(Object obj) throws PersistenceBrokerException
{
FieldDescriptor[] fields = getLockingFields();
for (int i = 0; i < fields.length; i++)
{
FieldDescriptor fmd = fields[i];
if (fmd.isUpdateLock())
{
PersistentField f = fmd.getPersistentField();
Object cv = f.get(obj);
// int
if ((f.getType() == int.class) || (f.getType() == Integer.class))
{
int newCv = 0;
if (cv != null)
{
newCv = ((Number) cv).intValue();
}
newCv++;
f.set(obj, new Integer(newCv));
}
// long
else if ((f.getType() == long.class) || (f.getType() == Long.class))
{
long newCv = 0;
if (cv != null)
{
newCv = ((Number) cv).longValue();
}
newCv++;
f.set(obj, new Long(newCv));
}
// Timestamp
else if (f.getType() == Timestamp.class)
{
long newCv = System.currentTimeMillis();
f.set(obj, new Timestamp(newCv));
}
}
}
} | java | {
"resource": ""
} |
q9365 | ClassDescriptor.getZeroArgumentConstructor | train | public Constructor getZeroArgumentConstructor()
{
if (zeroArgumentConstructor == null && !alreadyLookedupZeroArguments)
{
try
{
zeroArgumentConstructor = getClassOfObject().getConstructor(NO_PARAMS);
}
catch (NoSuchMethodException e)
{
//no public zero argument constructor available let's try for a private/protected one
try
{
zeroArgumentConstructor = getClassOfObject().getDeclaredConstructor(NO_PARAMS);
//we found one, now let's make it accessible
zeroArgumentConstructor.setAccessible(true);
}
catch (NoSuchMethodException e2)
{
//out of options, log the fact and let the method return null
LoggerFactory.getDefaultLogger().warn(
this.getClass().getName()
+ ": "
+ "No zero argument constructor defined for "
+ this.getClassOfObject());
}
}
alreadyLookedupZeroArguments = true;
}
return zeroArgumentConstructor;
} | java | {
"resource": ""
} |
q9366 | ClassDescriptor.setInitializationMethod | train | private synchronized void setInitializationMethod(Method newMethod)
{
if (newMethod != null)
{
// make sure it's a no argument method
if (newMethod.getParameterTypes().length > 0)
{
throw new MetadataException(
"Initialization methods must be zero argument methods: "
+ newMethod.getClass().getName()
+ "."
+ newMethod.getName());
}
// make it accessible if it's not already
if (!newMethod.isAccessible())
{
newMethod.setAccessible(true);
}
}
this.initializationMethod = newMethod;
} | java | {
"resource": ""
} |
q9367 | ClassDescriptor.setFactoryMethod | train | private synchronized void setFactoryMethod(Method newMethod)
{
if (newMethod != null)
{
// make sure it's a no argument method
if (newMethod.getParameterTypes().length > 0)
{
throw new MetadataException(
"Factory methods must be zero argument methods: "
+ newMethod.getClass().getName()
+ "."
+ newMethod.getName());
}
// make it accessible if it's not already
if (!newMethod.isAccessible())
{
newMethod.setAccessible(true);
}
}
this.factoryMethod = newMethod;
} | java | {
"resource": ""
} |
q9368 | FoundationLoggingPatternLayout.createPatternParser | train | protected org.apache.log4j.helpers.PatternParser createPatternParser(final String pattern) {
return new FoundationLoggingPatternParser(pattern);
} | java | {
"resource": ""
} |
q9369 | FoundationLoggingPatternLayout.format | train | public String format(final LoggingEvent event) {
final StringBuffer buf = new StringBuffer();
for (PatternConverter c = head; c != null; c = c.next) {
c.format(buf, event);
}
return buf.toString();
} | java | {
"resource": ""
} |
q9370 | SequenceManagerMSSQLGuidImpl.getUniqueString | train | protected String getUniqueString(FieldDescriptor field) throws SequenceManagerException
{
ResultSetAndStatement rsStmt = null;
String returnValue = null;
try
{
rsStmt = getBrokerForClass().serviceJdbcAccess().executeSQL(
"select newid()", field.getClassDescriptor(), Query.NOT_SCROLLABLE);
if (rsStmt.m_rs.next())
{
returnValue = rsStmt.m_rs.getString(1);
}
else
{
LoggerFactory.getDefaultLogger().error(this.getClass()
+ ": Can't lookup new oid for field " + field);
}
}
catch (PersistenceBrokerException e)
{
throw new SequenceManagerException(e);
}
catch (SQLException e)
{
throw new SequenceManagerException(e);
}
finally
{
// close the used resources
if (rsStmt != null) rsStmt.close();
}
return returnValue;
} | java | {
"resource": ""
} |
q9371 | JdbcTypesHelper.getObjectFromColumn | train | public static Object getObjectFromColumn(ResultSet rs, Integer jdbcType, int columnId)
throws SQLException
{
return getObjectFromColumn(rs, null, jdbcType, null, columnId);
} | java | {
"resource": ""
} |
q9372 | OjbMetadataTransferable.getTransferData | train | public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, java.io.IOException
{
if (flavor.isMimeTypeEqual(OJBMETADATA_FLAVOR))
return selectedDescriptors;
else
throw new UnsupportedFlavorException(flavor);
} | java | {
"resource": ""
} |
q9373 | OjbConfiguration.load | train | protected void load()
{
// properties file may be set as a System property.
// if no property is set take default name.
String fn = System.getProperty(OJB_PROPERTIES_FILE, OJB_PROPERTIES_FILE);
setFilename(fn);
super.load();
// default repository & connection descriptor file
repositoryFilename = getString("repositoryFile", OJB_METADATA_FILE);
// object cache class
objectCacheClass = getClass("ObjectCacheClass", ObjectCacheDefaultImpl.class, ObjectCache.class);
// load PersistentField Class
persistentFieldClass =
getClass("PersistentFieldClass", PersistentFieldDirectImpl.class, PersistentField.class);
// load PersistenceBroker Class
persistenceBrokerClass =
getClass("PersistenceBrokerClass", PersistenceBrokerImpl.class, PersistenceBroker.class);
// load ListProxy Class
listProxyClass = getClass("ListProxyClass", ListProxyDefaultImpl.class);
// load SetProxy Class
setProxyClass = getClass("SetProxyClass", SetProxyDefaultImpl.class);
// load CollectionProxy Class
collectionProxyClass = getClass("CollectionProxyClass", CollectionProxyDefaultImpl.class);
// load IndirectionHandler Class
indirectionHandlerClass =
getClass("IndirectionHandlerClass", IndirectionHandlerJDKImpl.class, IndirectionHandler.class);
// load ProxyFactory Class
proxyFactoryClass =
getClass("ProxyFactoryClass", ProxyFactoryJDKImpl.class, ProxyFactory.class);
// load configuration for ImplicitLocking parameter:
useImplicitLocking = getBoolean("ImplicitLocking", false);
// load configuration for LockAssociations parameter:
lockAssociationAsWrites = (getString("LockAssociations", "WRITE").equalsIgnoreCase("WRITE"));
// load OQL Collection Class
oqlCollectionClass = getClass("OqlCollectionClass", DListImpl.class, ManageableCollection.class);
// set the limit for IN-sql , -1 for no limits
sqlInLimit = getInteger("SqlInLimit", -1);
//load configuration for PB pool
maxActive = getInteger(PoolConfiguration.MAX_ACTIVE,
PoolConfiguration.DEFAULT_MAX_ACTIVE);
maxIdle = getInteger(PoolConfiguration.MAX_IDLE,
PoolConfiguration.DEFAULT_MAX_IDLE);
maxWait = getLong(PoolConfiguration.MAX_WAIT,
PoolConfiguration.DEFAULT_MAX_WAIT);
timeBetweenEvictionRunsMillis = getLong(PoolConfiguration.TIME_BETWEEN_EVICTION_RUNS_MILLIS,
PoolConfiguration.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS);
minEvictableIdleTimeMillis = getLong(PoolConfiguration.MIN_EVICTABLE_IDLE_TIME_MILLIS,
PoolConfiguration.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS);
whenExhaustedAction = getByte(PoolConfiguration.WHEN_EXHAUSTED_ACTION,
PoolConfiguration.DEFAULT_WHEN_EXHAUSTED_ACTION);
useSerializedRepository = getBoolean("useSerializedRepository", false);
} | java | {
"resource": ""
} |
q9374 | RemoteLockMapImpl.getReaders | train | public Collection getReaders(Object obj)
{
Collection result = null;
try
{
Identity oid = new Identity(obj, getBroker());
byte selector = (byte) 'r';
byte[] requestBarr = buildRequestArray(oid, selector);
HttpURLConnection conn = getHttpUrlConnection();
//post request
BufferedOutputStream out = new BufferedOutputStream(conn.getOutputStream());
out.write(requestBarr,0,requestBarr.length);
out.flush();
// read result from
InputStream in = conn.getInputStream();
ObjectInputStream ois = new ObjectInputStream(in);
result = (Collection) ois.readObject();
// cleanup
ois.close();
out.close();
conn.disconnect();
}
catch (Throwable t)
{
throw new PersistenceBrokerException(t);
}
return result;
} | java | {
"resource": ""
} |
q9375 | ForeignkeyDef.addColumnPair | train | public void addColumnPair(String localColumn, String remoteColumn)
{
if (!_localColumns.contains(localColumn))
{
_localColumns.add(localColumn);
}
if (!_remoteColumns.contains(remoteColumn))
{
_remoteColumns.add(remoteColumn);
}
} | java | {
"resource": ""
} |
q9376 | ColumnWithIdComparator.compare | train | public int compare(Object objA, Object objB)
{
String idAStr = _table.getColumn((String)objA).getProperty("id");
String idBStr = _table.getColumn((String)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": ""
} |
q9377 | UserAlias.getAlias | train | public String getAlias(String path)
{
if (m_allPathsAliased && m_attributePath.lastIndexOf(path) != -1)
{
return m_name;
}
Object retObj = m_mapping.get(path);
if (retObj != null)
{
return (String) retObj;
}
return null;
} | java | {
"resource": ""
} |
q9378 | ModelDef.addClass | train | public void addClass(ClassDescriptorDef classDef)
{
classDef.setOwner(this);
// Regardless of the format of the class name, we're using the fully qualified format
// This is safe because of the package & class naming constraints of the Java language
_classDefs.put(classDef.getQualifiedName(), classDef);
} | java | {
"resource": ""
} |
q9379 | ModelDef.checkConstraints | train | public void checkConstraints(String checkLevel) throws ConstraintException
{
// check constraints now after all classes have been processed
for (Iterator it = getClasses(); it.hasNext();)
{
((ClassDescriptorDef)it.next()).checkConstraints(checkLevel);
}
// additional model constraints that either deal with bigger parts of the model or
// can only be checked after the individual classes have been checked (e.g. specific
// attributes have been ensured)
new ModelConstraints().check(this, checkLevel);
} | java | {
"resource": ""
} |
q9380 | MediatorHTTPResponse.toFinishRequest | train | public FinishRequest toFinishRequest(boolean includeHeaders) {
if (includeHeaders) {
return new FinishRequest(body, copyHeaders(headers), statusCode);
} else {
String mime = null;
if (body!=null) {
mime = "text/plain";
if (headers!=null && (headers.containsKey("Content-Type") || headers.containsKey("content-type"))) {
mime = headers.get("Content-Type");
if (mime==null) {
mime = headers.get("content-type");
}
}
}
return new FinishRequest(body, mime, statusCode);
}
} | java | {
"resource": ""
} |
q9381 | AttributeService.setAttributeEditable | train | public void setAttributeEditable(Attribute attribute, boolean editable) {
attribute.setEditable(editable);
if (!(attribute instanceof LazyAttribute)) { // should not instantiate lazy attributes!
if (attribute instanceof ManyToOneAttribute) {
setAttributeEditable(((ManyToOneAttribute) attribute).getValue(), editable);
} else if (attribute instanceof OneToManyAttribute) {
List<AssociationValue> values = ((OneToManyAttribute) attribute).getValue();
for (AssociationValue value : values) {
setAttributeEditable(value, editable);
}
}
}
} | java | {
"resource": ""
} |
q9382 | RepositoryMockAgent.increaseBeliefCount | train | private void increaseBeliefCount(String bName) {
Object belief = this.getBelief(bName);
int count = 0;
if (belief!=null) {
count = (Integer) belief;
}
this.setBelief(bName, count + 1);
} | java | {
"resource": ""
} |
q9383 | RepositoryMockAgent.setBelief | train | private void setBelief(String bName, Object value) {
introspector.setBeliefValue(this.getLocalName(), bName, value, null);
} | java | {
"resource": ""
} |
q9384 | DataModelFactory.createOrganization | train | public static Organization createOrganization(final String name){
final Organization organization = new Organization();
organization.setName(name);
return organization;
} | java | {
"resource": ""
} |
q9385 | DataModelFactory.createModule | train | public static Module createModule(final String name,final String version){
final Module module = new Module();
module.setName(name);
module.setVersion(version);
module.setPromoted(false);
return module;
} | java | {
"resource": ""
} |
q9386 | DataModelFactory.createArtifact | train | public static Artifact createArtifact(final String groupId, final String artifactId, final String version, final String classifier, final String type, final String extension, final String origin){
final Artifact artifact = new Artifact();
artifact.setGroupId(groupId);
artifact.setArtifactId(artifactId);
artifact.setVersion(version);
if(classifier != null){
artifact.setClassifier(classifier);
}
if(type != null){
artifact.setType(type);
}
if(extension != null){
artifact.setExtension(extension);
}
artifact.setOrigin(origin == null ? "maven" : origin);
return artifact;
} | java | {
"resource": ""
} |
q9387 | DataModelFactory.createLicense | train | public static License createLicense(final String name, final String longName, final String comments, final String regexp, final String url){
final License license = new License();
license.setName(name);
license.setLongName(longName);
license.setComments(comments);
license.setRegexp(regexp);
license.setUrl(url);
return license;
} | java | {
"resource": ""
} |
q9388 | DataModelFactory.createComment | train | public static Comment createComment(final String entityId,
final String entityType,
final String action,
final String commentedText,
final String user,
final Date date) {
final Comment comment = new Comment();
comment.setEntityId(entityId);
comment.setEntityType(entityType);
comment.setAction(action);
comment.setCommentText(commentedText);
comment.setCommentedBy(user);
comment.setCreatedDateTime(date);
return comment;
} | java | {
"resource": ""
} |
q9389 | ObjectEnvelopeTable.writeAllEnvelopes | train | private void writeAllEnvelopes(boolean reuse)
{
// perform remove of m:n indirection table entries first
performM2NUnlinkEntries();
Iterator iter;
// using clone to avoid ConcurentModificationException
iter = ((List) mvOrderOfIds.clone()).iterator();
while(iter.hasNext())
{
ObjectEnvelope mod = (ObjectEnvelope) mhtObjectEnvelopes.get(iter.next());
boolean insert = false;
if(needsCommit)
{
insert = mod.needsInsert();
mod.getModificationState().commit(mod);
if(reuse && insert)
{
getTransaction().doSingleLock(mod.getClassDescriptor(), mod.getObject(), mod.getIdentity(), Transaction.WRITE);
}
}
/*
arminw: important to call this cleanup method for each registered
ObjectEnvelope, because this method will e.g. remove proxy listener
objects for registered objects.
*/
mod.cleanup(reuse, insert);
}
// add m:n indirection table entries
performM2NLinkEntries();
} | java | {
"resource": ""
} |
q9390 | ObjectEnvelopeTable.checkAllEnvelopes | train | private void checkAllEnvelopes(PersistenceBroker broker)
{
Iterator iter = ((List) mvOrderOfIds.clone()).iterator();
while(iter.hasNext())
{
ObjectEnvelope mod = (ObjectEnvelope) mhtObjectEnvelopes.get(iter.next());
// only non transient objects should be performed
if(!mod.getModificationState().isTransient())
{
mod.markReferenceElements(broker);
}
}
} | java | {
"resource": ""
} |
q9391 | ObjectEnvelopeTable.rollback | train | public void rollback()
{
try
{
Iterator iter = mvOrderOfIds.iterator();
while(iter.hasNext())
{
ObjectEnvelope mod = (ObjectEnvelope) mhtObjectEnvelopes.get(iter.next());
if(log.isDebugEnabled())
log.debug("rollback: " + mod);
// if the Object has been modified by transaction, mark object as dirty
if(mod.hasChanged(transaction.getBroker()))
{
mod.setModificationState(mod.getModificationState().markDirty());
}
mod.getModificationState().rollback(mod);
}
}
finally
{
needsCommit = false;
}
afterWriteCleanup();
} | java | {
"resource": ""
} |
q9392 | ObjectEnvelopeTable.remove | train | public void remove(Object pKey)
{
Identity id;
if(pKey instanceof Identity)
{
id = (Identity) pKey;
}
else
{
id = transaction.getBroker().serviceIdentity().buildIdentity(pKey);
}
mhtObjectEnvelopes.remove(id);
mvOrderOfIds.remove(id);
} | java | {
"resource": ""
} |
q9393 | ObjectEnvelopeTable.reorder | train | private void reorder()
{
if(getTransaction().isOrdering() && needsCommit && mhtObjectEnvelopes.size() > 1)
{
ObjectEnvelopeOrdering ordering = new ObjectEnvelopeOrdering(mvOrderOfIds, mhtObjectEnvelopes);
ordering.reorder();
Identity[] newOrder = ordering.getOrdering();
mvOrderOfIds.clear();
for(int i = 0; i < newOrder.length; i++)
{
mvOrderOfIds.add(newOrder[i]);
}
}
} | java | {
"resource": ""
} |
q9394 | ObjectEnvelopeTable.cascadeMarkedForInsert | train | private void cascadeMarkedForInsert()
{
// This list was used to avoid endless recursion on circular references
List alreadyPrepared = new ArrayList();
for(int i = 0; i < markedForInsertList.size(); i++)
{
ObjectEnvelope mod = (ObjectEnvelope) markedForInsertList.get(i);
// only if a new object was found we cascade to register the dependent objects
if(mod.needsInsert())
{
cascadeInsertFor(mod, alreadyPrepared);
alreadyPrepared.clear();
}
}
markedForInsertList.clear();
} | java | {
"resource": ""
} |
q9395 | ObjectEnvelopeTable.cascadeInsertFor | train | private void cascadeInsertFor(ObjectEnvelope mod, List alreadyPrepared)
{
// avoid endless recursion, so use List for registration
if(alreadyPrepared.contains(mod.getIdentity())) return;
alreadyPrepared.add(mod.getIdentity());
ClassDescriptor cld = getTransaction().getBroker().getClassDescriptor(mod.getObject().getClass());
List refs = cld.getObjectReferenceDescriptors(true);
cascadeInsertSingleReferences(mod, refs, alreadyPrepared);
List colls = cld.getCollectionDescriptors(true);
cascadeInsertCollectionReferences(mod, colls, alreadyPrepared);
} | java | {
"resource": ""
} |
q9396 | ObjectEnvelopeTable.cascadeMarkedForDeletion | train | private void cascadeMarkedForDeletion()
{
List alreadyPrepared = new ArrayList();
for(int i = 0; i < markedForDeletionList.size(); i++)
{
ObjectEnvelope mod = (ObjectEnvelope) markedForDeletionList.get(i);
// if the object wasn't associated with another object, start cascade delete
if(!isNewAssociatedObject(mod.getIdentity()))
{
cascadeDeleteFor(mod, alreadyPrepared);
alreadyPrepared.clear();
}
}
markedForDeletionList.clear();
} | java | {
"resource": ""
} |
q9397 | ObjectEnvelopeTable.cascadeDeleteFor | train | private void cascadeDeleteFor(ObjectEnvelope mod, List alreadyPrepared)
{
// avoid endless recursion
if(alreadyPrepared.contains(mod.getIdentity())) return;
alreadyPrepared.add(mod.getIdentity());
ClassDescriptor cld = getTransaction().getBroker().getClassDescriptor(mod.getObject().getClass());
List refs = cld.getObjectReferenceDescriptors(true);
cascadeDeleteSingleReferences(mod, refs, alreadyPrepared);
List colls = cld.getCollectionDescriptors(true);
cascadeDeleteCollectionReferences(mod, colls, alreadyPrepared);
} | java | {
"resource": ""
} |
q9398 | QueryReferenceBroker.getCollectionByQuery | train | public ManageableCollection getCollectionByQuery(Class collectionClass, Query query, boolean lazy) throws PersistenceBrokerException
{
ManageableCollection result;
try
{
// BRJ: return empty Collection for null query
if (query == null)
{
result = (ManageableCollection)collectionClass.newInstance();
}
else
{
if (lazy)
{
result = pb.getProxyFactory().createCollectionProxy(pb.getPBKey(), query, collectionClass);
}
else
{
result = getCollectionByQuery(collectionClass, query.getSearchClass(), query);
}
}
return result;
}
catch (Exception e)
{
if(e instanceof PersistenceBrokerException)
{
throw (PersistenceBrokerException) e;
}
else
{
throw new PersistenceBrokerException(e);
}
}
} | java | {
"resource": ""
} |
q9399 | QueryReferenceBroker.retrieveReferences | train | public void retrieveReferences(Object newObj, ClassDescriptor cld, boolean forced) throws PersistenceBrokerException
{
Iterator i = cld.getObjectReferenceDescriptors().iterator();
// turn off auto prefetching for related proxies
final Class saveClassToPrefetch = classToPrefetch;
classToPrefetch = null;
pb.getInternalCache().enableMaterializationCache();
try
{
while (i.hasNext())
{
ObjectReferenceDescriptor rds = (ObjectReferenceDescriptor) i.next();
retrieveReference(newObj, cld, rds, forced);
}
pb.getInternalCache().disableMaterializationCache();
}
catch(RuntimeException e)
{
pb.getInternalCache().doLocalClear();
throw e;
}
finally
{
classToPrefetch = saveClassToPrefetch;
}
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.