code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
private void nugetPackCommand() throws MojoExecutionException {
List<String> commandList = new LinkedList<String>();
commandList.add(0, NUGET_COMMAND);
commandList.add(1, "pack");
String[] command = commandList.toArray(new String[commandList.size()]);
ProcessBuilder builder = new ProcessBuilder();
builder.redirectErrorStream(true);
builder.directory(new File(nugetFolder));
builder.command(command);
try {
executeACommand(builder.start());
} catch (InterruptedException | IOException e) {
throw new MojoExecutionException("Error, while executing command: "
+ Arrays.toString(command) + "\n", e);
}
} | java |
public IndexCommitBuilder insert(Object object) {
updateModelClassSet(object);
getInsertList(object.getClass()).add((OpenEngSBModel) object);
return this;
} | java |
public IndexCommitBuilder update(Object object) {
updateModelClassSet(object);
getUpdateList(object.getClass()).add((OpenEngSBModel) object);
return this;
} | java |
public IndexCommitBuilder delete(Object object) {
updateModelClassSet(object);
getDeleteList(object.getClass()).add((OpenEngSBModel) object);
return this;
} | java |
private void checkNeededValues(TransformationDescription description) {
String message = "The TransformationDescription doesn't contain a %s. Description loading aborted";
if (description.getSourceModel().getModelClassName() == null) {
throw new IllegalArgumentException(String.format(message, "source class"));
}
if (description.getTargetModel().getModelClassName() == null) {
throw new IllegalArgumentException(String.format(message, "target class"));
}
String message2 = "The version string of the %s is not a correct version string. Description loading aborted";
try {
Version.parseVersion(description.getSourceModel().getVersionString());
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException(String.format(message2, "source class"), e);
}
try {
Version.parseVersion(description.getTargetModel().getVersionString());
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException(String.format(message2, "target class"), e);
}
} | java |
public Object transformObject(TransformationDescription description, Object source) throws InstantiationException,
IllegalAccessException, ClassNotFoundException {
return transformObject(description, source, null);
} | java |
public Object transformObject(TransformationDescription description, Object source, Object target)
throws InstantiationException, IllegalAccessException, ClassNotFoundException {
checkNeededValues(description);
Class<?> sourceClass = modelRegistry.loadModel(description.getSourceModel());
Class<?> targetClass = modelRegistry.loadModel(description.getTargetModel());
if (!sourceClass.isAssignableFrom(source.getClass())) {
throw new IllegalArgumentException("The given source object does not match the given description");
}
this.source = source;
if (target == null) {
this.target = targetClass.newInstance();
} else {
this.target = target;
}
for (TransformationStep step : description.getTransformingSteps()) {
performTransformationStep(step);
}
return this.target;
} | java |
private void performTransformationStep(TransformationStep step) throws IllegalAccessException {
try {
TransformationOperation operation =
operationLoader.loadTransformationOperationByName(step.getOperationName());
Object value = operation.performOperation(getSourceFieldValues(step), step.getOperationParams());
setObjectToTargetField(step.getTargetField(), value);
} catch (TransformationStepException e) {
LOGGER.debug(e.getMessage(), e);
} catch (Exception e) {
LOGGER.error("Unable to perform transformation step {}.", step, e);
}
} | java |
private List<Object> getSourceFieldValues(TransformationStep step) throws Exception {
List<Object> sources = new ArrayList<Object>();
for (String sourceField : step.getSourceFields()) {
Object object = getObjectValue(sourceField, true);
if (object == null) {
String message = String.format("The source field %s is null. Step will be be ignored", sourceField);
throw new TransformationStepException(message);
}
sources.add(object);
}
return sources;
} | java |
private void setObjectToTargetField(String fieldname, Object value) throws Exception {
Object toWrite = null;
if (fieldname.contains(".")) {
String path = StringUtils.substringBeforeLast(fieldname, ".");
toWrite = getObjectValue(path, false);
}
if (toWrite == null && isTemporaryField(fieldname)) {
String mapKey = StringUtils.substringAfter(fieldname, "#");
mapKey = StringUtils.substringBefore(mapKey, ".");
temporaryFields.put(mapKey, value);
return;
}
String realFieldName = fieldname.contains(".") ? StringUtils.substringAfterLast(fieldname, ".") : fieldname;
writeObjectToField(realFieldName, value, toWrite, target);
} | java |
private Object getObjectValue(String fieldname, boolean fromSource) throws Exception {
Object sourceObject = fromSource ? source : target;
Object result = null;
for (String part : StringUtils.split(fieldname, ".")) {
if (isTemporaryField(part)) {
result = loadObjectFromTemporary(part, fieldname);
} else {
result = loadObjectFromField(part, result, sourceObject);
}
}
return result;
} | java |
private Object loadObjectFromField(String fieldname, Object object, Object alternative) throws Exception {
Object source = object != null ? object : alternative;
try {
return FieldUtils.readField(source, fieldname, true);
} catch (Exception e) {
throw new IllegalArgumentException(String.format("Unable to load field '%s' from object '%s'", fieldname,
source.getClass().getName()));
}
} | java |
private void writeObjectToField(String fieldname, Object value, Object object, Object alternative)
throws Exception {
Object target = object != null ? object : alternative;
try {
FieldUtils.writeField(target, fieldname, value, true);
} catch (Exception e) {
throw new IllegalArgumentException(String.format("Unable to write value '%s' to field '%s' of object %s",
value.toString(), fieldname, target.getClass().getName()));
}
} | java |
private static Object waitForServiceFromTracker(ServiceTracker tracker, long timeout)
throws OsgiServiceNotAvailableException {
synchronized (tracker) {
tracker.open();
try {
return tracker.waitForService(timeout);
} catch (InterruptedException e) {
throw new OsgiServiceNotAvailableException(e);
} finally {
tracker.close();
}
}
} | java |
protected double[] getDialogDimensions(String message,
VaadinConfirmDialog.ContentMode style) {
// Based on Reindeer style:
double chrW = 0.51d;
double chrH = 1.5d;
double length = message != null? chrW * message.length() : 0;
double rows = Math.ceil(length / MAX_WIDTH);
// Estimate extra lines
if (style == VaadinConfirmDialog.ContentMode.TEXT_WITH_NEWLINES) {
rows += message != null? count("\n", message): 0;
}
//System.out.println(message.length() + " = " + length + "em");
//System.out.println("Rows: " + (length / MAX_WIDTH) + " = " + rows);
// Obey maximum size
double width = Math.min(MAX_WIDTH, length);
double height = Math.ceil(Math.min(MAX_HEIGHT, rows * chrH));
// Obey the minimum size
width = Math.max(width, MIN_WIDTH);
height = Math.max(height, MIN_HEIGHT);
// Based on Reindeer style:
double btnHeight = 4d;
double vmargin = 5d;
double hmargin = 1d;
double[] res = new double[] { width + hmargin,
height + btnHeight + vmargin };
//System.out.println(res[0] + "," + res[1]);
return res;
} | java |
private static int count(final String needle, final String haystack) {
int count = 0;
int pos = -1;
while ((pos = haystack.indexOf(needle, pos + 1)) >= 0) {
count++;
}
return count;
} | java |
private String format(double n) {
NumberFormat nf = NumberFormat.getNumberInstance(Locale.ENGLISH);
nf.setMaximumFractionDigits(1);
nf.setGroupingUsed(false);
return nf.format(n);
} | java |
public ModelDescription getModelDescription() {
String modelType = object.getString(EDBConstants.MODEL_TYPE);
String version = object.getString(EDBConstants.MODEL_TYPE_VERSION);
return new ModelDescription(modelType, version);
} | java |
public OpenEngSBModel getCorrespondingModel() throws EKBException {
ModelDescription description = getModelDescription();
try {
Class<?> modelClass = modelRegistry.loadModel(description);
return (OpenEngSBModel) edbConverter.convertEDBObjectToModel(modelClass, object);
} catch (ClassNotFoundException e) {
throw new EKBException(String.format("Unable to load model of type %s", description), e);
}
} | java |
public Iterator iterator()
{
CsvPreference preferences =
new CsvPreference.Builder(m_quoteChar, m_delimiterChar, m_endOfLineSymbols).build();
return new CsvIterator(new CsvListReader(m_reader, preferences), m_header);
} | java |
protected Serializable getCompiledExpression() {
if (compiledExpression == null) {
compiledExpression = MVEL.compileExpression(getExpression(), PARSER_CONTEXT);
}
return compiledExpression;
} | java |
protected Serializable getCompiledSetExpression() {
if (compiledSetExpression == null) {
compiledSetExpression = MVEL.compileSetExpression(getExpression(), PARSER_CONTEXT);
}
return compiledSetExpression;
} | java |
public void attachFormValidator(final Form<?> form, final FormValidator validator) {
form.add(new AbstractFormValidator() {
private static final long serialVersionUID = -4181095793820830517L;
@Override
public void validate(Form<?> form) {
Map<String, FormComponent<?>> loadFormComponents = loadFormComponents(form);
Map<String, String> toValidate = new HashMap<String, String>();
for (Map.Entry<String, FormComponent<?>> entry : loadFormComponents.entrySet()) {
toValidate.put(entry.getKey(), entry.getValue().getValue());
}
try {
validator.validate(toValidate);
} catch (ConnectorValidationFailedException e) {
Map<String, String> attributeErrorMessages = e.getErrorMessages();
for (Map.Entry<String, String> entry : attributeErrorMessages.entrySet()) {
FormComponent<?> fc = loadFormComponents.get(entry.getKey());
fc.error(new ValidationError().setMessage(entry.getValue()));
}
}
}
@Override
public FormComponent<?>[] getDependentFormComponents() {
Collection<FormComponent<?>> formComponents = loadFormComponents(form).values();
return formComponents.toArray(new FormComponent<?>[formComponents.size()]);
}
private Map<String, FormComponent<?>> loadFormComponents(final Form<?> form) {
Map<String, FormComponent<?>> formComponents = new HashMap<String, FormComponent<?>>();
if (validator != null) {
for (String attribute : validator.fieldsToValidate()) {
Component component =
form.get("attributesPanel:fields:" + attribute + ":row:field");
if (component instanceof FormComponent<?>) {
formComponents.put(attribute, (FormComponent<?>) component);
}
}
}
return formComponents;
}
});
} | java |
protected Long performCommitLogic(EDBCommit commit) throws EDBException {
if (!(commit instanceof JPACommit)) {
throw new EDBException("The given commit type is not supported.");
}
if (commit.isCommitted()) {
throw new EDBException("EDBCommit is already commitet.");
}
if (revisionCheckEnabled && commit.getParentRevisionNumber() != null
&& !commit.getParentRevisionNumber().equals(getCurrentRevisionNumber())) {
throw new EDBException("EDBCommit do not have the correct head revision number.");
}
runBeginCommitHooks(commit);
EDBException exception = runPreCommitHooks(commit);
if (exception != null) {
return runErrorHooks(commit, exception);
}
Long timestamp = performCommit((JPACommit) commit);
runEDBPostHooks(commit);
return timestamp;
} | java |
private void persistCommitChanges(JPACommit commit, Long timestamp) {
commit.setTimestamp(timestamp);
addModifiedObjectsToEntityManager(commit.getJPAObjects(), timestamp);
commit.setCommitted(true);
logger.debug("persisting JPACommit");
entityManager.persist(commit);
logger.debug("mark the deleted elements as deleted");
updateDeletedObjectsThroughEntityManager(commit.getDeletions(), timestamp);
} | java |
private void addModifiedObjectsToEntityManager(List<JPAObject> modified, Long timestamp) {
for (JPAObject update : modified) {
update.setTimestamp(timestamp);
entityManager.persist(update);
}
} | java |
private void updateDeletedObjectsThroughEntityManager(List<String> oids, Long timestamp) {
for (String id : oids) {
EDBObject o = new EDBObject(id);
o.updateTimestamp(timestamp);
o.setDeleted(true);
JPAObject j = EDBUtils.convertEDBObjectToJPAObject(o);
entityManager.persist(j);
}
} | java |
private void runBeginCommitHooks(EDBCommit commit) throws EDBException {
for (EDBBeginCommitHook hook : beginCommitHooks) {
try {
hook.onStartCommit(commit);
} catch (ServiceUnavailableException e) {
// Ignore
} catch (EDBException e) {
throw e;
} catch (Exception e) {
logger.error("Error while performing EDBBeginCommitHook", e);
}
}
} | java |
private EDBException runPreCommitHooks(EDBCommit commit) {
EDBException exception = null;
for (EDBPreCommitHook hook : preCommitHooks) {
try {
hook.onPreCommit(commit);
} catch (ServiceUnavailableException e) {
// Ignore
} catch (EDBException e) {
exception = e;
break;
} catch (Exception e) {
logger.error("Error while performing EDBPreCommitHook", e);
}
}
return exception;
} | java |
private Long runErrorHooks(EDBCommit commit, EDBException exception) throws EDBException {
for (EDBErrorHook hook : errorHooks) {
try {
EDBCommit newCommit = hook.onError(commit, exception);
if (newCommit != null) {
return commit(newCommit);
}
} catch (ServiceUnavailableException e) {
// Ignore
} catch (EDBException e) {
exception = e;
break;
} catch (Exception e) {
logger.error("Error while performing EDBErrorHook", e);
}
}
throw exception;
} | java |
private void runEDBPostHooks(EDBCommit commit) {
for (EDBPostCommitHook hook : postCommitHooks) {
try {
hook.onPostCommit(commit);
} catch (ServiceUnavailableException e) {
// Ignore
} catch (Exception e) {
logger.error("Error while performing EDBPostCommitHook", e);
}
}
} | java |
public boolean isLaconic(Explanation<E> justification) throws ExplanationException {
// OBSERVATION: If a justification is laconic, then given its O+, there should be
// one justification that is equal to itself.
// Could optimise more here - we know that a laconic justification won't contain
// equivalent classes axioms, inverse properties axioms etc. If an checker doesn't
// appear in O+ then it's not laconic!
Set<OWLAxiom> justificationSigmaClosure = computeOPlus(justification.getAxioms());
ExplanationGenerator<E> gen2 = explanationGeneratorFactory.createExplanationGenerator(justificationSigmaClosure);
Set<Explanation<E>> exps = gen2.getExplanations(justification.getEntailment(), 2);
return Collections.singleton(justification).equals(exps);
} | java |
public JPAEntry getEntry(String entryKey) {
for (JPAEntry entry : entries) {
if (entry.getKey().equals(entryKey)) {
return entry;
}
}
return null;
} | java |
public void removeEntry(String entryKey) {
Iterator<JPAEntry> iter = entries.iterator();
while (iter.hasNext()) {
if (iter.next().getKey().equals(entryKey)) {
iter.remove();
return;
}
}
} | java |
private Object getLengthOfObject(Object object, String functionName) throws TransformationOperationException {
try {
Method method = object.getClass().getMethod(functionName);
return method.invoke(object);
} catch (NoSuchMethodException e) {
StringBuilder builder = new StringBuilder();
builder.append("The type of the given field for the length step doesn't support ");
builder.append(functionName).append(" method. So 0 will be used as standard value.");
throw new TransformationOperationException(builder.toString(), e);
} catch (IllegalArgumentException e) {
throw new TransformationOperationException("Can't get length of the source field", e);
} catch (IllegalAccessException e) {
throw new TransformationOperationException("Can't get length of the source field", e);
} catch (InvocationTargetException e) {
throw new TransformationOperationException("Can't get length of the source field", e);
}
} | java |
private <T> T read_(Class<T> clazz, Object id) {
Map<String, Object> objects = objects(clazz);
return (T) objects.get(id.toString());
} | java |
public void deleteSubtreeExcludingRoot(Dn root) throws NoSuchNodeException, MissingParentException {
existsCheck(root);
try {
EntryCursor entryCursor = connection.search(root, "(objectclass=*)", SearchScope.ONELEVEL);
while (entryCursor.next()) {
deleteSubtreeIncludingRoot(entryCursor.get().getDn());
}
} catch (Exception e) {
throw new LdapDaoException(e);
}
} | java |
public boolean exists(Dn dn) {
try {
return connection.exists(dn);
} catch (LdapException e) {
throw new LdapDaoException(e);
}
} | java |
private QueryRequest createQueryRequest(String[] elements) {
QueryRequest request = QueryRequest.create();
for (String element : elements) {
String[] parts = StringUtils.split(element, ":", 2);
parts[0] = parts[0].replace("\\", "\\\\");
parts[1] = parts[1].replace("\\", "\\\\");
request.addParameter(parts[0], parts[1].substring(1, parts[1].length() - 1));
}
return request;
} | java |
public SequenceGenerator.SequenceBlock allocateBlock(int blockSize) {
final long l = this.last;
SequenceGenerator.SequenceBlock block =
new SequenceGenerator.SequenceBlock(l + 1, l + blockSize);
this.last = l + blockSize;
return block;
} | java |
public void readExternal(PofReader reader)
throws IOException {
name = reader.readString(0);
last = reader.readLong(1);
} | java |
public void writeExternal(PofWriter writer)
throws IOException {
writer.writeString(0, name);
writer.writeLong(1, last);
} | java |
public Set<OWLClass> getRootUnsatisfiableClasses() throws ExplanationException {
StructuralRootDerivedReasoner srd = new StructuralRootDerivedReasoner(manager, baseReasoner, reasonerFactory);
Set<OWLClass> estimatedRoots = srd.getRootUnsatisfiableClasses();
cls2JustificationMap = new HashMap<OWLClass, Set<Explanation<OWLAxiom>>>();
Set<OWLAxiom> allAxioms = new HashSet<OWLAxiom>();
for (OWLOntology ont : baseReasoner.getRootOntology().getImportsClosure()) {
allAxioms.addAll(ont.getLogicalAxioms());
}
for (OWLClass cls : estimatedRoots) {
cls2JustificationMap.put(cls, new HashSet<Explanation<OWLAxiom>>());
System.out.println("POTENTIAL ROOT: " + cls);
}
System.out.println("Finding real roots from " + estimatedRoots.size() + " estimated roots");
int done = 0;
roots.addAll(estimatedRoots);
for (final OWLClass estimatedRoot : estimatedRoots) {
ExplanationGeneratorFactory<OWLAxiom> genFac = ExplanationManager.createExplanationGeneratorFactory(reasonerFactory);
ExplanationGenerator<OWLAxiom> gen = genFac.createExplanationGenerator(allAxioms);
OWLDataFactory df = manager.getOWLDataFactory();
Set<Explanation<OWLAxiom>> expls = gen.getExplanations(df.getOWLSubClassOfAxiom(estimatedRoot, df.getOWLNothing()));
cls2JustificationMap.get(estimatedRoot).addAll(expls);
done++;
System.out.println("Done " + done);
}
for(OWLClass clsA : estimatedRoots) {
for(OWLClass clsB : estimatedRoots) {
if (!clsA.equals(clsB)) {
Set<Explanation<OWLAxiom>> clsAExpls = cls2JustificationMap.get(clsA);
Set<Explanation<OWLAxiom>> clsBExpls = cls2JustificationMap.get(clsB);
boolean clsARootForClsB = false;
boolean clsBRootForClsA = false;
// Be careful of cyclic dependencies!
for(Explanation<OWLAxiom> clsAExpl : clsAExpls) {
for(Explanation<OWLAxiom> clsBExpl : clsBExpls) {
if(isRootFor(clsAExpl, clsBExpl)) {
// A is a root of B
clsARootForClsB = true;
// System.out.println(clsB + " --- depends ---> " + clsA);
}
else if(isRootFor(clsBExpl, clsAExpl)) {
// B is a root of A
clsBRootForClsA = true;
// System.out.println(clsA + " --- depends ---> " + clsB);
}
}
}
if (!clsARootForClsB || !clsBRootForClsA) {
if(clsARootForClsB) {
roots.remove(clsB);
}
else if(clsBRootForClsA) {
roots.remove(clsA);
}
}
}
}
}
return roots;
} | java |
public static Connection getConnection(final String jndiName)
throws FactoryException {
Validate.notBlank(jndiName, "The validated character sequence 'jndiName' is null or empty");
// no need for defensive copies of Strings
try {
return DataSourceFactory.getDataSource(jndiName).getConnection();
} catch (SQLException e) {
final String error = "Error retrieving JDBC connection from JNDI: " + jndiName;
LOG.warn(error);
throw new FactoryException(error, e);
}
} | java |
public static QueryRequest query(String key, Object value) {
return QueryRequest.create().addParameter(key, value);
} | java |
public QueryRequest addParameter(String key, Object value) {
if (parameters.get(key) == null) {
parameters.put(key, Sets.newHashSet(value));
} else {
parameters.get(key).add(value);
}
return this;
} | java |
@SuppressWarnings({ "rawtypes", "unchecked" })
private Predicate[] analyzeParamMap(CriteriaBuilder criteriaBuilder, Root from, Map<String, Object> param) {
List<Predicate> predicates = new ArrayList<Predicate>();
for (Map.Entry<String, Object> entry : param.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
if (key.equals("timestamp")) {
predicates.add(criteriaBuilder.le(from.get("timestamp"), (Long) value));
} else if (key.equals("committer")) {
predicates.add(criteriaBuilder.equal(from.get("committer"), value));
} else if (key.equals("context")) {
predicates.add(criteriaBuilder.equal(from.get("context"), value));
}
}
Predicate[] temp = new Predicate[predicates.size()];
for (int i = 0; i < predicates.size(); i++) {
temp[i] = predicates.get(i);
}
return temp;
} | java |
private void batchImport() {
m_jdbcTemplate.batchUpdate(createInsertQuery(),
new BatchPreparedStatementSetter() {
public void setValues(
PreparedStatement ps, int i)
throws SQLException {
int j = 1;
for (String property : m_propertyNames) {
Map params = (Map) m_batch.get(
i);
ps.setObject(j++, params.get(
property));
}
}
public int getBatchSize() {
return m_batch.size();
}
});
} | java |
private String createInsertQuery() {
StringBuilder query = new StringBuilder();
query.append("insert into ").append(m_tableName)
.append("(").append(m_propertyNames[0]);
for (int i = 1; i < m_propertyNames.length; i++) {
query.append(",").append(m_propertyNames[i]);
}
query.append(") values (?");
for (int i = 1; i < m_propertyNames.length; i++) {
query.append(",?");
}
query.append(")");
return query.toString();
} | java |
public static <T extends Annotation> Method findMethodWithAnnotation(Class<?> clazz, Class<T> annotationType) {
Method annotatedMethod = null;
for (Method method : clazz.getDeclaredMethods()) {
T annotation = AnnotationUtils.findAnnotation(method, annotationType);
if (annotation != null) {
if (annotatedMethod != null) {
throw new BeanCreationException("Only ONE method with @" + annotationType.getName()
+ " is allowed on " + clazz.getName() + ".");
}
annotatedMethod = method;
}
}
if((annotatedMethod != null) || clazz.equals(Object.class)){
return annotatedMethod;
} else {
return findMethodWithAnnotation(clazz.getSuperclass(), annotationType);
}
} | java |
public static Object invokeMethod(Object object, Method method, Object... args) throws Throwable {
try {
return method.invoke(object, args);
} catch (InvocationTargetException e) {
throw e.getTargetException();
}
} | java |
public static void validateReturnType(Method method, Class<? extends Annotation> annotationType,
Class<?> expectedReturnType) {
if (!method.getReturnType().equals(expectedReturnType)) {
throw new BeanCreationException("Method " + method.getName() + " annotated with @"
+ annotationType.getName() + " must have a return type of "
+ expectedReturnType.getName());
}
} | java |
public static void validateArgument(Method method, Class<? extends Annotation> annotationType,
Class<?> expectedParameterType) {
if (method.getParameterTypes().length != 1 || !method.getParameterTypes()[0].equals(expectedParameterType)) {
throw new BeanCreationException(String.format(
"Method %s with @%s MUST take a single argument of type %s",
method,
annotationType.getName(),
expectedParameterType.getName()
));
}
} | java |
protected Object getValue() {
Object value = this.value;
if (value == null) {
this.value = value = fromBinary("value");
}
return value;
} | java |
public CuratorFramework newCurator() {
// Make all of the curator threads daemon threads so they don't block the JVM from terminating. Also label them
// with the ensemble they're connecting to, in case someone is trying to sort through a thread dump.
ThreadFactory threadFactory = new ThreadFactoryBuilder()
.setNameFormat("CuratorFramework[" + _connectString.orElse(DEFAULT_CONNECT_STRING) + "]-%d")
.setDaemon(true)
.build();
org.apache.curator.RetryPolicy retry = _setterRetryPolicy.orElse(
(_configRetryPolicy != null)
? _configRetryPolicy
: DEFAULT_RETRY_POLICY
);
return CuratorFrameworkFactory.builder()
.ensembleProvider(new ResolvingEnsembleProvider(_connectString.orElse(DEFAULT_CONNECT_STRING)))
.retryPolicy(retry)
.sessionTimeoutMs(Ints.checkedCast(_sessionTimeout.toMilliseconds()))
.connectionTimeoutMs(Ints.checkedCast(_connectionTimeout.toMilliseconds()))
.namespace(_namespace.orElse(null))
.threadFactory(threadFactory)
.build();
} | java |
public static Class<?> getTypeArgument(Class<?> clazz, Class<?> interfce) {
Map<Type, Type> resolvedTypes = new HashMap<Type, Type>();
Type type = clazz;
while (!declaresInterface(getClass(type), interfce)) {
if (type instanceof Class) {
type = ((Class<?>) type).getGenericSuperclass();
} else {
ParameterizedType parameterizedType = (ParameterizedType) type;
Class<?> rawType = (Class<?>) parameterizedType.getRawType();
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
TypeVariable<?>[] typeParameters = rawType.getTypeParameters();
for (int i = 0; i < actualTypeArguments.length; i++) {
resolvedTypes.put(typeParameters[i], actualTypeArguments[i]);
}
type = rawType.getGenericSuperclass();
}
}
Type actualTypeArgument;
if (type instanceof Class) {
actualTypeArgument = ((Class<?>) type).getTypeParameters()[0];
} else {
actualTypeArgument = ((ParameterizedType) type).getActualTypeArguments()[0];
}
Class<?> typeArgumentAsClass = null;
while (resolvedTypes.containsKey(actualTypeArgument)) {
actualTypeArgument = resolvedTypes.get(actualTypeArgument);
}
typeArgumentAsClass = getClass(actualTypeArgument);
return typeArgumentAsClass;
} | java |
public static List<Entry> assignmentStructure(Assignment assignment) {
List<Entry> entryList = new LinkedList<>();
entryList.add(namedObject(DnFactory.assignment(assignment)));
entryList.add(namedDescriptiveObject(DnFactory.assignmentProject(assignment), assignment.getProject()));
entryList.add(namedDescriptiveObject(DnFactory.assignmentUser(assignment), assignment.getUser()));
entryList.addAll(createAssignmentPermissionsEntries(assignment));
entryList.addAll(createAssignmentRolesEntries(assignment));
return entryList;
} | java |
public static List<Entry> permissionStructure(Permission permission) {
List<Entry> entryList = new LinkedList<>();
entryList.add(namedObject(DnFactory.permission(permission)));
entryList.add(namedDescriptiveObject(DnFactory.permissionAction(permission), permission.getAction()));
entryList
.add(namedDescriptiveObject(DnFactory.permissionComponent(permission), permission.getComponentName()));
return entryList;
} | java |
public static List<Entry> projectStructure(Project project) {
List<Entry> entryList = new LinkedList<>();
entryList.add(namedObject(DnFactory.project(project)));
entryList.addAll(createProjectAttributesEntries(project));
return entryList;
} | java |
public static List<Entry> roleStructure(Role role) {
List<Entry> entryList = new LinkedList<>();
entryList.add(namedObject(DnFactory.role(role)));
entryList.addAll(createRolePermissionsEntries(role));
entryList.addAll(createRoleSubrolesEntries(role));
return entryList;
} | java |
public BufferedImage getBufferedImage(int width, int height) {
BufferedImage bi = chart.createBufferedImage(width, height);
return bi;
} | java |
@SuppressWarnings("deprecation")
private JFreeChart createChart(CategoryDataset dataset) {
// String s = name;
String s = null;
String tit = null;
String ax = null;
// if (first)
// tit = title + " (EST)";
// else if (last)
// ax = "Time";
tit = this.name;
chart = ChartFactory.createStackedBarChart(
tit, // chart title
s, // domain axis label
ax, // range axis label
dataset, // data
PlotOrientation.HORIZONTAL, // the plot orientation
false, // legend
false, // tooltips
false // urls
);
CategoryPlot plot = chart.getCategoryPlot();
chart.getTitle().setHorizontalAlignment(HorizontalAlignment.LEFT);
plot.setRangeAxisLocation(AxisLocation.BOTTOM_OR_RIGHT);
//plot.getCategories();
//CategoryItemRenderer renderer = plot.getRenderer();
StackedBarRenderer renderer = (StackedBarRenderer) plot.getRenderer();
renderer.setItemLabelsVisible(true);
renderer.setItemLabelGenerator(new LabelGenerator(showlabels));
ItemLabelPosition pos = new ItemLabelPosition(ItemLabelAnchor.INSIDE1, TextAnchor.TOP_RIGHT);
renderer.setPositiveItemLabelPositionFallback(pos);
for(int i = 0; i < dataset.getRowCount(); i++) {
renderer.setSeriesPositiveItemLabelPosition(i, pos);
}
/*
if (values.elementAt(0) instanceof ResourceLevel) {
renderer.setItemLabelGenerator( new PlotBoxTL.LabelGenerator(true));
}
else
renderer.setItemLabelGenerator( new PlotBoxTL.LabelGenerator(false));
*/
renderer.setToolTipGenerator(new PlotBoxTooltip());
plot.setRenderer(renderer);
// renderer.getSeriesStroke(0).
plot.setForegroundAlpha(0.8f);
NumberAxis rangeAxis = (NumberAxis) plot.getRangeAxis();
rangeAxis.setStandardTickUnits(NumberAxis.createIntegerTickUnits());
rangeAxis.setLowerMargin(2.0);
rangeAxis.setUpperMargin(2.0);
//long origin = stl.getSerializableSimpleTimeline().getEarliestStartTime();
//long horizon = stl.getSerializableSimpleTimeline().getLatestEndTime();
long origin = stl.getPulses()[0].longValue();
NumberFormat nf = new DecimalFormat();
rangeAxis.setNumberFormatOverride ( nf );
if (this.range != null) rangeAxis.setRange(range);
//rangeAxis.setRange((new Double(origin)).doubleValue(), (new Double(horizon)).doubleValue());
///// 0 should be replaced by the start of the horizon
renderer.setBase(origin);
//renderer.setBase();
for (int i = 0; i < durations.length; i++) {
if (stl.isInconsistent(values[i]))
renderer.setSeriesPaint(i, new Color(198, 30, 69));
else if (stl.isCritical(values[i]))
renderer.setSeriesPaint(i, new Color(238,234,111));
else if (stl.isUndetermined(values[i]))
renderer.setSeriesPaint(i, new Color(255,255,255));
else renderer.setSeriesPaint(i, new Color(111,180,238));
renderer.setSeriesOutlinePaint(i, Color.black);
}
renderer.setBaseSeriesVisibleInLegend(false, false);
renderer.setSeriesStroke(0, new BasicStroke(40f));
return chart;
} | java |
private CategoryDataset createDataset() {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
startTimes = new Long[stl.getPulses().length+1];
startTimes[0] = new Long(0);
for( int i = 1 ; i < startTimes.length ; i++ ) {
startTimes[i] = stl.getPulses()[i-1];
}
durations = new Long[stl.getDurations().length+1];
durations[0] = new Long(0);
for( int i = 1 ; i < durations.length ; i++ ) {
durations[i] = stl.getDurations()[i-1];
}
values = new Object[stl.getValues().length+1];
values[0] = null;
for( int i = 1 ; i < values.length ; i++ ) {
values[i] = stl.getValues()[i-1];
}
for (int i = 0; i < durations.length; i++) {
//Dbg.printMsg("dur" + i + ": " + durations.elementAt(i), LogLvl.Normal);
//dataset.addValue((long)durations.elementAt(i), i+"", stateVar.getName());
dataset.addValue((long)durations[i], i+"", "");
}
return dataset;
} | java |
public static String extractAttributeEmptyCheck(Entry entry, String attributeType) {
Attribute attribute = entry.get(attributeType);
Attribute emptyFlagAttribute = entry.get(SchemaConstants.EMPTY_FLAG_ATTRIBUTE);
boolean empty = false;
try {
if (attribute != null) {
return attribute.getString();
} else if (emptyFlagAttribute != null) {
empty = Boolean.valueOf(emptyFlagAttribute.getString());
}
} catch (LdapInvalidAttributeValueException e) {
throw new ObjectClassViolationException(e);
}
return empty ? new String() : null;
} | java |
public static List<String> extractAttributeEmptyCheck(List<Entry> entries, String attributeType) {
List<String> result = new LinkedList<String>();
for (Entry e : entries) {
result.add(extractAttributeEmptyCheck(e, attributeType));
}
return result;
} | java |
public static List<String> extractAttributeEmptyCheck(SearchCursor cursor, String attributeType) {
List<String> result = new LinkedList<String>();
try {
while (cursor.next()) {
Entry entry = cursor.getEntry();
result.add(extractAttributeEmptyCheck(entry, attributeType));
}
} catch (Exception e) {
throw new LdapRuntimeException(e);
}
return result;
} | java |
private void createObjectDiffs() throws EDBException {
diff = new HashMap<String, EDBObjectDiff>();
List<EDBObject> tempList = new ArrayList<EDBObject>();
for (EDBObject o : this.endState) {
tempList.add(o);
}
addModifiedOrDeletedObjects(tempList);
addNewObjects(tempList);
} | java |
private void addModifiedOrDeletedObjects(List<EDBObject> tempList) {
for (EDBObject a : this.startState) {
String oid = a.getOID();
EDBObject b = removeIfExist(oid, tempList);
ObjectDiff odiff = new ObjectDiff(this.startCommit, this.endCommit, a, b);
if (odiff.getDifferenceCount() > 0) {
diff.put(oid, odiff);
}
}
} | java |
private void addNewObjects(List<EDBObject> tempList) {
for (EDBObject b : tempList) {
String oid = b.getOID();
ObjectDiff odiff = new ObjectDiff(this.startCommit, this.endCommit, null, b);
if (odiff.getDifferenceCount() > 0) {
diff.put(oid, odiff);
}
}
} | java |
private EDBObject removeIfExist(String oid, List<EDBObject> tempList) {
Iterator<EDBObject> iterator = tempList.iterator();
while (iterator.hasNext()) {
EDBObject obj = iterator.next();
if (obj.getOID().equals(oid)) {
iterator.remove();
return obj;
}
}
LOGGER.debug(oid + " wasn't found in the list of end state objects");
return null;
} | java |
private boolean compareRelation(RCCConstraint first,
RCCConstraint second) {
boolean existed = false;
for (int i = 0; i < first.types.length; i++) {
existed = false;
for (int j = 0; j < second.types.length; j++) {
if(first.types[i] == second.types[j])
existed = true;
}
if(!existed) return false;
}
return true;
} | java |
private void runPersistingLogic(EKBCommit commit, boolean check, UUID expectedContextHeadRevision,
boolean headRevisionCheck) throws SanityCheckException, EKBException {
String contextId = ContextHolder.get().getCurrentContextId();
try {
lockContext(contextId);
if (headRevisionCheck) {
checkForContextHeadRevision(contextId, expectedContextHeadRevision);
}
runEKBPreCommitHooks(commit);
if (check) {
performSanityChecks(commit);
}
EKBException exception = null;
ConvertedCommit converted = edbConverter.convertEKBCommit(commit);
try {
performPersisting(converted, commit);
runEKBPostCommitHooks(commit);
} catch (EKBException e) {
exception = e;
}
runEKBErrorHooks(commit, exception);
} finally {
releaseContext(contextId);
}
} | java |
private void performRevertLogic(String revision, UUID expectedContextHeadRevision, boolean expectedHeadCheck) {
String contextId = "";
try {
EDBCommit commit = edbService.getCommitByRevision(revision);
contextId = commit.getContextId();
lockContext(contextId);
if (expectedHeadCheck) {
checkForContextHeadRevision(contextId, expectedContextHeadRevision);
}
EDBCommit newCommit = edbService.createEDBCommit(new ArrayList<EDBObject>(),
new ArrayList<EDBObject>(), new ArrayList<EDBObject>());
for (EDBObject reverted : commit.getObjects()) {
// need to be done in order to avoid problems with conflict detection
reverted.remove(EDBConstants.MODEL_VERSION);
newCommit.update(reverted);
}
for (String delete : commit.getDeletions()) {
newCommit.delete(delete);
}
newCommit.setComment(String.format("revert [%s] %s", commit.getRevisionNumber().toString(),
commit.getComment() != null ? commit.getComment() : ""));
edbService.commit(newCommit);
} catch (EDBException e) {
throw new EKBException("Unable to revert to the given revision " + revision, e);
} finally {
releaseContext(contextId);
}
} | java |
private void lockContext(String contextId) throws EKBConcurrentException {
if (mode == ContextLockingMode.DEACTIVATED) {
return;
}
synchronized (activeWritingContexts) {
if (activeWritingContexts.contains(contextId)) {
throw new EKBConcurrentException("There is already a writing process active in the context.");
}
activeWritingContexts.add(contextId);
}
} | java |
private void checkForContextHeadRevision(String contextId, UUID expectedHeadRevision)
throws EKBConcurrentException {
if (!Objects.equal(edbService.getLastRevisionNumberOfContext(contextId), expectedHeadRevision)) {
throw new EKBConcurrentException("The current revision of the context does not match the "
+ "expected one.");
}
} | java |
private void releaseContext(String contextId) {
if (mode == ContextLockingMode.DEACTIVATED) {
return;
}
synchronized (activeWritingContexts) {
activeWritingContexts.remove(contextId);
}
} | java |
private void runEKBPreCommitHooks(EKBCommit commit) throws EKBException {
for (EKBPreCommitHook hook : preCommitHooks) {
try {
hook.onPreCommit(commit);
} catch (EKBException e) {
throw new EKBException("EDBException is thrown in a pre commit hook.", e);
} catch (Exception e) {
LOGGER.warn("An exception is thrown in a EKB pre commit hook.", e);
}
}
} | java |
private void runEKBPostCommitHooks(EKBCommit commit) throws EKBException {
for (EKBPostCommitHook hook : postCommitHooks) {
try {
hook.onPostCommit(commit);
} catch (Exception e) {
LOGGER.warn("An exception is thrown in a EKB post commit hook.", e);
}
}
} | java |
private void runEKBErrorHooks(EKBCommit commit, EKBException exception) {
if (exception != null) {
for (EKBErrorHook hook : errorHooks) {
hook.onError(commit, exception);
}
throw exception;
}
} | java |
private void performPersisting(ConvertedCommit commit, EKBCommit source) throws EKBException {
try {
EDBCommit ci = edbService.createEDBCommit(commit.getInserts(), commit.getUpdates(), commit.getDeletes());
ci.setDomainId(source.getDomainId());
ci.setConnectorId(source.getConnectorId());
ci.setInstanceId(source.getInstanceId());
ci.setComment(source.getComment());
edbService.commit(ci);
source.setRevisionNumber(ci.getRevisionNumber());
source.setParentRevisionNumber(ci.getParentRevisionNumber());
} catch (EDBCheckException e) {
throw new ModelPersistException(convertEDBObjectList(e.getFailedInserts()),
convertEDBObjectList(e.getFailedUpdates()), e.getFailedDeletes(), e);
} catch (EDBException e) {
throw new EKBException("Error while commiting EKBCommit", e);
}
} | java |
private List<String> convertEDBObjectList(List<EDBObject> objects) {
List<String> oids = new ArrayList<>();
for (EDBObject object : objects) {
oids.add(object.getOID());
}
return oids;
} | java |
private Set<ModelDescription> scanBundleForModels(Bundle bundle) {
Set<ModelDescription> models = new HashSet<ModelDescription>();
if (!shouldSkipBundle(bundle)) {
models = loadModelsOfBundle(bundle);
}
return models;
} | java |
private Set<ModelDescription> loadModelsOfBundle(Bundle bundle) {
Enumeration<URL> classEntries = bundle.findEntries("/", "*.class", true);
Set<ModelDescription> models = new HashSet<ModelDescription>();
if (classEntries == null) {
LOGGER.debug("Found no classes in the bundle {}", bundle);
return models;
}
while (classEntries.hasMoreElements()) {
URL classURL = classEntries.nextElement();
String classname = extractClassName(classURL);
if (isModelClass(classname, bundle)) {
models.add(new ModelDescription(classname, bundle.getVersion().toString()));
}
}
return models;
} | java |
private boolean isModelClass(String classname, Bundle bundle) {
LOGGER.debug("Check if class '{}' is a model class", classname);
Class<?> clazz;
try {
clazz = bundle.loadClass(classname);
} catch (ClassNotFoundException e) {
LOGGER.warn("Bundle could not load its own class: '{}' bundle: '{}'", classname, bundle.getSymbolicName());
LOGGER.debug("Exact error: ", e);
return false;
} catch (NoClassDefFoundError e) {
// ignore since this happens if bundle have optional imports
return false;
} catch (Error e) {
// if this catch clause is reached, then the bundle which caused this error need to be checked. There
// is something wrong with the setup of the bundle (e.g. double import of a library of different versions)
LOGGER.warn("Error while loading class: '{}' in bundle: '{}'", classname, bundle.getSymbolicName());
LOGGER.debug("Exact error: ", e);
return false;
}
return clazz.isAnnotationPresent(Model.class);
} | java |
private String extractClassName(URL classURL) {
String path = classURL.getPath();
return path
.replaceAll("^/", "")
.replaceAll(".class$", "")
.replaceAll("\\/", ".");
} | java |
public List<User> findAllUsers() {
List<User> list = new ArrayList<>();
List<String> usernames;
try {
usernames = readLines(usersFile);
} catch (IOException e) {
throw new FileBasedRuntimeException(e);
}
for (String username : usernames) {
if (StringUtils.isNotBlank(username)) {
list.add(new User(username));
}
}
return list;
} | java |
private int rightmostIndexBelowMax() {
for (int i = r-1; i>=0; i--)
if (index[i] < n - r + i) return i;
return -1;
} | java |
public static void setLevel(Level l) {
for (Logger log : loggers.values()) log.setLevel(l);
globalLevel = l;
} | java |
public static void setLevel(Class<?> c, Level l) /* throws LoggerNotDefined */ {
if (!loggers.containsKey(c)) tempLevels.put(c, l);
else loggers.get(c).setLevel(l);
//System.out.println("Set level " + l + " for logger " + loggers.get(c).getName());
} | java |
public void setImage(BufferedImage im) {
icon.setImage(im);
if (image == null) {
this.image = im;
// this.setSize(image.getWidth(), image.getHeight());
int panelX = image.getWidth();
int panelY = image.getHeight();
panel.setSize(panelX, panelY);
// Toolkit tk = Toolkit.getDefaultToolkit();
// int xSize = ((int) tk.getScreenSize().getWidth());
// int ySize = ((int) tk.getScreenSize().getHeight());
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (UnsupportedLookAndFeelException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
Rectangle bounds = ge.getMaximumWindowBounds();
int deltaX = 30;
int deltaY = 50;
int xSize = Math.min(bounds.width, panelX+deltaX);
int ySize = Math.min(bounds.height, panelY+deltaY);
this.setPreferredSize(new Dimension(xSize, ySize));
this.setResizable(true);
this.pack();
}
this.getContentPane().repaint();
if (!this.isVisible()) this.setVisible(true);
} | java |
public List<Assignment> findAllAssignments() {
List<Assignment> list = new ArrayList<>();
List<String> assignmentStrings;
try {
assignmentStrings = readLines(assignmentsFile);
} catch (IOException e) {
throw new FileBasedRuntimeException(e);
}
for (String assignmentString : assignmentStrings) {
if (StringUtils.isNotBlank(assignmentString)) {
String[] substrings =
StringUtils
.splitByWholeSeparator(assignmentString, Configuration.get().getAssociationSeparator());
if (substrings.length < 2 || StringUtils.isBlank(substrings[1])) {
continue;
}
Assignment assignment = new Assignment(substrings[0], substrings[1]);
if (substrings.length > 2) {
assignment.setRoles(Arrays.asList(StringUtils.splitByWholeSeparator(substrings[2], Configuration
.get().getValueSeparator())));
}
list.add(assignment);
}
}
return list;
} | java |
private static void logValue(final String key, final String value) {
// Fortify will report a violation here because of disclosure of potentially confidential information.
// However, the configuration keys are not confidential, which makes this a non-issue / false positive.
if (LOG.isInfoEnabled()) {
final StringBuilder msg = new StringBuilder("Key found in configuration ('")
.append(key)
.append("'), using configured value (not disclosed here for security reasons)");
LOG.info(msg.toString());
}
// Fortify will report a violation here because of disclosure of potentially confidential information.
// The configuration VALUES are confidential. DO NOT activate DEBUG logging in production.
if (LOG.isDebugEnabled()) {
final StringBuilder msg = new StringBuilder("Key found in configuration ('")
.append(key)
.append("'), using configured value ('");
if (value == null) {
msg.append("null')");
} else {
msg.append(value).append("')");
}
LOG.debug(msg.toString());
}
} | java |
private static void logDefault(final String key, final String defaultValue) {
// Fortify will report a violation here because of disclosure of potentially confidential information.
// However, neither the configuration keys nor the default propsbuilder values are confidential, which makes
// this a non-issue / false positive.
if (LOG.isInfoEnabled()) {
final StringBuilder msg = new StringBuilder("Key is not configured ('")
.append(key)
.append("'), using default value ('");
if (defaultValue == null) {
msg.append("null')");
} else {
msg.append(defaultValue).append("')");
}
LOG.info(msg.toString());
}
} | java |
@SuppressWarnings({"PMD.UseObjectForClearerAPI"})
// CHECKSTYLE:ON
private static void logDefault(final String key,
final String invalidValue,
final String validationError,
final String defaultValue) {
if (LOG.isWarnEnabled()) {
final StringBuilder msg = new StringBuilder("Invalid value ('")
.append(invalidValue)
.append("', ")
.append(validationError)
.append(") for key '")
.append(key)
.append("', using default instead ('");
if (defaultValue == null) {
msg.append("null')");
} else {
msg.append(defaultValue).append("')");
}
LOG.warn(msg.toString());
}
} | java |
public int getSequenceNumber(Coordinate coord) {
int minIndex = 0;
double minDist = Double.MAX_VALUE;
for (int i = 0; i < this.getPositions().length; i++) {
if (this.getPositions()[i].distance(coord) < minDist) {
minDist = this.getPositions()[i].distance(coord);
minIndex = i;
}
}
return minIndex;
} | java |
private void enhanceEKBCommit(EKBCommit commit) throws EKBException {
LOGGER.debug("Started to enhance the EKBCommit with Engineering Object information");
enhanceCommitInserts(commit);
enhanceCommitUpdates(commit);
// TODO: OPENENGSB-3357, consider also deletions in the enhancement
LOGGER.debug("Finished EKBCommit enhancing");
} | java |
private void enhanceCommitUpdates(EKBCommit commit) throws EKBException {
Map<Object, AdvancedModelWrapper> updated = new HashMap<Object, AdvancedModelWrapper>();
List<AdvancedModelWrapper> result = recursiveUpdateEnhancement(
convertOpenEngSBModelList(commit.getUpdates()), updated, commit);
commit.getUpdates().addAll(convertSimpleModelWrapperList(result));
} | java |
private List<AdvancedModelWrapper> convertOpenEngSBModelList(List<OpenEngSBModel> models) {
List<AdvancedModelWrapper> wrappers = new ArrayList<AdvancedModelWrapper>();
for (OpenEngSBModel model : models) {
wrappers.add(AdvancedModelWrapper.wrap(model));
}
return wrappers;
} | java |
private List<OpenEngSBModel> convertSimpleModelWrapperList(List<AdvancedModelWrapper> wrappers) {
List<OpenEngSBModel> models = new ArrayList<OpenEngSBModel>();
for (AdvancedModelWrapper wrapper : wrappers) {
models.add(wrapper.getUnderlyingModel());
}
return models;
} | java |
private List<AdvancedModelWrapper> recursiveUpdateEnhancement(List<AdvancedModelWrapper> updates,
Map<Object, AdvancedModelWrapper> updated, EKBCommit commit) {
List<AdvancedModelWrapper> additionalUpdates = enhanceUpdates(updates, updated, commit);
for (AdvancedModelWrapper model : updates) {
updated.put(model.getCompleteModelOID(), model);
}
if (!additionalUpdates.isEmpty()) {
additionalUpdates.addAll(recursiveUpdateEnhancement(additionalUpdates, updated, commit));
}
return additionalUpdates;
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.