repo stringlengths 7 58 | path stringlengths 12 218 | func_name stringlengths 3 140 | original_string stringlengths 73 34.1k | language stringclasses 1 value | code stringlengths 73 34.1k | code_tokens list | docstring stringlengths 3 16k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 105 339 | partition stringclasses 1 value |
|---|---|---|---|---|---|---|---|---|---|---|---|
BrunoEberhard/minimal-j | src/main/java/org/minimalj/frontend/impl/swing/FrameManager.java | FrameManager.closeWindowPerformed | public void closeWindowPerformed(SwingFrame frameView) {
if (!navigationFrames.contains(frameView)) return;
if (navigationFrames.size() == 1 && !askBeforeExit(frameView)) {
return;
}
if (frameView.tryToCloseWindow()) {
removeNavigationFrameView(frameView);
}
} | java | public void closeWindowPerformed(SwingFrame frameView) {
if (!navigationFrames.contains(frameView)) return;
if (navigationFrames.size() == 1 && !askBeforeExit(frameView)) {
return;
}
if (frameView.tryToCloseWindow()) {
removeNavigationFrameView(frameView);
}
} | [
"public",
"void",
"closeWindowPerformed",
"(",
"SwingFrame",
"frameView",
")",
"{",
"if",
"(",
"!",
"navigationFrames",
".",
"contains",
"(",
"frameView",
")",
")",
"return",
";",
"if",
"(",
"navigationFrames",
".",
"size",
"(",
")",
"==",
"1",
"&&",
"!",
"askBeforeExit",
"(",
"frameView",
")",
")",
"{",
"return",
";",
"}",
"if",
"(",
"frameView",
".",
"tryToCloseWindow",
"(",
")",
")",
"{",
"removeNavigationFrameView",
"(",
"frameView",
")",
";",
"}",
"}"
] | Asks the use about closing and then tries to close the Window
@param frameView NavigationFrameView to close | [
"Asks",
"the",
"use",
"about",
"closing",
"and",
"then",
"tries",
"to",
"close",
"the",
"Window"
] | f7c5461b2b47a10b383aee1e2f1f150f6773703b | https://github.com/BrunoEberhard/minimal-j/blob/f7c5461b2b47a10b383aee1e2f1f150f6773703b/src/main/java/org/minimalj/frontend/impl/swing/FrameManager.java#L96-L106 | train |
BrunoEberhard/minimal-j | src/main/java/org/minimalj/frontend/impl/swing/FrameManager.java | FrameManager.askBeforeExit | private boolean askBeforeExit(SwingFrame navigationFrameView) {
if (Configuration.isDevModeActive()) {
return true;
} else {
int answer = JOptionPane.showConfirmDialog(navigationFrameView, Resources.getString("Exit.confirm"), Resources.getString("Exit.confirm.title"), JOptionPane.YES_NO_OPTION);
return answer == JOptionPane.YES_OPTION;
}
} | java | private boolean askBeforeExit(SwingFrame navigationFrameView) {
if (Configuration.isDevModeActive()) {
return true;
} else {
int answer = JOptionPane.showConfirmDialog(navigationFrameView, Resources.getString("Exit.confirm"), Resources.getString("Exit.confirm.title"), JOptionPane.YES_NO_OPTION);
return answer == JOptionPane.YES_OPTION;
}
} | [
"private",
"boolean",
"askBeforeExit",
"(",
"SwingFrame",
"navigationFrameView",
")",
"{",
"if",
"(",
"Configuration",
".",
"isDevModeActive",
"(",
")",
")",
"{",
"return",
"true",
";",
"}",
"else",
"{",
"int",
"answer",
"=",
"JOptionPane",
".",
"showConfirmDialog",
"(",
"navigationFrameView",
",",
"Resources",
".",
"getString",
"(",
"\"Exit.confirm\"",
")",
",",
"Resources",
".",
"getString",
"(",
"\"Exit.confirm.title\"",
")",
",",
"JOptionPane",
".",
"YES_NO_OPTION",
")",
";",
"return",
"answer",
"==",
"JOptionPane",
".",
"YES_OPTION",
";",
"}",
"}"
] | Asks about leaving the application
@param navigationFrameView used as parent of question dialog
@return true if user wants to leave | [
"Asks",
"about",
"leaving",
"the",
"application"
] | f7c5461b2b47a10b383aee1e2f1f150f6773703b | https://github.com/BrunoEberhard/minimal-j/blob/f7c5461b2b47a10b383aee1e2f1f150f6773703b/src/main/java/org/minimalj/frontend/impl/swing/FrameManager.java#L151-L158 | train |
BrunoEberhard/minimal-j | src/main/java/org/minimalj/frontend/impl/swing/FrameManager.java | FrameManager.closeAllWindows | private boolean closeAllWindows(SwingFrame navigationFrameView) {
// Die umgekehrte Reihenfolge fühlt sich beim Schliessen natürlicher an
for (int i = navigationFrames.size()-1; i>= 0; i--) {
SwingFrame frameView = navigationFrames.get(i);
if (!frameView.tryToCloseWindow()) return false;
removeNavigationFrameView(frameView);
}
return true;
} | java | private boolean closeAllWindows(SwingFrame navigationFrameView) {
// Die umgekehrte Reihenfolge fühlt sich beim Schliessen natürlicher an
for (int i = navigationFrames.size()-1; i>= 0; i--) {
SwingFrame frameView = navigationFrames.get(i);
if (!frameView.tryToCloseWindow()) return false;
removeNavigationFrameView(frameView);
}
return true;
} | [
"private",
"boolean",
"closeAllWindows",
"(",
"SwingFrame",
"navigationFrameView",
")",
"{",
"// Die umgekehrte Reihenfolge fühlt sich beim Schliessen natürlicher an",
"for",
"(",
"int",
"i",
"=",
"navigationFrames",
".",
"size",
"(",
")",
"-",
"1",
";",
"i",
">=",
"0",
";",
"i",
"--",
")",
"{",
"SwingFrame",
"frameView",
"=",
"navigationFrames",
".",
"get",
"(",
"i",
")",
";",
"if",
"(",
"!",
"frameView",
".",
"tryToCloseWindow",
"(",
")",
")",
"return",
"false",
";",
"removeNavigationFrameView",
"(",
"frameView",
")",
";",
"}",
"return",
"true",
";",
"}"
] | Tries to close all windows. Stops at first failed attempt.
@param navigationFrameView used as parent of question dialogs
@return true if all windows are closed | [
"Tries",
"to",
"close",
"all",
"windows",
".",
"Stops",
"at",
"first",
"failed",
"attempt",
"."
] | f7c5461b2b47a10b383aee1e2f1f150f6773703b | https://github.com/BrunoEberhard/minimal-j/blob/f7c5461b2b47a10b383aee1e2f1f150f6773703b/src/main/java/org/minimalj/frontend/impl/swing/FrameManager.java#L166-L174 | train |
BrunoEberhard/minimal-j | src/main/java/org/minimalj/frontend/impl/swing/FrameManager.java | FrameManager.removeNavigationFrameView | private void removeNavigationFrameView(SwingFrame frameView) {
navigationFrames.remove(frameView);
if (navigationFrames.size() == 0) {
System.exit(0);
}
} | java | private void removeNavigationFrameView(SwingFrame frameView) {
navigationFrames.remove(frameView);
if (navigationFrames.size() == 0) {
System.exit(0);
}
} | [
"private",
"void",
"removeNavigationFrameView",
"(",
"SwingFrame",
"frameView",
")",
"{",
"navigationFrames",
".",
"remove",
"(",
"frameView",
")",
";",
"if",
"(",
"navigationFrames",
".",
"size",
"(",
")",
"==",
"0",
")",
"{",
"System",
".",
"exit",
"(",
"0",
")",
";",
"}",
"}"
] | Removes a frameView from the list and exits if it was the last
@param frameView NavigationFrameView to remove from the list | [
"Removes",
"a",
"frameView",
"from",
"the",
"list",
"and",
"exits",
"if",
"it",
"was",
"the",
"last"
] | f7c5461b2b47a10b383aee1e2f1f150f6773703b | https://github.com/BrunoEberhard/minimal-j/blob/f7c5461b2b47a10b383aee1e2f1f150f6773703b/src/main/java/org/minimalj/frontend/impl/swing/FrameManager.java#L181-L186 | train |
bazaarvoice/curator-extensions | recipes/src/main/java/com/bazaarvoice/curator/recipes/leader/LeaderService.java | LeaderService.sleep | private synchronized void sleep(long waitNanos) throws InterruptedException {
while (waitNanos > 0 && isRunning()) {
long start = System.nanoTime();
TimeUnit.NANOSECONDS.timedWait(this, waitNanos);
waitNanos -= System.nanoTime() - start;
}
} | java | private synchronized void sleep(long waitNanos) throws InterruptedException {
while (waitNanos > 0 && isRunning()) {
long start = System.nanoTime();
TimeUnit.NANOSECONDS.timedWait(this, waitNanos);
waitNanos -= System.nanoTime() - start;
}
} | [
"private",
"synchronized",
"void",
"sleep",
"(",
"long",
"waitNanos",
")",
"throws",
"InterruptedException",
"{",
"while",
"(",
"waitNanos",
">",
"0",
"&&",
"isRunning",
"(",
")",
")",
"{",
"long",
"start",
"=",
"System",
".",
"nanoTime",
"(",
")",
";",
"TimeUnit",
".",
"NANOSECONDS",
".",
"timedWait",
"(",
"this",
",",
"waitNanos",
")",
";",
"waitNanos",
"-=",
"System",
".",
"nanoTime",
"(",
")",
"-",
"start",
";",
"}",
"}"
] | Wait for the specified amount of time or until this service is stopped, whichever comes first. | [
"Wait",
"for",
"the",
"specified",
"amount",
"of",
"time",
"or",
"until",
"this",
"service",
"is",
"stopped",
"whichever",
"comes",
"first",
"."
] | eb1e1b478f1ae6aed602bb5d5cb481277203004e | https://github.com/bazaarvoice/curator-extensions/blob/eb1e1b478f1ae6aed602bb5d5cb481277203004e/recipes/src/main/java/com/bazaarvoice/curator/recipes/leader/LeaderService.java#L285-L291 | train |
openengsb/openengsb | components/edb/src/main/java/org/openengsb/core/edb/jpa/internal/ObjectDiff.java | ObjectDiff.loadKeyList | private List<String> loadKeyList() {
Set<String> keySet = new HashSet<String>();
for (EDBObjectEntry entry : startState.values()) {
keySet.add(entry.getKey());
}
for (EDBObjectEntry entry : endState.values()) {
keySet.add(entry.getKey());
}
return new ArrayList<String>(keySet);
} | java | private List<String> loadKeyList() {
Set<String> keySet = new HashSet<String>();
for (EDBObjectEntry entry : startState.values()) {
keySet.add(entry.getKey());
}
for (EDBObjectEntry entry : endState.values()) {
keySet.add(entry.getKey());
}
return new ArrayList<String>(keySet);
} | [
"private",
"List",
"<",
"String",
">",
"loadKeyList",
"(",
")",
"{",
"Set",
"<",
"String",
">",
"keySet",
"=",
"new",
"HashSet",
"<",
"String",
">",
"(",
")",
";",
"for",
"(",
"EDBObjectEntry",
"entry",
":",
"startState",
".",
"values",
"(",
")",
")",
"{",
"keySet",
".",
"add",
"(",
"entry",
".",
"getKey",
"(",
")",
")",
";",
"}",
"for",
"(",
"EDBObjectEntry",
"entry",
":",
"endState",
".",
"values",
"(",
")",
")",
"{",
"keySet",
".",
"add",
"(",
"entry",
".",
"getKey",
"(",
")",
")",
";",
"}",
"return",
"new",
"ArrayList",
"<",
"String",
">",
"(",
"keySet",
")",
";",
"}"
] | loads all keys from the start state and the end state | [
"loads",
"all",
"keys",
"from",
"the",
"start",
"state",
"and",
"the",
"end",
"state"
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/edb/src/main/java/org/openengsb/core/edb/jpa/internal/ObjectDiff.java#L90-L99 | train |
matthewhorridge/owlexplanation | src/main/java/org/semanticweb/owl/explanation/impl/laconic/OPlusGenerator.java | OPlusGenerator.getSameSourceAxioms | public Set<OWLAxiom> getSameSourceAxioms(OWLAxiom axiom, Set<OWLAxiom> toSearch) {
Set<OWLAxiom> axiomSources = axiom2SourceMap.get(axiom);
if(axiomSources == null) {
return Collections.emptySet();
}
Set<OWLAxiom> result = new HashSet<OWLAxiom>();
for(OWLAxiom ax : toSearch) {
Set<OWLAxiom> sources = axiom2SourceMap.get(ax);
if(sources != null) {
for(OWLAxiom axiomSourceAxiom : axiomSources) {
if(sources.contains(axiomSourceAxiom)) {
result.add(ax);
break;
}
}
}
}
return result;
} | java | public Set<OWLAxiom> getSameSourceAxioms(OWLAxiom axiom, Set<OWLAxiom> toSearch) {
Set<OWLAxiom> axiomSources = axiom2SourceMap.get(axiom);
if(axiomSources == null) {
return Collections.emptySet();
}
Set<OWLAxiom> result = new HashSet<OWLAxiom>();
for(OWLAxiom ax : toSearch) {
Set<OWLAxiom> sources = axiom2SourceMap.get(ax);
if(sources != null) {
for(OWLAxiom axiomSourceAxiom : axiomSources) {
if(sources.contains(axiomSourceAxiom)) {
result.add(ax);
break;
}
}
}
}
return result;
} | [
"public",
"Set",
"<",
"OWLAxiom",
">",
"getSameSourceAxioms",
"(",
"OWLAxiom",
"axiom",
",",
"Set",
"<",
"OWLAxiom",
">",
"toSearch",
")",
"{",
"Set",
"<",
"OWLAxiom",
">",
"axiomSources",
"=",
"axiom2SourceMap",
".",
"get",
"(",
"axiom",
")",
";",
"if",
"(",
"axiomSources",
"==",
"null",
")",
"{",
"return",
"Collections",
".",
"emptySet",
"(",
")",
";",
"}",
"Set",
"<",
"OWLAxiom",
">",
"result",
"=",
"new",
"HashSet",
"<",
"OWLAxiom",
">",
"(",
")",
";",
"for",
"(",
"OWLAxiom",
"ax",
":",
"toSearch",
")",
"{",
"Set",
"<",
"OWLAxiom",
">",
"sources",
"=",
"axiom2SourceMap",
".",
"get",
"(",
"ax",
")",
";",
"if",
"(",
"sources",
"!=",
"null",
")",
"{",
"for",
"(",
"OWLAxiom",
"axiomSourceAxiom",
":",
"axiomSources",
")",
"{",
"if",
"(",
"sources",
".",
"contains",
"(",
"axiomSourceAxiom",
")",
")",
"{",
"result",
".",
"add",
"(",
"ax",
")",
";",
"break",
";",
"}",
"}",
"}",
"}",
"return",
"result",
";",
"}"
] | Gets axioms that have the same source axioms as the specified axiom.
@param axiom The axiom for which axioms with the same sources will be retrieved.
@param toSearch The set of axioms to seach for the same sources. If <code>toSearch</code>
contains <code>axiom</code> then <code>axiom</code> will simply be ignored.
@return The axioms that have the same sources as <code>axiom</code>. This set will not contain
<code>axiom</code>. | [
"Gets",
"axioms",
"that",
"have",
"the",
"same",
"source",
"axioms",
"as",
"the",
"specified",
"axiom",
"."
] | 439c5ca67835f5e421adde725e4e8a3bcd760ac8 | https://github.com/matthewhorridge/owlexplanation/blob/439c5ca67835f5e421adde725e4e8a3bcd760ac8/src/main/java/org/semanticweb/owl/explanation/impl/laconic/OPlusGenerator.java#L126-L144 | train |
FedericoPecora/meta-csp-framework | src/main/java/org/metacsp/time/APSPSolver.java | APSPSolver.tpCreate | private int[] tpCreate(int n) {
if (n > MAX_TPS) return null;
int[] ret = new int[n];
for (int i = 0; i < n; i++) ret[i] = tpCreate();
return ret;
} | java | private int[] tpCreate(int n) {
if (n > MAX_TPS) return null;
int[] ret = new int[n];
for (int i = 0; i < n; i++) ret[i] = tpCreate();
return ret;
} | [
"private",
"int",
"[",
"]",
"tpCreate",
"(",
"int",
"n",
")",
"{",
"if",
"(",
"n",
">",
"MAX_TPS",
")",
"return",
"null",
";",
"int",
"[",
"]",
"ret",
"=",
"new",
"int",
"[",
"n",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"n",
";",
"i",
"++",
")",
"ret",
"[",
"i",
"]",
"=",
"tpCreate",
"(",
")",
";",
"return",
"ret",
";",
"}"
] | Batch TP creation | [
"Batch",
"TP",
"creation"
] | 42aaef2e2b76d0f738427f0dd9653c4f62b40517 | https://github.com/FedericoPecora/meta-csp-framework/blob/42aaef2e2b76d0f738427f0dd9653c4f62b40517/src/main/java/org/metacsp/time/APSPSolver.java#L266-L271 | train |
FedericoPecora/meta-csp-framework | src/main/java/org/metacsp/time/APSPSolver.java | APSPSolver.tpDelete | private void tpDelete(int[] IDtimePoint) {
logger.finest("Deleting " + IDtimePoint.length + " TP");
for (int i = 0; i < IDtimePoint.length; i++) {
tPoints[IDtimePoint[i]].setUsed(false);
if (IDtimePoint[i] == MAX_USED) MAX_USED--;
SimpleDistanceConstraint conO = new SimpleDistanceConstraint();
SimpleDistanceConstraint conH = new SimpleDistanceConstraint();
conO.setFrom(this.getVariable(0));
conO.setTo(this.getVariable(IDtimePoint[i]));
conH.setFrom(this.getVariable(IDtimePoint[i]));
conH.setTo(this.getVariable(1));
conO.setMinimum(0);
conO.setMaximum(H-O);
conH.setMinimum(0);
conH.setMaximum(H-O);
conO.addInterval(new Bounds(0,H-O));
conH.addInterval(new Bounds(0,H-O));
//[lb,ub] = [-di0,d0i]
tPoints[IDtimePoint[i]].setLowerBound(O);
tPoints[IDtimePoint[i]].setUpperBound(H);
tPoints[0].setOut(IDtimePoint[i],conO);
tPoints[IDtimePoint[i]].setOut(1,conH);
}
fromScratchDistanceMatrixComputation();
} | java | private void tpDelete(int[] IDtimePoint) {
logger.finest("Deleting " + IDtimePoint.length + " TP");
for (int i = 0; i < IDtimePoint.length; i++) {
tPoints[IDtimePoint[i]].setUsed(false);
if (IDtimePoint[i] == MAX_USED) MAX_USED--;
SimpleDistanceConstraint conO = new SimpleDistanceConstraint();
SimpleDistanceConstraint conH = new SimpleDistanceConstraint();
conO.setFrom(this.getVariable(0));
conO.setTo(this.getVariable(IDtimePoint[i]));
conH.setFrom(this.getVariable(IDtimePoint[i]));
conH.setTo(this.getVariable(1));
conO.setMinimum(0);
conO.setMaximum(H-O);
conH.setMinimum(0);
conH.setMaximum(H-O);
conO.addInterval(new Bounds(0,H-O));
conH.addInterval(new Bounds(0,H-O));
//[lb,ub] = [-di0,d0i]
tPoints[IDtimePoint[i]].setLowerBound(O);
tPoints[IDtimePoint[i]].setUpperBound(H);
tPoints[0].setOut(IDtimePoint[i],conO);
tPoints[IDtimePoint[i]].setOut(1,conH);
}
fromScratchDistanceMatrixComputation();
} | [
"private",
"void",
"tpDelete",
"(",
"int",
"[",
"]",
"IDtimePoint",
")",
"{",
"logger",
".",
"finest",
"(",
"\"Deleting \"",
"+",
"IDtimePoint",
".",
"length",
"+",
"\" TP\"",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"IDtimePoint",
".",
"length",
";",
"i",
"++",
")",
"{",
"tPoints",
"[",
"IDtimePoint",
"[",
"i",
"]",
"]",
".",
"setUsed",
"(",
"false",
")",
";",
"if",
"(",
"IDtimePoint",
"[",
"i",
"]",
"==",
"MAX_USED",
")",
"MAX_USED",
"--",
";",
"SimpleDistanceConstraint",
"conO",
"=",
"new",
"SimpleDistanceConstraint",
"(",
")",
";",
"SimpleDistanceConstraint",
"conH",
"=",
"new",
"SimpleDistanceConstraint",
"(",
")",
";",
"conO",
".",
"setFrom",
"(",
"this",
".",
"getVariable",
"(",
"0",
")",
")",
";",
"conO",
".",
"setTo",
"(",
"this",
".",
"getVariable",
"(",
"IDtimePoint",
"[",
"i",
"]",
")",
")",
";",
"conH",
".",
"setFrom",
"(",
"this",
".",
"getVariable",
"(",
"IDtimePoint",
"[",
"i",
"]",
")",
")",
";",
"conH",
".",
"setTo",
"(",
"this",
".",
"getVariable",
"(",
"1",
")",
")",
";",
"conO",
".",
"setMinimum",
"(",
"0",
")",
";",
"conO",
".",
"setMaximum",
"(",
"H",
"-",
"O",
")",
";",
"conH",
".",
"setMinimum",
"(",
"0",
")",
";",
"conH",
".",
"setMaximum",
"(",
"H",
"-",
"O",
")",
";",
"conO",
".",
"addInterval",
"(",
"new",
"Bounds",
"(",
"0",
",",
"H",
"-",
"O",
")",
")",
";",
"conH",
".",
"addInterval",
"(",
"new",
"Bounds",
"(",
"0",
",",
"H",
"-",
"O",
")",
")",
";",
"//[lb,ub] = [-di0,d0i]\r",
"tPoints",
"[",
"IDtimePoint",
"[",
"i",
"]",
"]",
".",
"setLowerBound",
"(",
"O",
")",
";",
"tPoints",
"[",
"IDtimePoint",
"[",
"i",
"]",
"]",
".",
"setUpperBound",
"(",
"H",
")",
";",
"tPoints",
"[",
"0",
"]",
".",
"setOut",
"(",
"IDtimePoint",
"[",
"i",
"]",
",",
"conO",
")",
";",
"tPoints",
"[",
"IDtimePoint",
"[",
"i",
"]",
"]",
".",
"setOut",
"(",
"1",
",",
"conH",
")",
";",
"}",
"fromScratchDistanceMatrixComputation",
"(",
")",
";",
"}"
] | Batch Time point erase | [
"Batch",
"Time",
"point",
"erase"
] | 42aaef2e2b76d0f738427f0dd9653c4f62b40517 | https://github.com/FedericoPecora/meta-csp-framework/blob/42aaef2e2b76d0f738427f0dd9653c4f62b40517/src/main/java/org/metacsp/time/APSPSolver.java#L317-L347 | train |
FedericoPecora/meta-csp-framework | src/main/java/org/metacsp/time/APSPSolver.java | APSPSolver.cDelete | private boolean cDelete(Bounds[] in, int[] from, int[] to, boolean canRestore) throws ConstraintNotFound, MalformedSimpleDistanceConstraint {
for (int i = 0; i < in.length; i++) {
//Conversion
long min = in[i].min;
long max = in[i].max;
if (in[i].max == Long.MAX_VALUE - 1) max = H-O;
if (in[i].min == Long.MIN_VALUE + 1) min = -1 * (H - O);
in[i] = new Bounds(min,max);
SimpleDistanceConstraint con = tPoints[from[i]].getOut(to[i]);
if (con == null) {
throw new ConstraintNotFound(String.format("Interval %s, from %d, to %d", in[i].toString(), from[i], to[i]));
}
if (con.getCounter() == 1) {
if (con.removeInterval(in[i])) tPoints[from[i]].setOut(to[i],null);
else throw new MalformedSimpleDistanceConstraint(con, 1);
}
else if (!con.removeInterval(in[i])) throw new MalformedSimpleDistanceConstraint(con, 2);
}
if (!canRestore) fromScratchDistanceMatrixComputation();
else {
logger.finest("QuickRestoring distance matrix, no propagation");
if (backupDMatrixSimple) restoreDMatrix();
}
for (int j = 0; j < MAX_USED+1; j++)
if (tPoints[j].isUsed() == true) {
tPoints[j].setLowerBound(sum(-distance[j][0],O));
tPoints[j].setUpperBound(sum(distance[0][j],O));
}
return true;
} | java | private boolean cDelete(Bounds[] in, int[] from, int[] to, boolean canRestore) throws ConstraintNotFound, MalformedSimpleDistanceConstraint {
for (int i = 0; i < in.length; i++) {
//Conversion
long min = in[i].min;
long max = in[i].max;
if (in[i].max == Long.MAX_VALUE - 1) max = H-O;
if (in[i].min == Long.MIN_VALUE + 1) min = -1 * (H - O);
in[i] = new Bounds(min,max);
SimpleDistanceConstraint con = tPoints[from[i]].getOut(to[i]);
if (con == null) {
throw new ConstraintNotFound(String.format("Interval %s, from %d, to %d", in[i].toString(), from[i], to[i]));
}
if (con.getCounter() == 1) {
if (con.removeInterval(in[i])) tPoints[from[i]].setOut(to[i],null);
else throw new MalformedSimpleDistanceConstraint(con, 1);
}
else if (!con.removeInterval(in[i])) throw new MalformedSimpleDistanceConstraint(con, 2);
}
if (!canRestore) fromScratchDistanceMatrixComputation();
else {
logger.finest("QuickRestoring distance matrix, no propagation");
if (backupDMatrixSimple) restoreDMatrix();
}
for (int j = 0; j < MAX_USED+1; j++)
if (tPoints[j].isUsed() == true) {
tPoints[j].setLowerBound(sum(-distance[j][0],O));
tPoints[j].setUpperBound(sum(distance[0][j],O));
}
return true;
} | [
"private",
"boolean",
"cDelete",
"(",
"Bounds",
"[",
"]",
"in",
",",
"int",
"[",
"]",
"from",
",",
"int",
"[",
"]",
"to",
",",
"boolean",
"canRestore",
")",
"throws",
"ConstraintNotFound",
",",
"MalformedSimpleDistanceConstraint",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"in",
".",
"length",
";",
"i",
"++",
")",
"{",
"//Conversion\r",
"long",
"min",
"=",
"in",
"[",
"i",
"]",
".",
"min",
";",
"long",
"max",
"=",
"in",
"[",
"i",
"]",
".",
"max",
";",
"if",
"(",
"in",
"[",
"i",
"]",
".",
"max",
"==",
"Long",
".",
"MAX_VALUE",
"-",
"1",
")",
"max",
"=",
"H",
"-",
"O",
";",
"if",
"(",
"in",
"[",
"i",
"]",
".",
"min",
"==",
"Long",
".",
"MIN_VALUE",
"+",
"1",
")",
"min",
"=",
"-",
"1",
"*",
"(",
"H",
"-",
"O",
")",
";",
"in",
"[",
"i",
"]",
"=",
"new",
"Bounds",
"(",
"min",
",",
"max",
")",
";",
"SimpleDistanceConstraint",
"con",
"=",
"tPoints",
"[",
"from",
"[",
"i",
"]",
"]",
".",
"getOut",
"(",
"to",
"[",
"i",
"]",
")",
";",
"if",
"(",
"con",
"==",
"null",
")",
"{",
"throw",
"new",
"ConstraintNotFound",
"(",
"String",
".",
"format",
"(",
"\"Interval %s, from %d, to %d\"",
",",
"in",
"[",
"i",
"]",
".",
"toString",
"(",
")",
",",
"from",
"[",
"i",
"]",
",",
"to",
"[",
"i",
"]",
")",
")",
";",
"}",
"if",
"(",
"con",
".",
"getCounter",
"(",
")",
"==",
"1",
")",
"{",
"if",
"(",
"con",
".",
"removeInterval",
"(",
"in",
"[",
"i",
"]",
")",
")",
"tPoints",
"[",
"from",
"[",
"i",
"]",
"]",
".",
"setOut",
"(",
"to",
"[",
"i",
"]",
",",
"null",
")",
";",
"else",
"throw",
"new",
"MalformedSimpleDistanceConstraint",
"(",
"con",
",",
"1",
")",
";",
"}",
"else",
"if",
"(",
"!",
"con",
".",
"removeInterval",
"(",
"in",
"[",
"i",
"]",
")",
")",
"throw",
"new",
"MalformedSimpleDistanceConstraint",
"(",
"con",
",",
"2",
")",
";",
"}",
"if",
"(",
"!",
"canRestore",
")",
"fromScratchDistanceMatrixComputation",
"(",
")",
";",
"else",
"{",
"logger",
".",
"finest",
"(",
"\"QuickRestoring distance matrix, no propagation\"",
")",
";",
"if",
"(",
"backupDMatrixSimple",
")",
"restoreDMatrix",
"(",
")",
";",
"}",
"for",
"(",
"int",
"j",
"=",
"0",
";",
"j",
"<",
"MAX_USED",
"+",
"1",
";",
"j",
"++",
")",
"if",
"(",
"tPoints",
"[",
"j",
"]",
".",
"isUsed",
"(",
")",
"==",
"true",
")",
"{",
"tPoints",
"[",
"j",
"]",
".",
"setLowerBound",
"(",
"sum",
"(",
"-",
"distance",
"[",
"j",
"]",
"[",
"0",
"]",
",",
"O",
")",
")",
";",
"tPoints",
"[",
"j",
"]",
".",
"setUpperBound",
"(",
"sum",
"(",
"distance",
"[",
"0",
"]",
"[",
"j",
"]",
",",
"O",
")",
")",
";",
"}",
"return",
"true",
";",
"}"
] | throw error in case of parameter inconsistency | [
"throw",
"error",
"in",
"case",
"of",
"parameter",
"inconsistency"
] | 42aaef2e2b76d0f738427f0dd9653c4f62b40517 | https://github.com/FedericoPecora/meta-csp-framework/blob/42aaef2e2b76d0f738427f0dd9653c4f62b40517/src/main/java/org/metacsp/time/APSPSolver.java#L632-L667 | train |
FedericoPecora/meta-csp-framework | src/main/java/org/metacsp/time/APSPSolver.java | APSPSolver.getTimePoint | public TimePoint getTimePoint(int Id) {
if (Id >= MAX_TPS) return null;
if (tPoints[Id] == null) return null;
if (!tPoints[Id].isUsed()) return null;
return tPoints[Id];
} | java | public TimePoint getTimePoint(int Id) {
if (Id >= MAX_TPS) return null;
if (tPoints[Id] == null) return null;
if (!tPoints[Id].isUsed()) return null;
return tPoints[Id];
} | [
"public",
"TimePoint",
"getTimePoint",
"(",
"int",
"Id",
")",
"{",
"if",
"(",
"Id",
">=",
"MAX_TPS",
")",
"return",
"null",
";",
"if",
"(",
"tPoints",
"[",
"Id",
"]",
"==",
"null",
")",
"return",
"null",
";",
"if",
"(",
"!",
"tPoints",
"[",
"Id",
"]",
".",
"isUsed",
"(",
")",
")",
"return",
"null",
";",
"return",
"tPoints",
"[",
"Id",
"]",
";",
"}"
] | Get a timepoint given its ID.
@param Id The ID of the timepoint.
@return The timepoint referenced by passed ID. | [
"Get",
"a",
"timepoint",
"given",
"its",
"ID",
"."
] | 42aaef2e2b76d0f738427f0dd9653c4f62b40517 | https://github.com/FedericoPecora/meta-csp-framework/blob/42aaef2e2b76d0f738427f0dd9653c4f62b40517/src/main/java/org/metacsp/time/APSPSolver.java#L677-L682 | train |
FedericoPecora/meta-csp-framework | src/main/java/org/metacsp/time/APSPSolver.java | APSPSolver.fromScratchDistanceMatrixComputation | private boolean fromScratchDistanceMatrixComputation() {
logger.fine("Propagating (cube) with (#TPs,#cons) = (" + this.MAX_USED + "," + this.theNetwork.getConstraints().length + ") (call num.: " + (++cubePropCount) + ")");
//*
//This code is not tested thoroughly but seems to work
for (int i = 0; i < MAX_USED+1; i++) {
for (int j = i; j < MAX_USED+1; j++) {
if (i != j) {
long dij = H;//APSPSolver.INF;
long dji = H;//APSPSolver.INF;
if(tPoints[i].getOut(j) != null) {
dij = Math.min(dij, +tPoints[i].getOut(j).getMaximum());
dji = Math.min(dji, -tPoints[i].getOut(j).getMinimum());
}
if(tPoints[j].getOut(i) != null) {
dij = Math.min(dij, -tPoints[j].getOut(i).getMinimum());
dji = Math.min(dji, +tPoints[j].getOut(i).getMaximum());
}
if(-dji > +dij) {
return false;
}
distance[i][j] = dij;
distance[j][i] = dji;
}
else distance[i][j] = 0;
}
}
for (int k = 0; k < MAX_USED+1; k++) {
if (tPoints[k].isUsed() == true) {
for (int i = 0; i < MAX_USED+1; i++) {
if (tPoints[i].isUsed() == true) {
for (int j = 0; j < MAX_USED+1; j++) {
if (tPoints[j].isUsed() == true) {
long temp = sum(distance[i][k],distance[k][j]);
if (distance[i][j] > temp)
distance[i][j] = temp;
}
if (i == j && distance[i][j] < 0) return false;
}
}
}
}
}
return true;
} | java | private boolean fromScratchDistanceMatrixComputation() {
logger.fine("Propagating (cube) with (#TPs,#cons) = (" + this.MAX_USED + "," + this.theNetwork.getConstraints().length + ") (call num.: " + (++cubePropCount) + ")");
//*
//This code is not tested thoroughly but seems to work
for (int i = 0; i < MAX_USED+1; i++) {
for (int j = i; j < MAX_USED+1; j++) {
if (i != j) {
long dij = H;//APSPSolver.INF;
long dji = H;//APSPSolver.INF;
if(tPoints[i].getOut(j) != null) {
dij = Math.min(dij, +tPoints[i].getOut(j).getMaximum());
dji = Math.min(dji, -tPoints[i].getOut(j).getMinimum());
}
if(tPoints[j].getOut(i) != null) {
dij = Math.min(dij, -tPoints[j].getOut(i).getMinimum());
dji = Math.min(dji, +tPoints[j].getOut(i).getMaximum());
}
if(-dji > +dij) {
return false;
}
distance[i][j] = dij;
distance[j][i] = dji;
}
else distance[i][j] = 0;
}
}
for (int k = 0; k < MAX_USED+1; k++) {
if (tPoints[k].isUsed() == true) {
for (int i = 0; i < MAX_USED+1; i++) {
if (tPoints[i].isUsed() == true) {
for (int j = 0; j < MAX_USED+1; j++) {
if (tPoints[j].isUsed() == true) {
long temp = sum(distance[i][k],distance[k][j]);
if (distance[i][j] > temp)
distance[i][j] = temp;
}
if (i == j && distance[i][j] < 0) return false;
}
}
}
}
}
return true;
} | [
"private",
"boolean",
"fromScratchDistanceMatrixComputation",
"(",
")",
"{",
"logger",
".",
"fine",
"(",
"\"Propagating (cube) with (#TPs,#cons) = (\"",
"+",
"this",
".",
"MAX_USED",
"+",
"\",\"",
"+",
"this",
".",
"theNetwork",
".",
"getConstraints",
"(",
")",
".",
"length",
"+",
"\") (call num.: \"",
"+",
"(",
"++",
"cubePropCount",
")",
"+",
"\")\"",
")",
";",
"//*\r",
"//This code is not tested thoroughly but seems to work\r",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"MAX_USED",
"+",
"1",
";",
"i",
"++",
")",
"{",
"for",
"(",
"int",
"j",
"=",
"i",
";",
"j",
"<",
"MAX_USED",
"+",
"1",
";",
"j",
"++",
")",
"{",
"if",
"(",
"i",
"!=",
"j",
")",
"{",
"long",
"dij",
"=",
"H",
";",
"//APSPSolver.INF;\r",
"long",
"dji",
"=",
"H",
";",
"//APSPSolver.INF;\r",
"if",
"(",
"tPoints",
"[",
"i",
"]",
".",
"getOut",
"(",
"j",
")",
"!=",
"null",
")",
"{",
"dij",
"=",
"Math",
".",
"min",
"(",
"dij",
",",
"+",
"tPoints",
"[",
"i",
"]",
".",
"getOut",
"(",
"j",
")",
".",
"getMaximum",
"(",
")",
")",
";",
"dji",
"=",
"Math",
".",
"min",
"(",
"dji",
",",
"-",
"tPoints",
"[",
"i",
"]",
".",
"getOut",
"(",
"j",
")",
".",
"getMinimum",
"(",
")",
")",
";",
"}",
"if",
"(",
"tPoints",
"[",
"j",
"]",
".",
"getOut",
"(",
"i",
")",
"!=",
"null",
")",
"{",
"dij",
"=",
"Math",
".",
"min",
"(",
"dij",
",",
"-",
"tPoints",
"[",
"j",
"]",
".",
"getOut",
"(",
"i",
")",
".",
"getMinimum",
"(",
")",
")",
";",
"dji",
"=",
"Math",
".",
"min",
"(",
"dji",
",",
"+",
"tPoints",
"[",
"j",
"]",
".",
"getOut",
"(",
"i",
")",
".",
"getMaximum",
"(",
")",
")",
";",
"}",
"if",
"(",
"-",
"dji",
">",
"+",
"dij",
")",
"{",
"return",
"false",
";",
"}",
"distance",
"[",
"i",
"]",
"[",
"j",
"]",
"=",
"dij",
";",
"distance",
"[",
"j",
"]",
"[",
"i",
"]",
"=",
"dji",
";",
"}",
"else",
"distance",
"[",
"i",
"]",
"[",
"j",
"]",
"=",
"0",
";",
"}",
"}",
"for",
"(",
"int",
"k",
"=",
"0",
";",
"k",
"<",
"MAX_USED",
"+",
"1",
";",
"k",
"++",
")",
"{",
"if",
"(",
"tPoints",
"[",
"k",
"]",
".",
"isUsed",
"(",
")",
"==",
"true",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"MAX_USED",
"+",
"1",
";",
"i",
"++",
")",
"{",
"if",
"(",
"tPoints",
"[",
"i",
"]",
".",
"isUsed",
"(",
")",
"==",
"true",
")",
"{",
"for",
"(",
"int",
"j",
"=",
"0",
";",
"j",
"<",
"MAX_USED",
"+",
"1",
";",
"j",
"++",
")",
"{",
"if",
"(",
"tPoints",
"[",
"j",
"]",
".",
"isUsed",
"(",
")",
"==",
"true",
")",
"{",
"long",
"temp",
"=",
"sum",
"(",
"distance",
"[",
"i",
"]",
"[",
"k",
"]",
",",
"distance",
"[",
"k",
"]",
"[",
"j",
"]",
")",
";",
"if",
"(",
"distance",
"[",
"i",
"]",
"[",
"j",
"]",
">",
"temp",
")",
"distance",
"[",
"i",
"]",
"[",
"j",
"]",
"=",
"temp",
";",
"}",
"if",
"(",
"i",
"==",
"j",
"&&",
"distance",
"[",
"i",
"]",
"[",
"j",
"]",
"<",
"0",
")",
"return",
"false",
";",
"}",
"}",
"}",
"}",
"}",
"return",
"true",
";",
"}"
] | "from scratch" re-computation | [
"from",
"scratch",
"re",
"-",
"computation"
] | 42aaef2e2b76d0f738427f0dd9653c4f62b40517 | https://github.com/FedericoPecora/meta-csp-framework/blob/42aaef2e2b76d0f738427f0dd9653c4f62b40517/src/main/java/org/metacsp/time/APSPSolver.java#L704-L753 | train |
FedericoPecora/meta-csp-framework | src/main/java/org/metacsp/time/APSPSolver.java | APSPSolver.incrementalDistanceMatrixComputation | private boolean incrementalDistanceMatrixComputation(int from,int to,Bounds i) {
logger.fine("Propagating (quad) with (#TPs,#cons) = (" + this.MAX_USED + "," + this.theNetwork.getConstraints().length + ") (call num.: " + (++quadPropCount) + ")");
if (distance[to][from] != APSPSolver.INF && sum(i.max,distance[to][from]) < 0) return false;
if (distance[from][to] != APSPSolver.INF && sum(-i.min,distance[from][to]) < 0) return false;
// System.out.println("a)" + sum(i.max,distance[to][from]));
// System.out.println("b)" + sum(-i.min,distance[from][to]));
long sum1;
long sum2;
long sum3;
long sum4;
long temp;
for (int u = 0; u < MAX_USED+1; u++) {
if (tPoints[u].isUsed()) {
for (int v = 0; v < MAX_USED+1;v++) {
if (tPoints[v].isUsed()) {
//min{distance[u][v];(distance[u][from]+i.max+distance[to][v]);(distance[u][to]-i.minl+distance[from][v])}
sum1 = sum(distance[u][to],-i.min);
sum2 = sum(sum1,distance[from][v]);
sum3 = sum(distance[u][from],i.max);
sum4 = sum(sum3,distance[to][v]);
temp = Math.min(sum2,sum4);
if (distance[u][v] > temp) {
//long oldD = distance[u][v];
distance[u][v] = temp;
if (u == v && distance[u][v] != 0) {
//logger.info("==================> Updated distance[" + u + "][" + v + "] from " + oldD + " to " + temp);
//throw new Error("Found negative cycle in incremental propagation while adding (from,to,i) (" + from + "," + to + "," + i + ")");
return false;
}
}
}
}
}
}
return true;
} | java | private boolean incrementalDistanceMatrixComputation(int from,int to,Bounds i) {
logger.fine("Propagating (quad) with (#TPs,#cons) = (" + this.MAX_USED + "," + this.theNetwork.getConstraints().length + ") (call num.: " + (++quadPropCount) + ")");
if (distance[to][from] != APSPSolver.INF && sum(i.max,distance[to][from]) < 0) return false;
if (distance[from][to] != APSPSolver.INF && sum(-i.min,distance[from][to]) < 0) return false;
// System.out.println("a)" + sum(i.max,distance[to][from]));
// System.out.println("b)" + sum(-i.min,distance[from][to]));
long sum1;
long sum2;
long sum3;
long sum4;
long temp;
for (int u = 0; u < MAX_USED+1; u++) {
if (tPoints[u].isUsed()) {
for (int v = 0; v < MAX_USED+1;v++) {
if (tPoints[v].isUsed()) {
//min{distance[u][v];(distance[u][from]+i.max+distance[to][v]);(distance[u][to]-i.minl+distance[from][v])}
sum1 = sum(distance[u][to],-i.min);
sum2 = sum(sum1,distance[from][v]);
sum3 = sum(distance[u][from],i.max);
sum4 = sum(sum3,distance[to][v]);
temp = Math.min(sum2,sum4);
if (distance[u][v] > temp) {
//long oldD = distance[u][v];
distance[u][v] = temp;
if (u == v && distance[u][v] != 0) {
//logger.info("==================> Updated distance[" + u + "][" + v + "] from " + oldD + " to " + temp);
//throw new Error("Found negative cycle in incremental propagation while adding (from,to,i) (" + from + "," + to + "," + i + ")");
return false;
}
}
}
}
}
}
return true;
} | [
"private",
"boolean",
"incrementalDistanceMatrixComputation",
"(",
"int",
"from",
",",
"int",
"to",
",",
"Bounds",
"i",
")",
"{",
"logger",
".",
"fine",
"(",
"\"Propagating (quad) with (#TPs,#cons) = (\"",
"+",
"this",
".",
"MAX_USED",
"+",
"\",\"",
"+",
"this",
".",
"theNetwork",
".",
"getConstraints",
"(",
")",
".",
"length",
"+",
"\") (call num.: \"",
"+",
"(",
"++",
"quadPropCount",
")",
"+",
"\")\"",
")",
";",
"if",
"(",
"distance",
"[",
"to",
"]",
"[",
"from",
"]",
"!=",
"APSPSolver",
".",
"INF",
"&&",
"sum",
"(",
"i",
".",
"max",
",",
"distance",
"[",
"to",
"]",
"[",
"from",
"]",
")",
"<",
"0",
")",
"return",
"false",
";",
"if",
"(",
"distance",
"[",
"from",
"]",
"[",
"to",
"]",
"!=",
"APSPSolver",
".",
"INF",
"&&",
"sum",
"(",
"-",
"i",
".",
"min",
",",
"distance",
"[",
"from",
"]",
"[",
"to",
"]",
")",
"<",
"0",
")",
"return",
"false",
";",
"//\t\tSystem.out.println(\"a)\" + sum(i.max,distance[to][from]));\r",
"//\t\tSystem.out.println(\"b)\" + sum(-i.min,distance[from][to]));\r",
"long",
"sum1",
";",
"long",
"sum2",
";",
"long",
"sum3",
";",
"long",
"sum4",
";",
"long",
"temp",
";",
"for",
"(",
"int",
"u",
"=",
"0",
";",
"u",
"<",
"MAX_USED",
"+",
"1",
";",
"u",
"++",
")",
"{",
"if",
"(",
"tPoints",
"[",
"u",
"]",
".",
"isUsed",
"(",
")",
")",
"{",
"for",
"(",
"int",
"v",
"=",
"0",
";",
"v",
"<",
"MAX_USED",
"+",
"1",
";",
"v",
"++",
")",
"{",
"if",
"(",
"tPoints",
"[",
"v",
"]",
".",
"isUsed",
"(",
")",
")",
"{",
"//min{distance[u][v];(distance[u][from]+i.max+distance[to][v]);(distance[u][to]-i.minl+distance[from][v])}\r",
"sum1",
"=",
"sum",
"(",
"distance",
"[",
"u",
"]",
"[",
"to",
"]",
",",
"-",
"i",
".",
"min",
")",
";",
"sum2",
"=",
"sum",
"(",
"sum1",
",",
"distance",
"[",
"from",
"]",
"[",
"v",
"]",
")",
";",
"sum3",
"=",
"sum",
"(",
"distance",
"[",
"u",
"]",
"[",
"from",
"]",
",",
"i",
".",
"max",
")",
";",
"sum4",
"=",
"sum",
"(",
"sum3",
",",
"distance",
"[",
"to",
"]",
"[",
"v",
"]",
")",
";",
"temp",
"=",
"Math",
".",
"min",
"(",
"sum2",
",",
"sum4",
")",
";",
"if",
"(",
"distance",
"[",
"u",
"]",
"[",
"v",
"]",
">",
"temp",
")",
"{",
"//long oldD = distance[u][v];\r",
"distance",
"[",
"u",
"]",
"[",
"v",
"]",
"=",
"temp",
";",
"if",
"(",
"u",
"==",
"v",
"&&",
"distance",
"[",
"u",
"]",
"[",
"v",
"]",
"!=",
"0",
")",
"{",
"//logger.info(\"==================> Updated distance[\" + u + \"][\" + v + \"] from \" + oldD + \" to \" + temp);\r",
"//throw new Error(\"Found negative cycle in incremental propagation while adding (from,to,i) (\" + from + \",\" + to + \",\" + i + \")\");\r",
"return",
"false",
";",
"}",
"}",
"}",
"}",
"}",
"}",
"return",
"true",
";",
"}"
] | Gd graph propagation function | [
"Gd",
"graph",
"propagation",
"function"
] | 42aaef2e2b76d0f738427f0dd9653c4f62b40517 | https://github.com/FedericoPecora/meta-csp-framework/blob/42aaef2e2b76d0f738427f0dd9653c4f62b40517/src/main/java/org/metacsp/time/APSPSolver.java#L756-L796 | train |
FedericoPecora/meta-csp-framework | src/main/java/org/metacsp/time/APSPSolver.java | APSPSolver.changeHorizon | public boolean changeHorizon(long val)
{
this.removeConstraint(horizonConstraint);
SimpleDistanceConstraint sdc = new SimpleDistanceConstraint();
sdc.setFrom(this.getVariable(0));
sdc.setTo(this.getVariable(1));
sdc.setMinimum(val);
sdc.setMaximum(val);
if (this.addConstraint(sdc)) {
this.H = val;
horizonConstraint = sdc;
return true;
}
return false;
} | java | public boolean changeHorizon(long val)
{
this.removeConstraint(horizonConstraint);
SimpleDistanceConstraint sdc = new SimpleDistanceConstraint();
sdc.setFrom(this.getVariable(0));
sdc.setTo(this.getVariable(1));
sdc.setMinimum(val);
sdc.setMaximum(val);
if (this.addConstraint(sdc)) {
this.H = val;
horizonConstraint = sdc;
return true;
}
return false;
} | [
"public",
"boolean",
"changeHorizon",
"(",
"long",
"val",
")",
"{",
"this",
".",
"removeConstraint",
"(",
"horizonConstraint",
")",
";",
"SimpleDistanceConstraint",
"sdc",
"=",
"new",
"SimpleDistanceConstraint",
"(",
")",
";",
"sdc",
".",
"setFrom",
"(",
"this",
".",
"getVariable",
"(",
"0",
")",
")",
";",
"sdc",
".",
"setTo",
"(",
"this",
".",
"getVariable",
"(",
"1",
")",
")",
";",
"sdc",
".",
"setMinimum",
"(",
"val",
")",
";",
"sdc",
".",
"setMaximum",
"(",
"val",
")",
";",
"if",
"(",
"this",
".",
"addConstraint",
"(",
"sdc",
")",
")",
"{",
"this",
".",
"H",
"=",
"val",
";",
"horizonConstraint",
"=",
"sdc",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}"
] | Set a new horizon for this network.
@param val The new horizon.
@return {@code True} If the operation succeeded, {@code False} otherwise. | [
"Set",
"a",
"new",
"horizon",
"for",
"this",
"network",
"."
] | 42aaef2e2b76d0f738427f0dd9653c4f62b40517 | https://github.com/FedericoPecora/meta-csp-framework/blob/42aaef2e2b76d0f738427f0dd9653c4f62b40517/src/main/java/org/metacsp/time/APSPSolver.java#L974-L988 | train |
openengsb/openengsb | components/common/src/main/java/org/openengsb/core/common/remote/FilterChainFactory.java | FilterChainFactory.create | public FilterChain create() throws FilterConfigurationException {
Preconditions.checkState(filters != null, "list of filters must be set");
Preconditions.checkState(inputType != null, "inputType must be set");
Preconditions.checkState(outputType != null, "outputType must be set");
Preconditions.checkState(filters.size() > 0, "need at least one filter");
validateFiltersList();
Iterator<Object> iterator = filters.iterator();
FilterChainElement firstInstance = getInstanceFromListElement(iterator.next());
if (!firstInstance.getSupportedInputType().isAssignableFrom(inputType)
|| !firstInstance.getSupportedOutputType().isAssignableFrom(outputType)) {
throw new FilterConfigurationException(String.format(
"incompatible Filtertype (%s) should be (%s->%s) - is (%s->%s)",
firstInstance.getClass(), inputType, outputType, firstInstance.getSupportedInputType(),
firstInstance.getSupportedOutputType()));
}
FilterChainElement current = firstInstance;
while (iterator.hasNext()) {
Object next = iterator.next();
FilterChainElement nextFilterElement = getInstanceFromListElement(next);
if (nextFilterElement == null) {
current.setNext((FilterAction) next);
break;
}
current.setNext(nextFilterElement);
current = nextFilterElement;
}
return new FilterChain(firstInstance);
} | java | public FilterChain create() throws FilterConfigurationException {
Preconditions.checkState(filters != null, "list of filters must be set");
Preconditions.checkState(inputType != null, "inputType must be set");
Preconditions.checkState(outputType != null, "outputType must be set");
Preconditions.checkState(filters.size() > 0, "need at least one filter");
validateFiltersList();
Iterator<Object> iterator = filters.iterator();
FilterChainElement firstInstance = getInstanceFromListElement(iterator.next());
if (!firstInstance.getSupportedInputType().isAssignableFrom(inputType)
|| !firstInstance.getSupportedOutputType().isAssignableFrom(outputType)) {
throw new FilterConfigurationException(String.format(
"incompatible Filtertype (%s) should be (%s->%s) - is (%s->%s)",
firstInstance.getClass(), inputType, outputType, firstInstance.getSupportedInputType(),
firstInstance.getSupportedOutputType()));
}
FilterChainElement current = firstInstance;
while (iterator.hasNext()) {
Object next = iterator.next();
FilterChainElement nextFilterElement = getInstanceFromListElement(next);
if (nextFilterElement == null) {
current.setNext((FilterAction) next);
break;
}
current.setNext(nextFilterElement);
current = nextFilterElement;
}
return new FilterChain(firstInstance);
} | [
"public",
"FilterChain",
"create",
"(",
")",
"throws",
"FilterConfigurationException",
"{",
"Preconditions",
".",
"checkState",
"(",
"filters",
"!=",
"null",
",",
"\"list of filters must be set\"",
")",
";",
"Preconditions",
".",
"checkState",
"(",
"inputType",
"!=",
"null",
",",
"\"inputType must be set\"",
")",
";",
"Preconditions",
".",
"checkState",
"(",
"outputType",
"!=",
"null",
",",
"\"outputType must be set\"",
")",
";",
"Preconditions",
".",
"checkState",
"(",
"filters",
".",
"size",
"(",
")",
">",
"0",
",",
"\"need at least one filter\"",
")",
";",
"validateFiltersList",
"(",
")",
";",
"Iterator",
"<",
"Object",
">",
"iterator",
"=",
"filters",
".",
"iterator",
"(",
")",
";",
"FilterChainElement",
"firstInstance",
"=",
"getInstanceFromListElement",
"(",
"iterator",
".",
"next",
"(",
")",
")",
";",
"if",
"(",
"!",
"firstInstance",
".",
"getSupportedInputType",
"(",
")",
".",
"isAssignableFrom",
"(",
"inputType",
")",
"||",
"!",
"firstInstance",
".",
"getSupportedOutputType",
"(",
")",
".",
"isAssignableFrom",
"(",
"outputType",
")",
")",
"{",
"throw",
"new",
"FilterConfigurationException",
"(",
"String",
".",
"format",
"(",
"\"incompatible Filtertype (%s) should be (%s->%s) - is (%s->%s)\"",
",",
"firstInstance",
".",
"getClass",
"(",
")",
",",
"inputType",
",",
"outputType",
",",
"firstInstance",
".",
"getSupportedInputType",
"(",
")",
",",
"firstInstance",
".",
"getSupportedOutputType",
"(",
")",
")",
")",
";",
"}",
"FilterChainElement",
"current",
"=",
"firstInstance",
";",
"while",
"(",
"iterator",
".",
"hasNext",
"(",
")",
")",
"{",
"Object",
"next",
"=",
"iterator",
".",
"next",
"(",
")",
";",
"FilterChainElement",
"nextFilterElement",
"=",
"getInstanceFromListElement",
"(",
"next",
")",
";",
"if",
"(",
"nextFilterElement",
"==",
"null",
")",
"{",
"current",
".",
"setNext",
"(",
"(",
"FilterAction",
")",
"next",
")",
";",
"break",
";",
"}",
"current",
".",
"setNext",
"(",
"nextFilterElement",
")",
";",
"current",
"=",
"nextFilterElement",
";",
"}",
"return",
"new",
"FilterChain",
"(",
"firstInstance",
")",
";",
"}"
] | The filters-list must be set. If the last-element is not set, the last element of the filters-list will be used.
@throws FilterConfigurationException if the filters in the filter-list are not compatible with each other | [
"The",
"filters",
"-",
"list",
"must",
"be",
"set",
".",
"If",
"the",
"last",
"-",
"element",
"is",
"not",
"set",
"the",
"last",
"element",
"of",
"the",
"filters",
"-",
"list",
"will",
"be",
"used",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/common/src/main/java/org/openengsb/core/common/remote/FilterChainFactory.java#L45-L75 | train |
BrunoEberhard/minimal-j | src/main/java/org/minimalj/util/DateUtils.java | DateUtils.parseCH | public static String parseCH(String inputText, boolean partialAllowed) {
if (StringUtils.isEmpty(inputText)) return null;
String text = cutNonDigitsAtBegin(inputText);
if (StringUtils.isEmpty(text)) return "";
text = cutNonDigitsAtEnd(text);
if (StringUtils.isEmpty(text)) return "";
// Nun hat der String sicher keinen Punkt mehr am Anfang oder Ende
if (inputText.indexOf(".") > -1) {
return parseCHWithDot(inputText, partialAllowed);
} else {
return parseCHWithoutDot(inputText, partialAllowed);
}
} | java | public static String parseCH(String inputText, boolean partialAllowed) {
if (StringUtils.isEmpty(inputText)) return null;
String text = cutNonDigitsAtBegin(inputText);
if (StringUtils.isEmpty(text)) return "";
text = cutNonDigitsAtEnd(text);
if (StringUtils.isEmpty(text)) return "";
// Nun hat der String sicher keinen Punkt mehr am Anfang oder Ende
if (inputText.indexOf(".") > -1) {
return parseCHWithDot(inputText, partialAllowed);
} else {
return parseCHWithoutDot(inputText, partialAllowed);
}
} | [
"public",
"static",
"String",
"parseCH",
"(",
"String",
"inputText",
",",
"boolean",
"partialAllowed",
")",
"{",
"if",
"(",
"StringUtils",
".",
"isEmpty",
"(",
"inputText",
")",
")",
"return",
"null",
";",
"String",
"text",
"=",
"cutNonDigitsAtBegin",
"(",
"inputText",
")",
";",
"if",
"(",
"StringUtils",
".",
"isEmpty",
"(",
"text",
")",
")",
"return",
"\"\"",
";",
"text",
"=",
"cutNonDigitsAtEnd",
"(",
"text",
")",
";",
"if",
"(",
"StringUtils",
".",
"isEmpty",
"(",
"text",
")",
")",
"return",
"\"\"",
";",
"// Nun hat der String sicher keinen Punkt mehr am Anfang oder Ende",
"if",
"(",
"inputText",
".",
"indexOf",
"(",
"\".\"",
")",
">",
"-",
"1",
")",
"{",
"return",
"parseCHWithDot",
"(",
"inputText",
",",
"partialAllowed",
")",
";",
"}",
"else",
"{",
"return",
"parseCHWithoutDot",
"(",
"inputText",
",",
"partialAllowed",
")",
";",
"}",
"}"
] | Converts a CH - Date String in a yyyy-mm-dd String. The conversion
is very lenient and tries to convert as long as its somehow clear
what the user may have wanted.
@param inputText The input text. Maybe empty or <code>null</code>.
@param partialAllowed false if the inputText has to be a complete date with month and day
@return null if the input text is empty (<code>null</code> or length 0). An empty String
if the input text doesn't fit a date or a String in format yyyy-mm-dd (or yyyy-mm or even
yyyy if partial allowed) | [
"Converts",
"a",
"CH",
"-",
"Date",
"String",
"in",
"a",
"yyyy",
"-",
"mm",
"-",
"dd",
"String",
".",
"The",
"conversion",
"is",
"very",
"lenient",
"and",
"tries",
"to",
"convert",
"as",
"long",
"as",
"its",
"somehow",
"clear",
"what",
"the",
"user",
"may",
"have",
"wanted",
"."
] | f7c5461b2b47a10b383aee1e2f1f150f6773703b | https://github.com/BrunoEberhard/minimal-j/blob/f7c5461b2b47a10b383aee1e2f1f150f6773703b/src/main/java/org/minimalj/util/DateUtils.java#L80-L94 | train |
BrunoEberhard/minimal-j | src/main/java/org/minimalj/util/DateUtils.java | DateUtils.parse | public static LocalDate parse(String date) {
if (StringUtils.isEmpty(date)) return null;
try {
return parse_(date);
} catch (DateTimeParseException x) {
return InvalidValues.createInvalidLocalDate(date);
}
} | java | public static LocalDate parse(String date) {
if (StringUtils.isEmpty(date)) return null;
try {
return parse_(date);
} catch (DateTimeParseException x) {
return InvalidValues.createInvalidLocalDate(date);
}
} | [
"public",
"static",
"LocalDate",
"parse",
"(",
"String",
"date",
")",
"{",
"if",
"(",
"StringUtils",
".",
"isEmpty",
"(",
"date",
")",
")",
"return",
"null",
";",
"try",
"{",
"return",
"parse_",
"(",
"date",
")",
";",
"}",
"catch",
"(",
"DateTimeParseException",
"x",
")",
"{",
"return",
"InvalidValues",
".",
"createInvalidLocalDate",
"(",
"date",
")",
";",
"}",
"}"
] | Tries to be a little bit more clever than the normal parsing. Accept dates
like 1.2.2013 or 010214
@param date date as a String or <code>null</code>
@return LocalDate date object (valid or invalid) or <code>null</code> | [
"Tries",
"to",
"be",
"a",
"little",
"bit",
"more",
"clever",
"than",
"the",
"normal",
"parsing",
".",
"Accept",
"dates",
"like",
"1",
".",
"2",
".",
"2013",
"or",
"010214"
] | f7c5461b2b47a10b383aee1e2f1f150f6773703b | https://github.com/BrunoEberhard/minimal-j/blob/f7c5461b2b47a10b383aee1e2f1f150f6773703b/src/main/java/org/minimalj/util/DateUtils.java#L189-L196 | train |
BrunoEberhard/minimal-j | src/main/java/org/minimalj/util/DateUtils.java | DateUtils.parse_ | public static LocalDate parse_(String date) {
DateTimeFormatter dateTimeFormatter = getDateTimeFormatter();
if (germanDateStyle()) {
date = parseCH(date, false);
return LocalDate.parse(date);
} else {
return LocalDate.parse(date, dateTimeFormatter);
}
} | java | public static LocalDate parse_(String date) {
DateTimeFormatter dateTimeFormatter = getDateTimeFormatter();
if (germanDateStyle()) {
date = parseCH(date, false);
return LocalDate.parse(date);
} else {
return LocalDate.parse(date, dateTimeFormatter);
}
} | [
"public",
"static",
"LocalDate",
"parse_",
"(",
"String",
"date",
")",
"{",
"DateTimeFormatter",
"dateTimeFormatter",
"=",
"getDateTimeFormatter",
"(",
")",
";",
"if",
"(",
"germanDateStyle",
"(",
")",
")",
"{",
"date",
"=",
"parseCH",
"(",
"date",
",",
"false",
")",
";",
"return",
"LocalDate",
".",
"parse",
"(",
"date",
")",
";",
"}",
"else",
"{",
"return",
"LocalDate",
".",
"parse",
"(",
"date",
",",
"dateTimeFormatter",
")",
";",
"}",
"}"
] | framework internal, only used by LocalDateTimeFormElement | [
"framework",
"internal",
"only",
"used",
"by",
"LocalDateTimeFormElement"
] | f7c5461b2b47a10b383aee1e2f1f150f6773703b | https://github.com/BrunoEberhard/minimal-j/blob/f7c5461b2b47a10b383aee1e2f1f150f6773703b/src/main/java/org/minimalj/util/DateUtils.java#L199-L207 | train |
openengsb/openengsb | ui/admin/src/main/java/org/openengsb/ui/admin/global/menu/MenuTemplate.java | MenuTemplate.addMenuItem | public void addMenuItem(String index, Class<? extends WebPage> linkClass, String langKey, String langDescKey,
String... authority) {
addMenuItem(index, linkClass, langKey, langDescKey, null, authority);
} | java | public void addMenuItem(String index, Class<? extends WebPage> linkClass, String langKey, String langDescKey,
String... authority) {
addMenuItem(index, linkClass, langKey, langDescKey, null, authority);
} | [
"public",
"void",
"addMenuItem",
"(",
"String",
"index",
",",
"Class",
"<",
"?",
"extends",
"WebPage",
">",
"linkClass",
",",
"String",
"langKey",
",",
"String",
"langDescKey",
",",
"String",
"...",
"authority",
")",
"{",
"addMenuItem",
"(",
"index",
",",
"linkClass",
",",
"langKey",
",",
"langDescKey",
",",
"null",
",",
"authority",
")",
";",
"}"
] | Adds a new item to main header navigation where the index defines the name of the index, which should be the
class name; linkClass defines the class name to be linked to; langKey defines the language key for the text which
should be displayed and authority defines who is authorized to see the link | [
"Adds",
"a",
"new",
"item",
"to",
"main",
"header",
"navigation",
"where",
"the",
"index",
"defines",
"the",
"name",
"of",
"the",
"index",
"which",
"should",
"be",
"the",
"class",
"name",
";",
"linkClass",
"defines",
"the",
"class",
"name",
"to",
"be",
"linked",
"to",
";",
"langKey",
"defines",
"the",
"language",
"key",
"for",
"the",
"text",
"which",
"should",
"be",
"displayed",
"and",
"authority",
"defines",
"who",
"is",
"authorized",
"to",
"see",
"the",
"link"
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/ui/admin/src/main/java/org/openengsb/ui/admin/global/menu/MenuTemplate.java#L128-L131 | train |
BrunoEberhard/minimal-j | src/main/java/org/minimalj/backend/Backend.java | Backend.read | public static <T> T read(Class<T> clazz, Object id) {
return execute(new ReadEntityTransaction<T>(clazz, id));
} | java | public static <T> T read(Class<T> clazz, Object id) {
return execute(new ReadEntityTransaction<T>(clazz, id));
} | [
"public",
"static",
"<",
"T",
">",
"T",
"read",
"(",
"Class",
"<",
"T",
">",
"clazz",
",",
"Object",
"id",
")",
"{",
"return",
"execute",
"(",
"new",
"ReadEntityTransaction",
"<",
"T",
">",
"(",
"clazz",
",",
"id",
")",
")",
";",
"}"
] | transaction is created. | [
"transaction",
"is",
"created",
"."
] | f7c5461b2b47a10b383aee1e2f1f150f6773703b | https://github.com/BrunoEberhard/minimal-j/blob/f7c5461b2b47a10b383aee1e2f1f150f6773703b/src/main/java/org/minimalj/backend/Backend.java#L143-L145 | train |
openengsb/openengsb | components/console/src/main/java/org/openengsb/core/console/internal/util/ServicesHelper.java | ServicesHelper.listRunningServices | public void listRunningServices() {
try {
final List<String> formatedOutput =
SecurityContext.executeWithSystemPermissions(new Callable<List<String>>() {
@Override
public List<String> call() throws Exception {
List<String> tmp = new ArrayList<String>();
List<ServiceReference<Domain>> listServiceReferences =
osgiUtilsService.listServiceReferences(Domain.class);
for (ServiceReference<Domain> ref : listServiceReferences) {
Domain service = bundleContext.getService(ref);
tmp.add(OutputStreamFormater.formatValues(
ref.getProperty(org.osgi.framework.Constants.SERVICE_PID).toString(), service
.getAliveState().toString()));
}
return tmp;
}
});
for (String s : formatedOutput) {
OutputStreamFormater.printValue(s);
}
} catch (ExecutionException ex) {
ex.printStackTrace();
System.err.println("Could not get services");
}
} | java | public void listRunningServices() {
try {
final List<String> formatedOutput =
SecurityContext.executeWithSystemPermissions(new Callable<List<String>>() {
@Override
public List<String> call() throws Exception {
List<String> tmp = new ArrayList<String>();
List<ServiceReference<Domain>> listServiceReferences =
osgiUtilsService.listServiceReferences(Domain.class);
for (ServiceReference<Domain> ref : listServiceReferences) {
Domain service = bundleContext.getService(ref);
tmp.add(OutputStreamFormater.formatValues(
ref.getProperty(org.osgi.framework.Constants.SERVICE_PID).toString(), service
.getAliveState().toString()));
}
return tmp;
}
});
for (String s : formatedOutput) {
OutputStreamFormater.printValue(s);
}
} catch (ExecutionException ex) {
ex.printStackTrace();
System.err.println("Could not get services");
}
} | [
"public",
"void",
"listRunningServices",
"(",
")",
"{",
"try",
"{",
"final",
"List",
"<",
"String",
">",
"formatedOutput",
"=",
"SecurityContext",
".",
"executeWithSystemPermissions",
"(",
"new",
"Callable",
"<",
"List",
"<",
"String",
">",
">",
"(",
")",
"{",
"@",
"Override",
"public",
"List",
"<",
"String",
">",
"call",
"(",
")",
"throws",
"Exception",
"{",
"List",
"<",
"String",
">",
"tmp",
"=",
"new",
"ArrayList",
"<",
"String",
">",
"(",
")",
";",
"List",
"<",
"ServiceReference",
"<",
"Domain",
">",
">",
"listServiceReferences",
"=",
"osgiUtilsService",
".",
"listServiceReferences",
"(",
"Domain",
".",
"class",
")",
";",
"for",
"(",
"ServiceReference",
"<",
"Domain",
">",
"ref",
":",
"listServiceReferences",
")",
"{",
"Domain",
"service",
"=",
"bundleContext",
".",
"getService",
"(",
"ref",
")",
";",
"tmp",
".",
"add",
"(",
"OutputStreamFormater",
".",
"formatValues",
"(",
"ref",
".",
"getProperty",
"(",
"org",
".",
"osgi",
".",
"framework",
".",
"Constants",
".",
"SERVICE_PID",
")",
".",
"toString",
"(",
")",
",",
"service",
".",
"getAliveState",
"(",
")",
".",
"toString",
"(",
")",
")",
")",
";",
"}",
"return",
"tmp",
";",
"}",
"}",
")",
";",
"for",
"(",
"String",
"s",
":",
"formatedOutput",
")",
"{",
"OutputStreamFormater",
".",
"printValue",
"(",
"s",
")",
";",
"}",
"}",
"catch",
"(",
"ExecutionException",
"ex",
")",
"{",
"ex",
".",
"printStackTrace",
"(",
")",
";",
"System",
".",
"err",
".",
"println",
"(",
"\"Could not get services\"",
")",
";",
"}",
"}"
] | prints out all available services and their alive state | [
"prints",
"out",
"all",
"available",
"services",
"and",
"their",
"alive",
"state"
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/console/src/main/java/org/openengsb/core/console/internal/util/ServicesHelper.java#L72-L98 | train |
openengsb/openengsb | components/console/src/main/java/org/openengsb/core/console/internal/util/ServicesHelper.java | ServicesHelper.deleteService | public void deleteService(String id, boolean force) {
try {
if (id == null || id.isEmpty()) {
id = selectRunningService();
}
final String idFinal = id;
int input = 'Y';
if (!force) {
OutputStreamFormater.printValue(String.format(
"Do you really want to delete the connector: %s (Y/n): ", id));
input = keyboard.read();
}
if ('n' != (char) input && 'N' != (char) input) {
SecurityContext.executeWithSystemPermissions(new Callable<Object>() {
@Override
public Object call() throws Exception {
serviceManager.delete(idFinal);
return null;
}
});
OutputStreamFormater.printValue(String.format("Service: %s successfully deleted", id));
}
} catch (ExecutionException e) {
e.printStackTrace();
System.err.println("Could not delete service");
} catch (IOException e) {
e.printStackTrace();
System.err.println("Unexpected Error");
}
} | java | public void deleteService(String id, boolean force) {
try {
if (id == null || id.isEmpty()) {
id = selectRunningService();
}
final String idFinal = id;
int input = 'Y';
if (!force) {
OutputStreamFormater.printValue(String.format(
"Do you really want to delete the connector: %s (Y/n): ", id));
input = keyboard.read();
}
if ('n' != (char) input && 'N' != (char) input) {
SecurityContext.executeWithSystemPermissions(new Callable<Object>() {
@Override
public Object call() throws Exception {
serviceManager.delete(idFinal);
return null;
}
});
OutputStreamFormater.printValue(String.format("Service: %s successfully deleted", id));
}
} catch (ExecutionException e) {
e.printStackTrace();
System.err.println("Could not delete service");
} catch (IOException e) {
e.printStackTrace();
System.err.println("Unexpected Error");
}
} | [
"public",
"void",
"deleteService",
"(",
"String",
"id",
",",
"boolean",
"force",
")",
"{",
"try",
"{",
"if",
"(",
"id",
"==",
"null",
"||",
"id",
".",
"isEmpty",
"(",
")",
")",
"{",
"id",
"=",
"selectRunningService",
"(",
")",
";",
"}",
"final",
"String",
"idFinal",
"=",
"id",
";",
"int",
"input",
"=",
"'",
"'",
";",
"if",
"(",
"!",
"force",
")",
"{",
"OutputStreamFormater",
".",
"printValue",
"(",
"String",
".",
"format",
"(",
"\"Do you really want to delete the connector: %s (Y/n): \"",
",",
"id",
")",
")",
";",
"input",
"=",
"keyboard",
".",
"read",
"(",
")",
";",
"}",
"if",
"(",
"'",
"'",
"!=",
"(",
"char",
")",
"input",
"&&",
"'",
"'",
"!=",
"(",
"char",
")",
"input",
")",
"{",
"SecurityContext",
".",
"executeWithSystemPermissions",
"(",
"new",
"Callable",
"<",
"Object",
">",
"(",
")",
"{",
"@",
"Override",
"public",
"Object",
"call",
"(",
")",
"throws",
"Exception",
"{",
"serviceManager",
".",
"delete",
"(",
"idFinal",
")",
";",
"return",
"null",
";",
"}",
"}",
")",
";",
"OutputStreamFormater",
".",
"printValue",
"(",
"String",
".",
"format",
"(",
"\"Service: %s successfully deleted\"",
",",
"id",
")",
")",
";",
"}",
"}",
"catch",
"(",
"ExecutionException",
"e",
")",
"{",
"e",
".",
"printStackTrace",
"(",
")",
";",
"System",
".",
"err",
".",
"println",
"(",
"\"Could not delete service\"",
")",
";",
"}",
"catch",
"(",
"IOException",
"e",
")",
"{",
"e",
".",
"printStackTrace",
"(",
")",
";",
"System",
".",
"err",
".",
"println",
"(",
"\"Unexpected Error\"",
")",
";",
"}",
"}"
] | delete a service identified by its id, if force is true, the user does not have to confirm | [
"delete",
"a",
"service",
"identified",
"by",
"its",
"id",
"if",
"force",
"is",
"true",
"the",
"user",
"does",
"not",
"have",
"to",
"confirm"
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/console/src/main/java/org/openengsb/core/console/internal/util/ServicesHelper.java#L119-L148 | train |
openengsb/openengsb | components/console/src/main/java/org/openengsb/core/console/internal/util/ServicesHelper.java | ServicesHelper.selectRunningService | private String selectRunningService() {
String selectedServiceId;
List<String> runningServiceIds = getRunningServiceIds();
for (int i = 0; i < runningServiceIds.size(); i++) {
String serviceId = runningServiceIds.get(i);
OutputStreamFormater.printTabbedValues(9, String.format("[%s]", i), String.format("%s", serviceId));
}
String s = readUserInput();
int pos;
try {
pos = Integer.parseInt(s);
selectedServiceId = runningServiceIds.get(pos);
} catch (Exception e) {
throw new IllegalArgumentException(String.format("Invalid Input: %s", s));
}
return selectedServiceId;
} | java | private String selectRunningService() {
String selectedServiceId;
List<String> runningServiceIds = getRunningServiceIds();
for (int i = 0; i < runningServiceIds.size(); i++) {
String serviceId = runningServiceIds.get(i);
OutputStreamFormater.printTabbedValues(9, String.format("[%s]", i), String.format("%s", serviceId));
}
String s = readUserInput();
int pos;
try {
pos = Integer.parseInt(s);
selectedServiceId = runningServiceIds.get(pos);
} catch (Exception e) {
throw new IllegalArgumentException(String.format("Invalid Input: %s", s));
}
return selectedServiceId;
} | [
"private",
"String",
"selectRunningService",
"(",
")",
"{",
"String",
"selectedServiceId",
";",
"List",
"<",
"String",
">",
"runningServiceIds",
"=",
"getRunningServiceIds",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"runningServiceIds",
".",
"size",
"(",
")",
";",
"i",
"++",
")",
"{",
"String",
"serviceId",
"=",
"runningServiceIds",
".",
"get",
"(",
"i",
")",
";",
"OutputStreamFormater",
".",
"printTabbedValues",
"(",
"9",
",",
"String",
".",
"format",
"(",
"\"[%s]\"",
",",
"i",
")",
",",
"String",
".",
"format",
"(",
"\"%s\"",
",",
"serviceId",
")",
")",
";",
"}",
"String",
"s",
"=",
"readUserInput",
"(",
")",
";",
"int",
"pos",
";",
"try",
"{",
"pos",
"=",
"Integer",
".",
"parseInt",
"(",
"s",
")",
";",
"selectedServiceId",
"=",
"runningServiceIds",
".",
"get",
"(",
"pos",
")",
";",
"}",
"catch",
"(",
"Exception",
"e",
")",
"{",
"throw",
"new",
"IllegalArgumentException",
"(",
"String",
".",
"format",
"(",
"\"Invalid Input: %s\"",
",",
"s",
")",
")",
";",
"}",
"return",
"selectedServiceId",
";",
"}"
] | let the user chose one of the running services
@return | [
"let",
"the",
"user",
"chose",
"one",
"of",
"the",
"running",
"services"
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/console/src/main/java/org/openengsb/core/console/internal/util/ServicesHelper.java#L155-L172 | train |
openengsb/openengsb | components/console/src/main/java/org/openengsb/core/console/internal/util/ServicesHelper.java | ServicesHelper.getRunningServiceIds | public List<String> getRunningServiceIds() {
List<ServiceReference<Domain>> serviceReferences = osgiUtilsService.listServiceReferences(Domain.class);
List<String> result = new ArrayList<String>();
for (ServiceReference<Domain> ref : serviceReferences) {
result.add((String) ref.getProperty(org.osgi.framework.Constants.SERVICE_PID));
}
return result;
} | java | public List<String> getRunningServiceIds() {
List<ServiceReference<Domain>> serviceReferences = osgiUtilsService.listServiceReferences(Domain.class);
List<String> result = new ArrayList<String>();
for (ServiceReference<Domain> ref : serviceReferences) {
result.add((String) ref.getProperty(org.osgi.framework.Constants.SERVICE_PID));
}
return result;
} | [
"public",
"List",
"<",
"String",
">",
"getRunningServiceIds",
"(",
")",
"{",
"List",
"<",
"ServiceReference",
"<",
"Domain",
">>",
"serviceReferences",
"=",
"osgiUtilsService",
".",
"listServiceReferences",
"(",
"Domain",
".",
"class",
")",
";",
"List",
"<",
"String",
">",
"result",
"=",
"new",
"ArrayList",
"<",
"String",
">",
"(",
")",
";",
"for",
"(",
"ServiceReference",
"<",
"Domain",
">",
"ref",
":",
"serviceReferences",
")",
"{",
"result",
".",
"add",
"(",
"(",
"String",
")",
"ref",
".",
"getProperty",
"(",
"org",
".",
"osgi",
".",
"framework",
".",
"Constants",
".",
"SERVICE_PID",
")",
")",
";",
"}",
"return",
"result",
";",
"}"
] | returns a list of all service ids | [
"returns",
"a",
"list",
"of",
"all",
"service",
"ids"
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/console/src/main/java/org/openengsb/core/console/internal/util/ServicesHelper.java#L177-L184 | train |
openengsb/openengsb | components/console/src/main/java/org/openengsb/core/console/internal/util/ServicesHelper.java | ServicesHelper.createService | public void createService(String domainProviderName, boolean force, Map<String, String> attributes) {
// check if a domain has been chosen
if (domainProviderName == null || domainProviderName.isEmpty()) {
domainProviderName = selectDomainProvider();
}
// get domain provider Id
String domainProviderId = "";
List<DomainProvider> domainProvider = getDomainProvider();
for (DomainProvider provider : domainProvider) {
if (provider.getName().getString(Locale.getDefault()).equals(domainProviderName)) {
domainProviderId = provider.getId();
}
}
// get the connector which should be created
ConnectorProvider connectorProvider =
getConnectorToCreate(domainProviderId, attributes.get(ServiceCommands.CONNECTOR_TYPE));
String id;
if (attributes.isEmpty() || !attributes.containsKey(org.osgi.framework.Constants.SERVICE_PID)) {
OutputStreamFormater.printValue("Please enter an ID");
id = readUserInput();
} else {
id = attributes.get(org.osgi.framework.Constants.SERVICE_PID);
}
ServiceDescriptor descriptor = connectorProvider.getDescriptor();
OutputStreamFormater.printValue(String.format("Please enter the attributes for %s, keep empty for default",
descriptor.getName().getString(Locale.getDefault())));
// get attributes for connector
Map<String, String> attributeMap = getConnectorAttributes(descriptor.getAttributes(), attributes);
Map<String, Object> properties = new HashMap<String, Object>();
ConnectorDescription connectorDescription =
new ConnectorDescription(domainProviderId, connectorProvider.getId(), attributeMap, properties);
if (force) {
if (id != null && !id.isEmpty()) {
serviceManager.forceCreateWithId(id, connectorDescription);
} else {
serviceManager.forceCreate(connectorDescription);
}
OutputStreamFormater.printValue("Connector successfully created");
} else {
OutputStreamFormater.printValue("Do you want to create the connector with the following attributes:", "");
OutputStreamFormater.printValue("Connector ID", id);
for (String key : attributeMap.keySet()) {
OutputStreamFormater.printValue(key, attributeMap.get(key));
}
OutputStreamFormater.printValue("Create connector: (Y/n)");
if (!readUserInput().equalsIgnoreCase("n")) {
try {
if (id != null && !id.isEmpty()) {
serviceManager.createWithId(id, connectorDescription);
} else {
serviceManager.create(connectorDescription);
}
OutputStreamFormater.printValue("Connector successfully created");
} catch (RuntimeException e) {
e.printStackTrace();
OutputStreamFormater.printValue("Connector validation failed, creation aborted");
}
} else {
OutputStreamFormater.printValue("Creation aborted");
}
}
} | java | public void createService(String domainProviderName, boolean force, Map<String, String> attributes) {
// check if a domain has been chosen
if (domainProviderName == null || domainProviderName.isEmpty()) {
domainProviderName = selectDomainProvider();
}
// get domain provider Id
String domainProviderId = "";
List<DomainProvider> domainProvider = getDomainProvider();
for (DomainProvider provider : domainProvider) {
if (provider.getName().getString(Locale.getDefault()).equals(domainProviderName)) {
domainProviderId = provider.getId();
}
}
// get the connector which should be created
ConnectorProvider connectorProvider =
getConnectorToCreate(domainProviderId, attributes.get(ServiceCommands.CONNECTOR_TYPE));
String id;
if (attributes.isEmpty() || !attributes.containsKey(org.osgi.framework.Constants.SERVICE_PID)) {
OutputStreamFormater.printValue("Please enter an ID");
id = readUserInput();
} else {
id = attributes.get(org.osgi.framework.Constants.SERVICE_PID);
}
ServiceDescriptor descriptor = connectorProvider.getDescriptor();
OutputStreamFormater.printValue(String.format("Please enter the attributes for %s, keep empty for default",
descriptor.getName().getString(Locale.getDefault())));
// get attributes for connector
Map<String, String> attributeMap = getConnectorAttributes(descriptor.getAttributes(), attributes);
Map<String, Object> properties = new HashMap<String, Object>();
ConnectorDescription connectorDescription =
new ConnectorDescription(domainProviderId, connectorProvider.getId(), attributeMap, properties);
if (force) {
if (id != null && !id.isEmpty()) {
serviceManager.forceCreateWithId(id, connectorDescription);
} else {
serviceManager.forceCreate(connectorDescription);
}
OutputStreamFormater.printValue("Connector successfully created");
} else {
OutputStreamFormater.printValue("Do you want to create the connector with the following attributes:", "");
OutputStreamFormater.printValue("Connector ID", id);
for (String key : attributeMap.keySet()) {
OutputStreamFormater.printValue(key, attributeMap.get(key));
}
OutputStreamFormater.printValue("Create connector: (Y/n)");
if (!readUserInput().equalsIgnoreCase("n")) {
try {
if (id != null && !id.isEmpty()) {
serviceManager.createWithId(id, connectorDescription);
} else {
serviceManager.create(connectorDescription);
}
OutputStreamFormater.printValue("Connector successfully created");
} catch (RuntimeException e) {
e.printStackTrace();
OutputStreamFormater.printValue("Connector validation failed, creation aborted");
}
} else {
OutputStreamFormater.printValue("Creation aborted");
}
}
} | [
"public",
"void",
"createService",
"(",
"String",
"domainProviderName",
",",
"boolean",
"force",
",",
"Map",
"<",
"String",
",",
"String",
">",
"attributes",
")",
"{",
"// check if a domain has been chosen",
"if",
"(",
"domainProviderName",
"==",
"null",
"||",
"domainProviderName",
".",
"isEmpty",
"(",
")",
")",
"{",
"domainProviderName",
"=",
"selectDomainProvider",
"(",
")",
";",
"}",
"// get domain provider Id",
"String",
"domainProviderId",
"=",
"\"\"",
";",
"List",
"<",
"DomainProvider",
">",
"domainProvider",
"=",
"getDomainProvider",
"(",
")",
";",
"for",
"(",
"DomainProvider",
"provider",
":",
"domainProvider",
")",
"{",
"if",
"(",
"provider",
".",
"getName",
"(",
")",
".",
"getString",
"(",
"Locale",
".",
"getDefault",
"(",
")",
")",
".",
"equals",
"(",
"domainProviderName",
")",
")",
"{",
"domainProviderId",
"=",
"provider",
".",
"getId",
"(",
")",
";",
"}",
"}",
"// get the connector which should be created",
"ConnectorProvider",
"connectorProvider",
"=",
"getConnectorToCreate",
"(",
"domainProviderId",
",",
"attributes",
".",
"get",
"(",
"ServiceCommands",
".",
"CONNECTOR_TYPE",
")",
")",
";",
"String",
"id",
";",
"if",
"(",
"attributes",
".",
"isEmpty",
"(",
")",
"||",
"!",
"attributes",
".",
"containsKey",
"(",
"org",
".",
"osgi",
".",
"framework",
".",
"Constants",
".",
"SERVICE_PID",
")",
")",
"{",
"OutputStreamFormater",
".",
"printValue",
"(",
"\"Please enter an ID\"",
")",
";",
"id",
"=",
"readUserInput",
"(",
")",
";",
"}",
"else",
"{",
"id",
"=",
"attributes",
".",
"get",
"(",
"org",
".",
"osgi",
".",
"framework",
".",
"Constants",
".",
"SERVICE_PID",
")",
";",
"}",
"ServiceDescriptor",
"descriptor",
"=",
"connectorProvider",
".",
"getDescriptor",
"(",
")",
";",
"OutputStreamFormater",
".",
"printValue",
"(",
"String",
".",
"format",
"(",
"\"Please enter the attributes for %s, keep empty for default\"",
",",
"descriptor",
".",
"getName",
"(",
")",
".",
"getString",
"(",
"Locale",
".",
"getDefault",
"(",
")",
")",
")",
")",
";",
"// get attributes for connector",
"Map",
"<",
"String",
",",
"String",
">",
"attributeMap",
"=",
"getConnectorAttributes",
"(",
"descriptor",
".",
"getAttributes",
"(",
")",
",",
"attributes",
")",
";",
"Map",
"<",
"String",
",",
"Object",
">",
"properties",
"=",
"new",
"HashMap",
"<",
"String",
",",
"Object",
">",
"(",
")",
";",
"ConnectorDescription",
"connectorDescription",
"=",
"new",
"ConnectorDescription",
"(",
"domainProviderId",
",",
"connectorProvider",
".",
"getId",
"(",
")",
",",
"attributeMap",
",",
"properties",
")",
";",
"if",
"(",
"force",
")",
"{",
"if",
"(",
"id",
"!=",
"null",
"&&",
"!",
"id",
".",
"isEmpty",
"(",
")",
")",
"{",
"serviceManager",
".",
"forceCreateWithId",
"(",
"id",
",",
"connectorDescription",
")",
";",
"}",
"else",
"{",
"serviceManager",
".",
"forceCreate",
"(",
"connectorDescription",
")",
";",
"}",
"OutputStreamFormater",
".",
"printValue",
"(",
"\"Connector successfully created\"",
")",
";",
"}",
"else",
"{",
"OutputStreamFormater",
".",
"printValue",
"(",
"\"Do you want to create the connector with the following attributes:\"",
",",
"\"\"",
")",
";",
"OutputStreamFormater",
".",
"printValue",
"(",
"\"Connector ID\"",
",",
"id",
")",
";",
"for",
"(",
"String",
"key",
":",
"attributeMap",
".",
"keySet",
"(",
")",
")",
"{",
"OutputStreamFormater",
".",
"printValue",
"(",
"key",
",",
"attributeMap",
".",
"get",
"(",
"key",
")",
")",
";",
"}",
"OutputStreamFormater",
".",
"printValue",
"(",
"\"Create connector: (Y/n)\"",
")",
";",
"if",
"(",
"!",
"readUserInput",
"(",
")",
".",
"equalsIgnoreCase",
"(",
"\"n\"",
")",
")",
"{",
"try",
"{",
"if",
"(",
"id",
"!=",
"null",
"&&",
"!",
"id",
".",
"isEmpty",
"(",
")",
")",
"{",
"serviceManager",
".",
"createWithId",
"(",
"id",
",",
"connectorDescription",
")",
";",
"}",
"else",
"{",
"serviceManager",
".",
"create",
"(",
"connectorDescription",
")",
";",
"}",
"OutputStreamFormater",
".",
"printValue",
"(",
"\"Connector successfully created\"",
")",
";",
"}",
"catch",
"(",
"RuntimeException",
"e",
")",
"{",
"e",
".",
"printStackTrace",
"(",
")",
";",
"OutputStreamFormater",
".",
"printValue",
"(",
"\"Connector validation failed, creation aborted\"",
")",
";",
"}",
"}",
"else",
"{",
"OutputStreamFormater",
".",
"printValue",
"(",
"\"Creation aborted\"",
")",
";",
"}",
"}",
"}"
] | crate a service for the given domain, if force is true, input is not verified | [
"crate",
"a",
"service",
"for",
"the",
"given",
"domain",
"if",
"force",
"is",
"true",
"input",
"is",
"not",
"verified"
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/console/src/main/java/org/openengsb/core/console/internal/util/ServicesHelper.java#L189-L255 | train |
openengsb/openengsb | components/services/src/main/java/org/openengsb/core/services/internal/security/ldap/EntryFactory.java | EntryFactory.globalPermissionSetStructure | public static List<Entry> globalPermissionSetStructure(String permissionSet) {
Entry permissionSetEntry = namedObject(permissionSet, SchemaConstants.ouGlobalPermissionSets());
Entry ouDirect = organizationalUnit("direct", permissionSetEntry.getDn());
Entry ouChildrenSets = organizationalUnit("childrenSets", permissionSetEntry.getDn());
Entry ouAttributes = organizationalUnit("attributes", permissionSetEntry.getDn());
return Arrays.asList(permissionSetEntry, ouAttributes, ouDirect, ouChildrenSets);
} | java | public static List<Entry> globalPermissionSetStructure(String permissionSet) {
Entry permissionSetEntry = namedObject(permissionSet, SchemaConstants.ouGlobalPermissionSets());
Entry ouDirect = organizationalUnit("direct", permissionSetEntry.getDn());
Entry ouChildrenSets = organizationalUnit("childrenSets", permissionSetEntry.getDn());
Entry ouAttributes = organizationalUnit("attributes", permissionSetEntry.getDn());
return Arrays.asList(permissionSetEntry, ouAttributes, ouDirect, ouChildrenSets);
} | [
"public",
"static",
"List",
"<",
"Entry",
">",
"globalPermissionSetStructure",
"(",
"String",
"permissionSet",
")",
"{",
"Entry",
"permissionSetEntry",
"=",
"namedObject",
"(",
"permissionSet",
",",
"SchemaConstants",
".",
"ouGlobalPermissionSets",
"(",
")",
")",
";",
"Entry",
"ouDirect",
"=",
"organizationalUnit",
"(",
"\"direct\"",
",",
"permissionSetEntry",
".",
"getDn",
"(",
")",
")",
";",
"Entry",
"ouChildrenSets",
"=",
"organizationalUnit",
"(",
"\"childrenSets\"",
",",
"permissionSetEntry",
".",
"getDn",
"(",
")",
")",
";",
"Entry",
"ouAttributes",
"=",
"organizationalUnit",
"(",
"\"attributes\"",
",",
"permissionSetEntry",
".",
"getDn",
"(",
")",
")",
";",
"return",
"Arrays",
".",
"asList",
"(",
"permissionSetEntry",
",",
"ouAttributes",
",",
"ouDirect",
",",
"ouChildrenSets",
")",
";",
"}"
] | Returns a list of entries representing a permissionSet. The list should not be reordered since its order follows
the tree structure of the DIT. It can be inserted into the DIT right away. | [
"Returns",
"a",
"list",
"of",
"entries",
"representing",
"a",
"permissionSet",
".",
"The",
"list",
"should",
"not",
"be",
"reordered",
"since",
"its",
"order",
"follows",
"the",
"tree",
"structure",
"of",
"the",
"DIT",
".",
"It",
"can",
"be",
"inserted",
"into",
"the",
"DIT",
"right",
"away",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/services/src/main/java/org/openengsb/core/services/internal/security/ldap/EntryFactory.java#L109-L115 | train |
openengsb/openengsb | components/edbi/jdbc/src/main/java/org/openengsb/core/edbi/jdbc/JdbcIndexEngine.java | JdbcIndexEngine.removeUnmappedFields | protected void removeUnmappedFields(JdbcIndex<?> index) {
Iterator<IndexField<?>> iterator = index.getFields().iterator();
while (iterator.hasNext()) {
IndexField<?> field = iterator.next();
if (field.getMappedType() == null) {
LOG.info("Removing {} from index {} - no mapped type information", field.getName(), index.getName());
iterator.remove();
}
}
} | java | protected void removeUnmappedFields(JdbcIndex<?> index) {
Iterator<IndexField<?>> iterator = index.getFields().iterator();
while (iterator.hasNext()) {
IndexField<?> field = iterator.next();
if (field.getMappedType() == null) {
LOG.info("Removing {} from index {} - no mapped type information", field.getName(), index.getName());
iterator.remove();
}
}
} | [
"protected",
"void",
"removeUnmappedFields",
"(",
"JdbcIndex",
"<",
"?",
">",
"index",
")",
"{",
"Iterator",
"<",
"IndexField",
"<",
"?",
">",
">",
"iterator",
"=",
"index",
".",
"getFields",
"(",
")",
".",
"iterator",
"(",
")",
";",
"while",
"(",
"iterator",
".",
"hasNext",
"(",
")",
")",
"{",
"IndexField",
"<",
"?",
">",
"field",
"=",
"iterator",
".",
"next",
"(",
")",
";",
"if",
"(",
"field",
".",
"getMappedType",
"(",
")",
"==",
"null",
")",
"{",
"LOG",
".",
"info",
"(",
"\"Removing {} from index {} - no mapped type information\"",
",",
"field",
".",
"getName",
"(",
")",
",",
"index",
".",
"getName",
"(",
")",
")",
";",
"iterator",
".",
"remove",
"(",
")",
";",
"}",
"}",
"}"
] | Remove fields from the index that have no mapped type information.
@param index the index to be pruned | [
"Remove",
"fields",
"from",
"the",
"index",
"that",
"have",
"no",
"mapped",
"type",
"information",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/edbi/jdbc/src/main/java/org/openengsb/core/edbi/jdbc/JdbcIndexEngine.java#L232-L244 | train |
mguymon/naether | src/main/java/com/tobedevoured/naether/maven/Project.java | Project.loadPOM | public static Model loadPOM(String pomPath, String localRepo, Collection<RemoteRepository> repositories) throws ProjectException {
RepositoryClient repoClient = new RepositoryClient(localRepo);
NaetherModelResolver resolver = new NaetherModelResolver(repoClient, repositories);
ModelBuildingRequest req = new DefaultModelBuildingRequest();
req.setProcessPlugins( false );
req.setPomFile( new File(pomPath) );
req.setModelResolver( resolver );
req.setValidationLevel( ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL );
DefaultModelBuilder builder = (new DefaultModelBuilderFactory()).newInstance();
try {
return builder.build( req ).getEffectiveModel();
} catch ( ModelBuildingException e ) {
throw new ProjectException("Failed to build project from pom", e);
}
} | java | public static Model loadPOM(String pomPath, String localRepo, Collection<RemoteRepository> repositories) throws ProjectException {
RepositoryClient repoClient = new RepositoryClient(localRepo);
NaetherModelResolver resolver = new NaetherModelResolver(repoClient, repositories);
ModelBuildingRequest req = new DefaultModelBuildingRequest();
req.setProcessPlugins( false );
req.setPomFile( new File(pomPath) );
req.setModelResolver( resolver );
req.setValidationLevel( ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL );
DefaultModelBuilder builder = (new DefaultModelBuilderFactory()).newInstance();
try {
return builder.build( req ).getEffectiveModel();
} catch ( ModelBuildingException e ) {
throw new ProjectException("Failed to build project from pom", e);
}
} | [
"public",
"static",
"Model",
"loadPOM",
"(",
"String",
"pomPath",
",",
"String",
"localRepo",
",",
"Collection",
"<",
"RemoteRepository",
">",
"repositories",
")",
"throws",
"ProjectException",
"{",
"RepositoryClient",
"repoClient",
"=",
"new",
"RepositoryClient",
"(",
"localRepo",
")",
";",
"NaetherModelResolver",
"resolver",
"=",
"new",
"NaetherModelResolver",
"(",
"repoClient",
",",
"repositories",
")",
";",
"ModelBuildingRequest",
"req",
"=",
"new",
"DefaultModelBuildingRequest",
"(",
")",
";",
"req",
".",
"setProcessPlugins",
"(",
"false",
")",
";",
"req",
".",
"setPomFile",
"(",
"new",
"File",
"(",
"pomPath",
")",
")",
";",
"req",
".",
"setModelResolver",
"(",
"resolver",
")",
";",
"req",
".",
"setValidationLevel",
"(",
"ModelBuildingRequest",
".",
"VALIDATION_LEVEL_MINIMAL",
")",
";",
"DefaultModelBuilder",
"builder",
"=",
"(",
"new",
"DefaultModelBuilderFactory",
"(",
")",
")",
".",
"newInstance",
"(",
")",
";",
"try",
"{",
"return",
"builder",
".",
"build",
"(",
"req",
")",
".",
"getEffectiveModel",
"(",
")",
";",
"}",
"catch",
"(",
"ModelBuildingException",
"e",
")",
"{",
"throw",
"new",
"ProjectException",
"(",
"\"Failed to build project from pom\"",
",",
"e",
")",
";",
"}",
"}"
] | Load Maven pom
@param pomPath String path
@param localRepo String
@param repositories {@link Collection}
@return {@link Model}
@throws ProjectException if fails to open, read, or parse the POM | [
"Load",
"Maven",
"pom"
] | 218d8fd36c0b8b6e16d66e5715975570b4560ec4 | https://github.com/mguymon/naether/blob/218d8fd36c0b8b6e16d66e5715975570b4560ec4/src/main/java/com/tobedevoured/naether/maven/Project.java#L132-L148 | train |
mguymon/naether | src/main/java/com/tobedevoured/naether/maven/Project.java | Project.getVersion | public String getVersion() {
String version = getMavenModel().getVersion();
if ( version == null && getMavenModel().getParent() != null ) {
version = getMavenModel().getParent().getVersion();
}
return version;
} | java | public String getVersion() {
String version = getMavenModel().getVersion();
if ( version == null && getMavenModel().getParent() != null ) {
version = getMavenModel().getParent().getVersion();
}
return version;
} | [
"public",
"String",
"getVersion",
"(",
")",
"{",
"String",
"version",
"=",
"getMavenModel",
"(",
")",
".",
"getVersion",
"(",
")",
";",
"if",
"(",
"version",
"==",
"null",
"&&",
"getMavenModel",
"(",
")",
".",
"getParent",
"(",
")",
"!=",
"null",
")",
"{",
"version",
"=",
"getMavenModel",
"(",
")",
".",
"getParent",
"(",
")",
".",
"getVersion",
"(",
")",
";",
"}",
"return",
"version",
";",
"}"
] | Get version of the Project. If null, checks the Parent Project's version.
@return String | [
"Get",
"version",
"of",
"the",
"Project",
".",
"If",
"null",
"checks",
"the",
"Parent",
"Project",
"s",
"version",
"."
] | 218d8fd36c0b8b6e16d66e5715975570b4560ec4 | https://github.com/mguymon/naether/blob/218d8fd36c0b8b6e16d66e5715975570b4560ec4/src/main/java/com/tobedevoured/naether/maven/Project.java#L155-L162 | train |
mguymon/naether | src/main/java/com/tobedevoured/naether/maven/Project.java | Project.addRepository | public void addRepository(String url) throws ProjectException {
List<Repository> repositories = getRepositories();
if ( repositories == null ) {
repositories = new ArrayList<Repository>();
}
try {
Repository repository = RepoBuilder.repositoryFromUrl( url );
repositories.add( repository );
} catch (MalformedURLException e) {
throw new ProjectException( e );
}
getMavenModel().setRepositories( repositories );
} | java | public void addRepository(String url) throws ProjectException {
List<Repository> repositories = getRepositories();
if ( repositories == null ) {
repositories = new ArrayList<Repository>();
}
try {
Repository repository = RepoBuilder.repositoryFromUrl( url );
repositories.add( repository );
} catch (MalformedURLException e) {
throw new ProjectException( e );
}
getMavenModel().setRepositories( repositories );
} | [
"public",
"void",
"addRepository",
"(",
"String",
"url",
")",
"throws",
"ProjectException",
"{",
"List",
"<",
"Repository",
">",
"repositories",
"=",
"getRepositories",
"(",
")",
";",
"if",
"(",
"repositories",
"==",
"null",
")",
"{",
"repositories",
"=",
"new",
"ArrayList",
"<",
"Repository",
">",
"(",
")",
";",
"}",
"try",
"{",
"Repository",
"repository",
"=",
"RepoBuilder",
".",
"repositoryFromUrl",
"(",
"url",
")",
";",
"repositories",
".",
"add",
"(",
"repository",
")",
";",
"}",
"catch",
"(",
"MalformedURLException",
"e",
")",
"{",
"throw",
"new",
"ProjectException",
"(",
"e",
")",
";",
"}",
"getMavenModel",
"(",
")",
".",
"setRepositories",
"(",
"repositories",
")",
";",
"}"
] | Add a Repository to the Project
@param url String
@throws ProjectException exception | [
"Add",
"a",
"Repository",
"to",
"the",
"Project"
] | 218d8fd36c0b8b6e16d66e5715975570b4560ec4 | https://github.com/mguymon/naether/blob/218d8fd36c0b8b6e16d66e5715975570b4560ec4/src/main/java/com/tobedevoured/naether/maven/Project.java#L204-L219 | train |
mguymon/naether | src/main/java/com/tobedevoured/naether/maven/Project.java | Project.getRepositoryUrls | public List<String> getRepositoryUrls() {
List<String> urls = new ArrayList<String>();
for ( Repository repo : getRepositories() ) {
urls.add( repo.getUrl() );
}
return urls;
} | java | public List<String> getRepositoryUrls() {
List<String> urls = new ArrayList<String>();
for ( Repository repo : getRepositories() ) {
urls.add( repo.getUrl() );
}
return urls;
} | [
"public",
"List",
"<",
"String",
">",
"getRepositoryUrls",
"(",
")",
"{",
"List",
"<",
"String",
">",
"urls",
"=",
"new",
"ArrayList",
"<",
"String",
">",
"(",
")",
";",
"for",
"(",
"Repository",
"repo",
":",
"getRepositories",
"(",
")",
")",
"{",
"urls",
".",
"add",
"(",
"repo",
".",
"getUrl",
"(",
")",
")",
";",
"}",
"return",
"urls",
";",
"}"
] | Get List of Repositories as String url
@return List | [
"Get",
"List",
"of",
"Repositories",
"as",
"String",
"url"
] | 218d8fd36c0b8b6e16d66e5715975570b4560ec4 | https://github.com/mguymon/naether/blob/218d8fd36c0b8b6e16d66e5715975570b4560ec4/src/main/java/com/tobedevoured/naether/maven/Project.java#L254-L262 | train |
mguymon/naether | src/main/java/com/tobedevoured/naether/maven/Project.java | Project.setProjectNotation | public void setProjectNotation(String notation) {
Map<String, String> notationMap = Notation.parse(notation);
this.setGroupId(notationMap.get("groupId"));
this.setArtifactId(notationMap.get("artifactId"));
this.setType(notationMap.get("type"));
this.setVersion(notationMap.get("version"));
} | java | public void setProjectNotation(String notation) {
Map<String, String> notationMap = Notation.parse(notation);
this.setGroupId(notationMap.get("groupId"));
this.setArtifactId(notationMap.get("artifactId"));
this.setType(notationMap.get("type"));
this.setVersion(notationMap.get("version"));
} | [
"public",
"void",
"setProjectNotation",
"(",
"String",
"notation",
")",
"{",
"Map",
"<",
"String",
",",
"String",
">",
"notationMap",
"=",
"Notation",
".",
"parse",
"(",
"notation",
")",
";",
"this",
".",
"setGroupId",
"(",
"notationMap",
".",
"get",
"(",
"\"groupId\"",
")",
")",
";",
"this",
".",
"setArtifactId",
"(",
"notationMap",
".",
"get",
"(",
"\"artifactId\"",
")",
")",
";",
"this",
".",
"setType",
"(",
"notationMap",
".",
"get",
"(",
"\"type\"",
")",
")",
";",
"this",
".",
"setVersion",
"(",
"notationMap",
".",
"get",
"(",
"\"version\"",
")",
")",
";",
"}"
] | Set Maven Project from String notation
@param notation String | [
"Set",
"Maven",
"Project",
"from",
"String",
"notation"
] | 218d8fd36c0b8b6e16d66e5715975570b4560ec4 | https://github.com/mguymon/naether/blob/218d8fd36c0b8b6e16d66e5715975570b4560ec4/src/main/java/com/tobedevoured/naether/maven/Project.java#L278-L284 | train |
mguymon/naether | src/main/java/com/tobedevoured/naether/maven/Project.java | Project.addDependency | public void addDependency(String notation, String scope ) {
Map<String, String> notationMap = Notation.parse(notation);
Dependency dependency = new Dependency();
dependency.setGroupId(notationMap.get("groupId"));
dependency.setArtifactId(notationMap.get("artifactId"));
dependency.setType(notationMap.get("type"));
dependency.setVersion(notationMap.get("version"));
dependency.setScope( scope );
addDependency(dependency);
} | java | public void addDependency(String notation, String scope ) {
Map<String, String> notationMap = Notation.parse(notation);
Dependency dependency = new Dependency();
dependency.setGroupId(notationMap.get("groupId"));
dependency.setArtifactId(notationMap.get("artifactId"));
dependency.setType(notationMap.get("type"));
dependency.setVersion(notationMap.get("version"));
dependency.setScope( scope );
addDependency(dependency);
} | [
"public",
"void",
"addDependency",
"(",
"String",
"notation",
",",
"String",
"scope",
")",
"{",
"Map",
"<",
"String",
",",
"String",
">",
"notationMap",
"=",
"Notation",
".",
"parse",
"(",
"notation",
")",
";",
"Dependency",
"dependency",
"=",
"new",
"Dependency",
"(",
")",
";",
"dependency",
".",
"setGroupId",
"(",
"notationMap",
".",
"get",
"(",
"\"groupId\"",
")",
")",
";",
"dependency",
".",
"setArtifactId",
"(",
"notationMap",
".",
"get",
"(",
"\"artifactId\"",
")",
")",
";",
"dependency",
".",
"setType",
"(",
"notationMap",
".",
"get",
"(",
"\"type\"",
")",
")",
";",
"dependency",
".",
"setVersion",
"(",
"notationMap",
".",
"get",
"(",
"\"version\"",
")",
")",
";",
"dependency",
".",
"setScope",
"(",
"scope",
")",
";",
"addDependency",
"(",
"dependency",
")",
";",
"}"
] | Add a Dependency by String notation
@param notation String
@param scope String | [
"Add",
"a",
"Dependency",
"by",
"String",
"notation"
] | 218d8fd36c0b8b6e16d66e5715975570b4560ec4 | https://github.com/mguymon/naether/blob/218d8fd36c0b8b6e16d66e5715975570b4560ec4/src/main/java/com/tobedevoured/naether/maven/Project.java#L401-L410 | train |
mguymon/naether | src/main/java/com/tobedevoured/naether/maven/Project.java | Project.toXml | public String toXml() throws ProjectException {
log.debug("Writing xml");
Project copy = this;
copy.removeProperty( "project.basedir" );
StringWriter writer = new StringWriter();
MavenXpp3Writer pomWriter = new MavenXpp3Writer();
try {
pomWriter.write(writer, copy.mavenModel);
} catch (IOException e) {
throw new ProjectException("Failed to create pom xml", e);
}
writer.flush();
return writer.toString();
} | java | public String toXml() throws ProjectException {
log.debug("Writing xml");
Project copy = this;
copy.removeProperty( "project.basedir" );
StringWriter writer = new StringWriter();
MavenXpp3Writer pomWriter = new MavenXpp3Writer();
try {
pomWriter.write(writer, copy.mavenModel);
} catch (IOException e) {
throw new ProjectException("Failed to create pom xml", e);
}
writer.flush();
return writer.toString();
} | [
"public",
"String",
"toXml",
"(",
")",
"throws",
"ProjectException",
"{",
"log",
".",
"debug",
"(",
"\"Writing xml\"",
")",
";",
"Project",
"copy",
"=",
"this",
";",
"copy",
".",
"removeProperty",
"(",
"\"project.basedir\"",
")",
";",
"StringWriter",
"writer",
"=",
"new",
"StringWriter",
"(",
")",
";",
"MavenXpp3Writer",
"pomWriter",
"=",
"new",
"MavenXpp3Writer",
"(",
")",
";",
"try",
"{",
"pomWriter",
".",
"write",
"(",
"writer",
",",
"copy",
".",
"mavenModel",
")",
";",
"}",
"catch",
"(",
"IOException",
"e",
")",
"{",
"throw",
"new",
"ProjectException",
"(",
"\"Failed to create pom xml\"",
",",
"e",
")",
";",
"}",
"writer",
".",
"flush",
"(",
")",
";",
"return",
"writer",
".",
"toString",
"(",
")",
";",
"}"
] | Convert Project to POM XML
@return String
@throws ProjectException exception | [
"Convert",
"Project",
"to",
"POM",
"XML"
] | 218d8fd36c0b8b6e16d66e5715975570b4560ec4 | https://github.com/mguymon/naether/blob/218d8fd36c0b8b6e16d66e5715975570b4560ec4/src/main/java/com/tobedevoured/naether/maven/Project.java#L543-L560 | train |
BrunoEberhard/minimal-j | src/main/java/org/minimalj/util/ExceptionUtils.java | ExceptionUtils.logReducedStackTrace | public static void logReducedStackTrace(Logger logger, Exception exception) {
Exception here = new Exception();
String[] hereStrings = getStackFrames(here);
String[] throwableStrings = getStackFrames(exception);
int linesToSkip = 1;
while (throwableStrings.length - linesToSkip > 0 && hereStrings.length - linesToSkip > 0) {
if (!StringUtils.equals(hereStrings[hereStrings.length-linesToSkip], throwableStrings[throwableStrings.length-linesToSkip])) {
break;
}
linesToSkip++;
}
for (int i = 0; i<=throwableStrings.length-linesToSkip; i++) {
logger.log(Level.SEVERE, throwableStrings[i]);
}
} | java | public static void logReducedStackTrace(Logger logger, Exception exception) {
Exception here = new Exception();
String[] hereStrings = getStackFrames(here);
String[] throwableStrings = getStackFrames(exception);
int linesToSkip = 1;
while (throwableStrings.length - linesToSkip > 0 && hereStrings.length - linesToSkip > 0) {
if (!StringUtils.equals(hereStrings[hereStrings.length-linesToSkip], throwableStrings[throwableStrings.length-linesToSkip])) {
break;
}
linesToSkip++;
}
for (int i = 0; i<=throwableStrings.length-linesToSkip; i++) {
logger.log(Level.SEVERE, throwableStrings[i]);
}
} | [
"public",
"static",
"void",
"logReducedStackTrace",
"(",
"Logger",
"logger",
",",
"Exception",
"exception",
")",
"{",
"Exception",
"here",
"=",
"new",
"Exception",
"(",
")",
";",
"String",
"[",
"]",
"hereStrings",
"=",
"getStackFrames",
"(",
"here",
")",
";",
"String",
"[",
"]",
"throwableStrings",
"=",
"getStackFrames",
"(",
"exception",
")",
";",
"int",
"linesToSkip",
"=",
"1",
";",
"while",
"(",
"throwableStrings",
".",
"length",
"-",
"linesToSkip",
">",
"0",
"&&",
"hereStrings",
".",
"length",
"-",
"linesToSkip",
">",
"0",
")",
"{",
"if",
"(",
"!",
"StringUtils",
".",
"equals",
"(",
"hereStrings",
"[",
"hereStrings",
".",
"length",
"-",
"linesToSkip",
"]",
",",
"throwableStrings",
"[",
"throwableStrings",
".",
"length",
"-",
"linesToSkip",
"]",
")",
")",
"{",
"break",
";",
"}",
"linesToSkip",
"++",
";",
"}",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<=",
"throwableStrings",
".",
"length",
"-",
"linesToSkip",
";",
"i",
"++",
")",
"{",
"logger",
".",
"log",
"(",
"Level",
".",
"SEVERE",
",",
"throwableStrings",
"[",
"i",
"]",
")",
";",
"}",
"}"
] | Logs only the relevant part of the stack trace. For example
if a getter fails it's irrelevant if the getter is called
by a swing class or something else
@param logger the logger where the output should go
@param exception the exception to be printed | [
"Logs",
"only",
"the",
"relevant",
"part",
"of",
"the",
"stack",
"trace",
".",
"For",
"example",
"if",
"a",
"getter",
"fails",
"it",
"s",
"irrelevant",
"if",
"the",
"getter",
"is",
"called",
"by",
"a",
"swing",
"class",
"or",
"something",
"else"
] | f7c5461b2b47a10b383aee1e2f1f150f6773703b | https://github.com/BrunoEberhard/minimal-j/blob/f7c5461b2b47a10b383aee1e2f1f150f6773703b/src/main/java/org/minimalj/util/ExceptionUtils.java#L21-L36 | train |
BrunoEberhard/minimal-j | src/main/java/org/minimalj/util/ExceptionUtils.java | ExceptionUtils.getStackTrace | private static String getStackTrace(final Throwable throwable) {
final StringWriter sw = new StringWriter();
final PrintWriter pw = new PrintWriter(sw, true);
throwable.printStackTrace(pw);
return sw.getBuffer().toString();
} | java | private static String getStackTrace(final Throwable throwable) {
final StringWriter sw = new StringWriter();
final PrintWriter pw = new PrintWriter(sw, true);
throwable.printStackTrace(pw);
return sw.getBuffer().toString();
} | [
"private",
"static",
"String",
"getStackTrace",
"(",
"final",
"Throwable",
"throwable",
")",
"{",
"final",
"StringWriter",
"sw",
"=",
"new",
"StringWriter",
"(",
")",
";",
"final",
"PrintWriter",
"pw",
"=",
"new",
"PrintWriter",
"(",
"sw",
",",
"true",
")",
";",
"throwable",
".",
"printStackTrace",
"(",
"pw",
")",
";",
"return",
"sw",
".",
"getBuffer",
"(",
")",
".",
"toString",
"(",
")",
";",
"}"
] | from apache ExceptionUtil | [
"from",
"apache",
"ExceptionUtil"
] | f7c5461b2b47a10b383aee1e2f1f150f6773703b | https://github.com/BrunoEberhard/minimal-j/blob/f7c5461b2b47a10b383aee1e2f1f150f6773703b/src/main/java/org/minimalj/util/ExceptionUtils.java#L39-L44 | train |
mbeiter/util | db/src/main/java/org/beiter/michael/db/DataSourceFactory.java | DataSourceFactory.getDataSource | public static DataSource getDataSource(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 {
// the initial context is created from the provided JNDI settings
final Context context = new InitialContext();
// retrieve a data source object, close the context as it is no longer needed, and return the data source
final Object namedObject = context.lookup(jndiName);
if (DataSource.class.isInstance(namedObject)) {
final DataSource dataSource = (DataSource) context.lookup(jndiName);
context.close();
return dataSource;
} else {
final String error = "The JNDI name '" + jndiName + "' does not reference a SQL DataSource."
+ " This is a configuration issue.";
LOG.warn(error);
throw new FactoryException(error);
}
} catch (NamingException e) {
final String error = "Error retrieving JDBC date source from JNDI: " + jndiName;
LOG.warn(error);
throw new FactoryException(error, e);
}
} | java | public static DataSource getDataSource(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 {
// the initial context is created from the provided JNDI settings
final Context context = new InitialContext();
// retrieve a data source object, close the context as it is no longer needed, and return the data source
final Object namedObject = context.lookup(jndiName);
if (DataSource.class.isInstance(namedObject)) {
final DataSource dataSource = (DataSource) context.lookup(jndiName);
context.close();
return dataSource;
} else {
final String error = "The JNDI name '" + jndiName + "' does not reference a SQL DataSource."
+ " This is a configuration issue.";
LOG.warn(error);
throw new FactoryException(error);
}
} catch (NamingException e) {
final String error = "Error retrieving JDBC date source from JNDI: " + jndiName;
LOG.warn(error);
throw new FactoryException(error, e);
}
} | [
"public",
"static",
"DataSource",
"getDataSource",
"(",
"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",
"{",
"// the initial context is created from the provided JNDI settings",
"final",
"Context",
"context",
"=",
"new",
"InitialContext",
"(",
")",
";",
"// retrieve a data source object, close the context as it is no longer needed, and return the data source",
"final",
"Object",
"namedObject",
"=",
"context",
".",
"lookup",
"(",
"jndiName",
")",
";",
"if",
"(",
"DataSource",
".",
"class",
".",
"isInstance",
"(",
"namedObject",
")",
")",
"{",
"final",
"DataSource",
"dataSource",
"=",
"(",
"DataSource",
")",
"context",
".",
"lookup",
"(",
"jndiName",
")",
";",
"context",
".",
"close",
"(",
")",
";",
"return",
"dataSource",
";",
"}",
"else",
"{",
"final",
"String",
"error",
"=",
"\"The JNDI name '\"",
"+",
"jndiName",
"+",
"\"' does not reference a SQL DataSource.\"",
"+",
"\" This is a configuration issue.\"",
";",
"LOG",
".",
"warn",
"(",
"error",
")",
";",
"throw",
"new",
"FactoryException",
"(",
"error",
")",
";",
"}",
"}",
"catch",
"(",
"NamingException",
"e",
")",
"{",
"final",
"String",
"error",
"=",
"\"Error retrieving JDBC date source from JNDI: \"",
"+",
"jndiName",
";",
"LOG",
".",
"warn",
"(",
"error",
")",
";",
"throw",
"new",
"FactoryException",
"(",
"error",
",",
"e",
")",
";",
"}",
"}"
] | Return a DataSource instance for a JNDI managed JDBC data source.
@param jndiName The JNDI connection name
@return a JDBC data source
@throws FactoryException When no date source can be retrieved from JNDI
@throws NullPointerException When {@code jndiName} is null
@throws IllegalArgumentException When {@code jndiName} is empty | [
"Return",
"a",
"DataSource",
"instance",
"for",
"a",
"JNDI",
"managed",
"JDBC",
"data",
"source",
"."
] | 490fcebecb936e00c2f2ce2096b679b2fd10865e | https://github.com/mbeiter/util/blob/490fcebecb936e00c2f2ce2096b679b2fd10865e/db/src/main/java/org/beiter/michael/db/DataSourceFactory.java#L89-L118 | train |
mbeiter/util | db/src/main/java/org/beiter/michael/db/DataSourceFactory.java | DataSourceFactory.loadDriver | private static void loadDriver(final String driver) throws FactoryException {
// assert in private method
assert driver != null : "The driver cannot be null";
LOG.debug("Loading the database driver '" + driver + "'");
// make sure the driver is available
try {
Class.forName(driver);
} catch (ClassNotFoundException e) {
final String error = "Error loading JDBC driver class: " + driver;
LOG.warn(error, e);
throw new FactoryException(error, e);
}
} | java | private static void loadDriver(final String driver) throws FactoryException {
// assert in private method
assert driver != null : "The driver cannot be null";
LOG.debug("Loading the database driver '" + driver + "'");
// make sure the driver is available
try {
Class.forName(driver);
} catch (ClassNotFoundException e) {
final String error = "Error loading JDBC driver class: " + driver;
LOG.warn(error, e);
throw new FactoryException(error, e);
}
} | [
"private",
"static",
"void",
"loadDriver",
"(",
"final",
"String",
"driver",
")",
"throws",
"FactoryException",
"{",
"// assert in private method",
"assert",
"driver",
"!=",
"null",
":",
"\"The driver cannot be null\"",
";",
"LOG",
".",
"debug",
"(",
"\"Loading the database driver '\"",
"+",
"driver",
"+",
"\"'\"",
")",
";",
"// make sure the driver is available",
"try",
"{",
"Class",
".",
"forName",
"(",
"driver",
")",
";",
"}",
"catch",
"(",
"ClassNotFoundException",
"e",
")",
"{",
"final",
"String",
"error",
"=",
"\"Error loading JDBC driver class: \"",
"+",
"driver",
";",
"LOG",
".",
"warn",
"(",
"error",
",",
"e",
")",
";",
"throw",
"new",
"FactoryException",
"(",
"error",
",",
"e",
")",
";",
"}",
"}"
] | Make sure that the database driver exists
@param driver The JDBC driver class to load
@throws FactoryException When the driver cannot be loaded | [
"Make",
"sure",
"that",
"the",
"database",
"driver",
"exists"
] | 490fcebecb936e00c2f2ce2096b679b2fd10865e | https://github.com/mbeiter/util/blob/490fcebecb936e00c2f2ce2096b679b2fd10865e/db/src/main/java/org/beiter/michael/db/DataSourceFactory.java#L211-L226 | train |
mbeiter/util | db/src/main/java/org/beiter/michael/db/DataSourceFactory.java | DataSourceFactory.getPoolingDataSource | private static PoolingDataSource<PoolableConnection> getPoolingDataSource(final String url,
final ConcurrentMap<String, String> properties,
final ConnectionProperties poolSpec) {
// assert in private method
assert url != null : "The url cannot be null";
assert properties != null : "The properties cannot be null";
assert poolSpec != null : "The pol spec cannot be null";
LOG.debug("Creating new pooled data source for '" + url + "'");
// convert the properties hashmap to java properties
final Properties props = new Properties();
props.putAll(properties);
// create a Apache DBCP pool configuration from the pool spec
final GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
poolConfig.setMaxTotal(poolSpec.getMaxTotal());
poolConfig.setMaxIdle(poolSpec.getMaxIdle());
poolConfig.setMinIdle(poolSpec.getMinIdle());
poolConfig.setMaxWaitMillis(poolSpec.getMaxWaitMillis());
poolConfig.setTestOnCreate(poolSpec.isTestOnCreate());
poolConfig.setTestOnBorrow(poolSpec.isTestOnBorrow());
poolConfig.setTestOnReturn(poolSpec.isTestOnReturn());
poolConfig.setTestWhileIdle(poolSpec.isTestWhileIdle());
poolConfig.setTimeBetweenEvictionRunsMillis(poolSpec.getTimeBetweenEvictionRunsMillis());
poolConfig.setNumTestsPerEvictionRun(poolSpec.getNumTestsPerEvictionRun());
poolConfig.setMinEvictableIdleTimeMillis(poolSpec.getMinEvictableIdleTimeMillis());
poolConfig.setSoftMinEvictableIdleTimeMillis(poolSpec.getSoftMinEvictableIdleTimeMillis());
poolConfig.setLifo(poolSpec.isLifo());
// create the pool and assign the factory to the pool
final org.apache.commons.dbcp2.ConnectionFactory connFactory = new DriverManagerConnectionFactory(url, props);
final PoolableConnectionFactory poolConnFactory = new PoolableConnectionFactory(connFactory, null);
poolConnFactory.setDefaultAutoCommit(poolSpec.isDefaultAutoCommit());
poolConnFactory.setDefaultReadOnly(poolSpec.isDefaultReadOnly());
poolConnFactory.setDefaultTransactionIsolation(poolSpec.getDefaultTransactionIsolation());
poolConnFactory.setCacheState(poolSpec.isCacheState());
poolConnFactory.setValidationQuery(poolSpec.getValidationQuery());
poolConnFactory.setMaxConnLifetimeMillis(poolSpec.getMaxConnLifetimeMillis());
final GenericObjectPool<PoolableConnection> connPool = new GenericObjectPool<>(poolConnFactory, poolConfig);
poolConnFactory.setPool(connPool);
// create a new pooled data source
return new PoolingDataSource<>(connPool);
} | java | private static PoolingDataSource<PoolableConnection> getPoolingDataSource(final String url,
final ConcurrentMap<String, String> properties,
final ConnectionProperties poolSpec) {
// assert in private method
assert url != null : "The url cannot be null";
assert properties != null : "The properties cannot be null";
assert poolSpec != null : "The pol spec cannot be null";
LOG.debug("Creating new pooled data source for '" + url + "'");
// convert the properties hashmap to java properties
final Properties props = new Properties();
props.putAll(properties);
// create a Apache DBCP pool configuration from the pool spec
final GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
poolConfig.setMaxTotal(poolSpec.getMaxTotal());
poolConfig.setMaxIdle(poolSpec.getMaxIdle());
poolConfig.setMinIdle(poolSpec.getMinIdle());
poolConfig.setMaxWaitMillis(poolSpec.getMaxWaitMillis());
poolConfig.setTestOnCreate(poolSpec.isTestOnCreate());
poolConfig.setTestOnBorrow(poolSpec.isTestOnBorrow());
poolConfig.setTestOnReturn(poolSpec.isTestOnReturn());
poolConfig.setTestWhileIdle(poolSpec.isTestWhileIdle());
poolConfig.setTimeBetweenEvictionRunsMillis(poolSpec.getTimeBetweenEvictionRunsMillis());
poolConfig.setNumTestsPerEvictionRun(poolSpec.getNumTestsPerEvictionRun());
poolConfig.setMinEvictableIdleTimeMillis(poolSpec.getMinEvictableIdleTimeMillis());
poolConfig.setSoftMinEvictableIdleTimeMillis(poolSpec.getSoftMinEvictableIdleTimeMillis());
poolConfig.setLifo(poolSpec.isLifo());
// create the pool and assign the factory to the pool
final org.apache.commons.dbcp2.ConnectionFactory connFactory = new DriverManagerConnectionFactory(url, props);
final PoolableConnectionFactory poolConnFactory = new PoolableConnectionFactory(connFactory, null);
poolConnFactory.setDefaultAutoCommit(poolSpec.isDefaultAutoCommit());
poolConnFactory.setDefaultReadOnly(poolSpec.isDefaultReadOnly());
poolConnFactory.setDefaultTransactionIsolation(poolSpec.getDefaultTransactionIsolation());
poolConnFactory.setCacheState(poolSpec.isCacheState());
poolConnFactory.setValidationQuery(poolSpec.getValidationQuery());
poolConnFactory.setMaxConnLifetimeMillis(poolSpec.getMaxConnLifetimeMillis());
final GenericObjectPool<PoolableConnection> connPool = new GenericObjectPool<>(poolConnFactory, poolConfig);
poolConnFactory.setPool(connPool);
// create a new pooled data source
return new PoolingDataSource<>(connPool);
} | [
"private",
"static",
"PoolingDataSource",
"<",
"PoolableConnection",
">",
"getPoolingDataSource",
"(",
"final",
"String",
"url",
",",
"final",
"ConcurrentMap",
"<",
"String",
",",
"String",
">",
"properties",
",",
"final",
"ConnectionProperties",
"poolSpec",
")",
"{",
"// assert in private method",
"assert",
"url",
"!=",
"null",
":",
"\"The url cannot be null\"",
";",
"assert",
"properties",
"!=",
"null",
":",
"\"The properties cannot be null\"",
";",
"assert",
"poolSpec",
"!=",
"null",
":",
"\"The pol spec cannot be null\"",
";",
"LOG",
".",
"debug",
"(",
"\"Creating new pooled data source for '\"",
"+",
"url",
"+",
"\"'\"",
")",
";",
"// convert the properties hashmap to java properties",
"final",
"Properties",
"props",
"=",
"new",
"Properties",
"(",
")",
";",
"props",
".",
"putAll",
"(",
"properties",
")",
";",
"// create a Apache DBCP pool configuration from the pool spec",
"final",
"GenericObjectPoolConfig",
"poolConfig",
"=",
"new",
"GenericObjectPoolConfig",
"(",
")",
";",
"poolConfig",
".",
"setMaxTotal",
"(",
"poolSpec",
".",
"getMaxTotal",
"(",
")",
")",
";",
"poolConfig",
".",
"setMaxIdle",
"(",
"poolSpec",
".",
"getMaxIdle",
"(",
")",
")",
";",
"poolConfig",
".",
"setMinIdle",
"(",
"poolSpec",
".",
"getMinIdle",
"(",
")",
")",
";",
"poolConfig",
".",
"setMaxWaitMillis",
"(",
"poolSpec",
".",
"getMaxWaitMillis",
"(",
")",
")",
";",
"poolConfig",
".",
"setTestOnCreate",
"(",
"poolSpec",
".",
"isTestOnCreate",
"(",
")",
")",
";",
"poolConfig",
".",
"setTestOnBorrow",
"(",
"poolSpec",
".",
"isTestOnBorrow",
"(",
")",
")",
";",
"poolConfig",
".",
"setTestOnReturn",
"(",
"poolSpec",
".",
"isTestOnReturn",
"(",
")",
")",
";",
"poolConfig",
".",
"setTestWhileIdle",
"(",
"poolSpec",
".",
"isTestWhileIdle",
"(",
")",
")",
";",
"poolConfig",
".",
"setTimeBetweenEvictionRunsMillis",
"(",
"poolSpec",
".",
"getTimeBetweenEvictionRunsMillis",
"(",
")",
")",
";",
"poolConfig",
".",
"setNumTestsPerEvictionRun",
"(",
"poolSpec",
".",
"getNumTestsPerEvictionRun",
"(",
")",
")",
";",
"poolConfig",
".",
"setMinEvictableIdleTimeMillis",
"(",
"poolSpec",
".",
"getMinEvictableIdleTimeMillis",
"(",
")",
")",
";",
"poolConfig",
".",
"setSoftMinEvictableIdleTimeMillis",
"(",
"poolSpec",
".",
"getSoftMinEvictableIdleTimeMillis",
"(",
")",
")",
";",
"poolConfig",
".",
"setLifo",
"(",
"poolSpec",
".",
"isLifo",
"(",
")",
")",
";",
"// create the pool and assign the factory to the pool",
"final",
"org",
".",
"apache",
".",
"commons",
".",
"dbcp2",
".",
"ConnectionFactory",
"connFactory",
"=",
"new",
"DriverManagerConnectionFactory",
"(",
"url",
",",
"props",
")",
";",
"final",
"PoolableConnectionFactory",
"poolConnFactory",
"=",
"new",
"PoolableConnectionFactory",
"(",
"connFactory",
",",
"null",
")",
";",
"poolConnFactory",
".",
"setDefaultAutoCommit",
"(",
"poolSpec",
".",
"isDefaultAutoCommit",
"(",
")",
")",
";",
"poolConnFactory",
".",
"setDefaultReadOnly",
"(",
"poolSpec",
".",
"isDefaultReadOnly",
"(",
")",
")",
";",
"poolConnFactory",
".",
"setDefaultTransactionIsolation",
"(",
"poolSpec",
".",
"getDefaultTransactionIsolation",
"(",
")",
")",
";",
"poolConnFactory",
".",
"setCacheState",
"(",
"poolSpec",
".",
"isCacheState",
"(",
")",
")",
";",
"poolConnFactory",
".",
"setValidationQuery",
"(",
"poolSpec",
".",
"getValidationQuery",
"(",
")",
")",
";",
"poolConnFactory",
".",
"setMaxConnLifetimeMillis",
"(",
"poolSpec",
".",
"getMaxConnLifetimeMillis",
"(",
")",
")",
";",
"final",
"GenericObjectPool",
"<",
"PoolableConnection",
">",
"connPool",
"=",
"new",
"GenericObjectPool",
"<>",
"(",
"poolConnFactory",
",",
"poolConfig",
")",
";",
"poolConnFactory",
".",
"setPool",
"(",
"connPool",
")",
";",
"// create a new pooled data source",
"return",
"new",
"PoolingDataSource",
"<>",
"(",
"connPool",
")",
";",
"}"
] | Get a pooled data source for the provided connection parameters.
@param url The JDBC database URL of the form <code>jdbc:subprotocol:subname</code>
@param properties A list of key/value configuration parameters to pass as connection arguments. Normally at
least a "user" and "password" property should be included
@param poolSpec A connection pool spec
@return A pooled database connection | [
"Get",
"a",
"pooled",
"data",
"source",
"for",
"the",
"provided",
"connection",
"parameters",
"."
] | 490fcebecb936e00c2f2ce2096b679b2fd10865e | https://github.com/mbeiter/util/blob/490fcebecb936e00c2f2ce2096b679b2fd10865e/db/src/main/java/org/beiter/michael/db/DataSourceFactory.java#L237-L283 | train |
mguymon/naether | src/main/java/com/tobedevoured/naether/util/Notation.java | Notation.getLocalPaths | public static List<String> getLocalPaths( String localRepoPath, List<String> notations ) throws NaetherException {
DefaultServiceLocator locator = new DefaultServiceLocator();
SimpleLocalRepositoryManagerFactory factory = new SimpleLocalRepositoryManagerFactory();
factory.initService( locator );
LocalRepository localRepo = new LocalRepository(localRepoPath);
LocalRepositoryManager manager = null;
try {
manager = factory.newInstance( localRepo );
} catch (NoLocalRepositoryManagerException e) {
throw new NaetherException( "Failed to initial local repository manage", e );
}
List<String> localPaths = new ArrayList<String>();
for ( String notation : notations ) {
Dependency dependency = new Dependency(new DefaultArtifact(notation), "compile");
File path = new File( localRepo.getBasedir(), manager.getPathForLocalArtifact( dependency.getArtifact() ) );
localPaths.add( path.toString() );
}
return localPaths;
} | java | public static List<String> getLocalPaths( String localRepoPath, List<String> notations ) throws NaetherException {
DefaultServiceLocator locator = new DefaultServiceLocator();
SimpleLocalRepositoryManagerFactory factory = new SimpleLocalRepositoryManagerFactory();
factory.initService( locator );
LocalRepository localRepo = new LocalRepository(localRepoPath);
LocalRepositoryManager manager = null;
try {
manager = factory.newInstance( localRepo );
} catch (NoLocalRepositoryManagerException e) {
throw new NaetherException( "Failed to initial local repository manage", e );
}
List<String> localPaths = new ArrayList<String>();
for ( String notation : notations ) {
Dependency dependency = new Dependency(new DefaultArtifact(notation), "compile");
File path = new File( localRepo.getBasedir(), manager.getPathForLocalArtifact( dependency.getArtifact() ) );
localPaths.add( path.toString() );
}
return localPaths;
} | [
"public",
"static",
"List",
"<",
"String",
">",
"getLocalPaths",
"(",
"String",
"localRepoPath",
",",
"List",
"<",
"String",
">",
"notations",
")",
"throws",
"NaetherException",
"{",
"DefaultServiceLocator",
"locator",
"=",
"new",
"DefaultServiceLocator",
"(",
")",
";",
"SimpleLocalRepositoryManagerFactory",
"factory",
"=",
"new",
"SimpleLocalRepositoryManagerFactory",
"(",
")",
";",
"factory",
".",
"initService",
"(",
"locator",
")",
";",
"LocalRepository",
"localRepo",
"=",
"new",
"LocalRepository",
"(",
"localRepoPath",
")",
";",
"LocalRepositoryManager",
"manager",
"=",
"null",
";",
"try",
"{",
"manager",
"=",
"factory",
".",
"newInstance",
"(",
"localRepo",
")",
";",
"}",
"catch",
"(",
"NoLocalRepositoryManagerException",
"e",
")",
"{",
"throw",
"new",
"NaetherException",
"(",
"\"Failed to initial local repository manage\"",
",",
"e",
")",
";",
"}",
"List",
"<",
"String",
">",
"localPaths",
"=",
"new",
"ArrayList",
"<",
"String",
">",
"(",
")",
";",
"for",
"(",
"String",
"notation",
":",
"notations",
")",
"{",
"Dependency",
"dependency",
"=",
"new",
"Dependency",
"(",
"new",
"DefaultArtifact",
"(",
"notation",
")",
",",
"\"compile\"",
")",
";",
"File",
"path",
"=",
"new",
"File",
"(",
"localRepo",
".",
"getBasedir",
"(",
")",
",",
"manager",
".",
"getPathForLocalArtifact",
"(",
"dependency",
".",
"getArtifact",
"(",
")",
")",
")",
";",
"localPaths",
".",
"add",
"(",
"path",
".",
"toString",
"(",
")",
")",
";",
"}",
"return",
"localPaths",
";",
"}"
] | Get local paths for notations
@param localRepoPath String path
@param notations List of notations
@return List of paths
@throws NaetherException exception | [
"Get",
"local",
"paths",
"for",
"notations"
] | 218d8fd36c0b8b6e16d66e5715975570b4560ec4 | https://github.com/mguymon/naether/blob/218d8fd36c0b8b6e16d66e5715975570b4560ec4/src/main/java/com/tobedevoured/naether/util/Notation.java#L211-L233 | train |
aseovic/coherence-tools | loader/src/main/java/com/seovic/loader/source/JpaSource.java | JpaSource.iterator | public Iterator iterator()
{
Query readAll = m_em.createQuery(
createReadAllQuery(m_entityClass.getSimpleName()));
return new JpaIterator(readAll, m_batchSize);
} | java | public Iterator iterator()
{
Query readAll = m_em.createQuery(
createReadAllQuery(m_entityClass.getSimpleName()));
return new JpaIterator(readAll, m_batchSize);
} | [
"public",
"Iterator",
"iterator",
"(",
")",
"{",
"Query",
"readAll",
"=",
"m_em",
".",
"createQuery",
"(",
"createReadAllQuery",
"(",
"m_entityClass",
".",
"getSimpleName",
"(",
")",
")",
")",
";",
"return",
"new",
"JpaIterator",
"(",
"readAll",
",",
"m_batchSize",
")",
";",
"}"
] | Return an iterator that iterates over this source.
@return a source iterator
@see JpaIterator | [
"Return",
"an",
"iterator",
"that",
"iterates",
"over",
"this",
"source",
"."
] | 561a1d7e572ad98657fcd26beb1164891b0cd6fe | https://github.com/aseovic/coherence-tools/blob/561a1d7e572ad98657fcd26beb1164891b0cd6fe/loader/src/main/java/com/seovic/loader/source/JpaSource.java#L93-L98 | train |
openengsb/openengsb | api/workflow/src/main/java/org/openengsb/core/workflow/api/model/ProcessBag.java | ProcessBag.addProperty | public void addProperty(String key, Object value) throws ProcessBagException {
if (properties.containsKey(key)) {
throw new ProcessBagException(key + " already used!");
} else {
properties.put(key, value);
}
} | java | public void addProperty(String key, Object value) throws ProcessBagException {
if (properties.containsKey(key)) {
throw new ProcessBagException(key + " already used!");
} else {
properties.put(key, value);
}
} | [
"public",
"void",
"addProperty",
"(",
"String",
"key",
",",
"Object",
"value",
")",
"throws",
"ProcessBagException",
"{",
"if",
"(",
"properties",
".",
"containsKey",
"(",
"key",
")",
")",
"{",
"throw",
"new",
"ProcessBagException",
"(",
"key",
"+",
"\" already used!\"",
")",
";",
"}",
"else",
"{",
"properties",
".",
"put",
"(",
"key",
",",
"value",
")",
";",
"}",
"}"
] | Adds a new property only if it does not exist already
@throws ProcessBagException if the key is already present | [
"Adds",
"a",
"new",
"property",
"only",
"if",
"it",
"does",
"not",
"exist",
"already"
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/api/workflow/src/main/java/org/openengsb/core/workflow/api/model/ProcessBag.java#L134-L140 | train |
FedericoPecora/meta-csp-framework | src/main/java/org/metacsp/time/qualitative/SimpleInterval.java | SimpleInterval.compareTo | @Override
public int compareTo(Object arg0) {
if (arg0 instanceof SimpleInterval) {
SimpleInterval that = (SimpleInterval)arg0;
return intervalName.compareTo(that.getIntervalName());
}
return 0;
} | java | @Override
public int compareTo(Object arg0) {
if (arg0 instanceof SimpleInterval) {
SimpleInterval that = (SimpleInterval)arg0;
return intervalName.compareTo(that.getIntervalName());
}
return 0;
} | [
"@",
"Override",
"public",
"int",
"compareTo",
"(",
"Object",
"arg0",
")",
"{",
"if",
"(",
"arg0",
"instanceof",
"SimpleInterval",
")",
"{",
"SimpleInterval",
"that",
"=",
"(",
"SimpleInterval",
")",
"arg0",
";",
"return",
"intervalName",
".",
"compareTo",
"(",
"that",
".",
"getIntervalName",
"(",
")",
")",
";",
"}",
"return",
"0",
";",
"}"
] | Comapres this to another Interval
@return {@code 1} if this Interval's lower bound is lower than the argument's, {@code 0} if they are the same, {@code 1} otherwise | [
"Comapres",
"this",
"to",
"another",
"Interval"
] | 42aaef2e2b76d0f738427f0dd9653c4f62b40517 | https://github.com/FedericoPecora/meta-csp-framework/blob/42aaef2e2b76d0f738427f0dd9653c4f62b40517/src/main/java/org/metacsp/time/qualitative/SimpleInterval.java#L75-L82 | train |
BrunoEberhard/minimal-j | src/main/java/org/minimalj/application/Application.java | Application.initApplication | public static void initApplication(String... args) {
if (args.length < 1) {
System.err.println("Please specify an Application as argument");
System.exit(-1);
}
setInstance(createApplicationByClassName(args[0]));
} | java | public static void initApplication(String... args) {
if (args.length < 1) {
System.err.println("Please specify an Application as argument");
System.exit(-1);
}
setInstance(createApplicationByClassName(args[0]));
} | [
"public",
"static",
"void",
"initApplication",
"(",
"String",
"...",
"args",
")",
"{",
"if",
"(",
"args",
".",
"length",
"<",
"1",
")",
"{",
"System",
".",
"err",
".",
"println",
"(",
"\"Please specify an Application as argument\"",
")",
";",
"System",
".",
"exit",
"(",
"-",
"1",
")",
";",
"}",
"setInstance",
"(",
"createApplicationByClassName",
"(",
"args",
"[",
"0",
"]",
")",
")",
";",
"}"
] | This is just a shortcut for creating the application from jvm arguments.
Most frontend main classes use this method
@param args the arguments provided to the jvm | [
"This",
"is",
"just",
"a",
"shortcut",
"for",
"creating",
"the",
"application",
"from",
"jvm",
"arguments",
".",
"Most",
"frontend",
"main",
"classes",
"use",
"this",
"method"
] | f7c5461b2b47a10b383aee1e2f1f150f6773703b | https://github.com/BrunoEberhard/minimal-j/blob/f7c5461b2b47a10b383aee1e2f1f150f6773703b/src/main/java/org/minimalj/application/Application.java#L107-L113 | train |
FedericoPecora/meta-csp-framework | src/main/java/org/metacsp/utility/Permutation.java | Permutation.next | public int[] next() {
if (!hasNext) return null;
int[] result = new int[r];
for (int i=0; i<r; i++) result[i] = index[i];
moveIndex();
return result;
} | java | public int[] next() {
if (!hasNext) return null;
int[] result = new int[r];
for (int i=0; i<r; i++) result[i] = index[i];
moveIndex();
return result;
} | [
"public",
"int",
"[",
"]",
"next",
"(",
")",
"{",
"if",
"(",
"!",
"hasNext",
")",
"return",
"null",
";",
"int",
"[",
"]",
"result",
"=",
"new",
"int",
"[",
"r",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"r",
";",
"i",
"++",
")",
"result",
"[",
"i",
"]",
"=",
"index",
"[",
"i",
"]",
";",
"moveIndex",
"(",
")",
";",
"return",
"result",
";",
"}"
] | Get the next permutation.
@return The next permutation, <code>null</code> if none exists. | [
"Get",
"the",
"next",
"permutation",
"."
] | 42aaef2e2b76d0f738427f0dd9653c4f62b40517 | https://github.com/FedericoPecora/meta-csp-framework/blob/42aaef2e2b76d0f738427f0dd9653c4f62b40517/src/main/java/org/metacsp/utility/Permutation.java#L66-L72 | train |
FedericoPecora/meta-csp-framework | src/main/java/org/metacsp/utility/Permutation.java | Permutation.reverseAfter | private void reverseAfter(int i) {
int start = i+1;
int end = n-1;
while (start < end) {
swap(index,start,end);
start++;
end--;
}
} | java | private void reverseAfter(int i) {
int start = i+1;
int end = n-1;
while (start < end) {
swap(index,start,end);
start++;
end--;
}
} | [
"private",
"void",
"reverseAfter",
"(",
"int",
"i",
")",
"{",
"int",
"start",
"=",
"i",
"+",
"1",
";",
"int",
"end",
"=",
"n",
"-",
"1",
";",
"while",
"(",
"start",
"<",
"end",
")",
"{",
"swap",
"(",
"index",
",",
"start",
",",
"end",
")",
";",
"start",
"++",
";",
"end",
"--",
";",
"}",
"}"
] | Reverse the index elements to the right of the specified index. | [
"Reverse",
"the",
"index",
"elements",
"to",
"the",
"right",
"of",
"the",
"specified",
"index",
"."
] | 42aaef2e2b76d0f738427f0dd9653c4f62b40517 | https://github.com/FedericoPecora/meta-csp-framework/blob/42aaef2e2b76d0f738427f0dd9653c4f62b40517/src/main/java/org/metacsp/utility/Permutation.java#L75-L83 | train |
FedericoPecora/meta-csp-framework | src/main/java/org/metacsp/utility/Permutation.java | Permutation.rightmostDip | private int rightmostDip() {
for (int i=n-2; i>=0; i--)
if (index[i] < index[i+1])
return i;
return -1;
} | java | private int rightmostDip() {
for (int i=n-2; i>=0; i--)
if (index[i] < index[i+1])
return i;
return -1;
} | [
"private",
"int",
"rightmostDip",
"(",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"n",
"-",
"2",
";",
"i",
">=",
"0",
";",
"i",
"--",
")",
"if",
"(",
"index",
"[",
"i",
"]",
"<",
"index",
"[",
"i",
"+",
"1",
"]",
")",
"return",
"i",
";",
"return",
"-",
"1",
";",
"}"
] | that is less than its neighbor on the right. | [
"that",
"is",
"less",
"than",
"its",
"neighbor",
"on",
"the",
"right",
"."
] | 42aaef2e2b76d0f738427f0dd9653c4f62b40517 | https://github.com/FedericoPecora/meta-csp-framework/blob/42aaef2e2b76d0f738427f0dd9653c4f62b40517/src/main/java/org/metacsp/utility/Permutation.java#L87-L92 | train |
FedericoPecora/meta-csp-framework | src/main/java/org/metacsp/fuzzyAllenInterval/FuzzyAllenIntervalConstraint.java | FuzzyAllenIntervalConstraint.getInversePossibilities | public HashMap<Type, Double> getInversePossibilities() {
HashMap<Type, Double> ret = new HashMap<Type, Double>();
for (Type t : Type.values()) ret.put(t, 0.0);
for (Type t : types) {
//??? IS THIS CORRECT ??? --> Seems correct
//get inverse of each relation that is 1.0
Type inverseRelation = FuzzyAllenIntervalConstraint.getInverseRelation(t);
HashMap<FuzzyAllenIntervalConstraint.Type, Double> possibilities = this.getPossibilities();
//set poss of each inverse relation to 1.0
ret.put(inverseRelation, possibilities.get(t));
//calculate the Freksa N of each inverse relation
HashMap<FuzzyAllenIntervalConstraint.Type, Double> fr = new HashMap<FuzzyAllenIntervalConstraint.Type, Double>();
for(int i = 0; i < FuzzyAllenIntervalConstraint.freksa_neighbor[inverseRelation.ordinal()].length; i++)
fr.put(FuzzyAllenIntervalConstraint.lookupTypeByInt(i), FuzzyAllenIntervalConstraint.getPossibilityDegree(FuzzyAllenIntervalConstraint.freksa_neighbor[inverseRelation.ordinal()][i]));
//take the maximum between calculated Freksa N and previously added possibilities
//(because this is an OR)
for(FuzzyAllenIntervalConstraint.Type t1: fr.keySet())
ret.put(t1, Math.max(ret.get(t1), fr.get(t1)));
}
/*
System.out.println("=====================================");
System.out.println("DIRECT " + this + ":\n" + this.possibilities);
System.out.println("INVERSE:\n" + ret);
System.out.println("=====================================");
*/
return ret;
} | java | public HashMap<Type, Double> getInversePossibilities() {
HashMap<Type, Double> ret = new HashMap<Type, Double>();
for (Type t : Type.values()) ret.put(t, 0.0);
for (Type t : types) {
//??? IS THIS CORRECT ??? --> Seems correct
//get inverse of each relation that is 1.0
Type inverseRelation = FuzzyAllenIntervalConstraint.getInverseRelation(t);
HashMap<FuzzyAllenIntervalConstraint.Type, Double> possibilities = this.getPossibilities();
//set poss of each inverse relation to 1.0
ret.put(inverseRelation, possibilities.get(t));
//calculate the Freksa N of each inverse relation
HashMap<FuzzyAllenIntervalConstraint.Type, Double> fr = new HashMap<FuzzyAllenIntervalConstraint.Type, Double>();
for(int i = 0; i < FuzzyAllenIntervalConstraint.freksa_neighbor[inverseRelation.ordinal()].length; i++)
fr.put(FuzzyAllenIntervalConstraint.lookupTypeByInt(i), FuzzyAllenIntervalConstraint.getPossibilityDegree(FuzzyAllenIntervalConstraint.freksa_neighbor[inverseRelation.ordinal()][i]));
//take the maximum between calculated Freksa N and previously added possibilities
//(because this is an OR)
for(FuzzyAllenIntervalConstraint.Type t1: fr.keySet())
ret.put(t1, Math.max(ret.get(t1), fr.get(t1)));
}
/*
System.out.println("=====================================");
System.out.println("DIRECT " + this + ":\n" + this.possibilities);
System.out.println("INVERSE:\n" + ret);
System.out.println("=====================================");
*/
return ret;
} | [
"public",
"HashMap",
"<",
"Type",
",",
"Double",
">",
"getInversePossibilities",
"(",
")",
"{",
"HashMap",
"<",
"Type",
",",
"Double",
">",
"ret",
"=",
"new",
"HashMap",
"<",
"Type",
",",
"Double",
">",
"(",
")",
";",
"for",
"(",
"Type",
"t",
":",
"Type",
".",
"values",
"(",
")",
")",
"ret",
".",
"put",
"(",
"t",
",",
"0.0",
")",
";",
"for",
"(",
"Type",
"t",
":",
"types",
")",
"{",
"//??? IS THIS CORRECT ??? --> Seems correct\r",
"//get inverse of each relation that is 1.0 \r",
"Type",
"inverseRelation",
"=",
"FuzzyAllenIntervalConstraint",
".",
"getInverseRelation",
"(",
"t",
")",
";",
"HashMap",
"<",
"FuzzyAllenIntervalConstraint",
".",
"Type",
",",
"Double",
">",
"possibilities",
"=",
"this",
".",
"getPossibilities",
"(",
")",
";",
"//set poss of each inverse relation to 1.0\r",
"ret",
".",
"put",
"(",
"inverseRelation",
",",
"possibilities",
".",
"get",
"(",
"t",
")",
")",
";",
"//calculate the Freksa N of each inverse relation\r",
"HashMap",
"<",
"FuzzyAllenIntervalConstraint",
".",
"Type",
",",
"Double",
">",
"fr",
"=",
"new",
"HashMap",
"<",
"FuzzyAllenIntervalConstraint",
".",
"Type",
",",
"Double",
">",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"FuzzyAllenIntervalConstraint",
".",
"freksa_neighbor",
"[",
"inverseRelation",
".",
"ordinal",
"(",
")",
"]",
".",
"length",
";",
"i",
"++",
")",
"fr",
".",
"put",
"(",
"FuzzyAllenIntervalConstraint",
".",
"lookupTypeByInt",
"(",
"i",
")",
",",
"FuzzyAllenIntervalConstraint",
".",
"getPossibilityDegree",
"(",
"FuzzyAllenIntervalConstraint",
".",
"freksa_neighbor",
"[",
"inverseRelation",
".",
"ordinal",
"(",
")",
"]",
"[",
"i",
"]",
")",
")",
";",
"//take the maximum between calculated Freksa N and previously added possibilities\r",
"//(because this is an OR)\r",
"for",
"(",
"FuzzyAllenIntervalConstraint",
".",
"Type",
"t1",
":",
"fr",
".",
"keySet",
"(",
")",
")",
"ret",
".",
"put",
"(",
"t1",
",",
"Math",
".",
"max",
"(",
"ret",
".",
"get",
"(",
"t1",
")",
",",
"fr",
".",
"get",
"(",
"t1",
")",
")",
")",
";",
"}",
"/*\r\n\t\tSystem.out.println(\"=====================================\");\r\n\t\tSystem.out.println(\"DIRECT \" + this + \":\\n\" + this.possibilities);\r\n\t\tSystem.out.println(\"INVERSE:\\n\" + ret);\r\n\t\tSystem.out.println(\"=====================================\");\r\n\t\t*/",
"return",
"ret",
";",
"}"
] | Get the possibilities of all inverse relations.
@return The possibilities of all inverse relations | [
"Get",
"the",
"possibilities",
"of",
"all",
"inverse",
"relations",
"."
] | 42aaef2e2b76d0f738427f0dd9653c4f62b40517 | https://github.com/FedericoPecora/meta-csp-framework/blob/42aaef2e2b76d0f738427f0dd9653c4f62b40517/src/main/java/org/metacsp/fuzzyAllenInterval/FuzzyAllenIntervalConstraint.java#L93-L125 | train |
openengsb/openengsb | api/ekb/src/main/java/org/openengsb/core/ekb/api/transformation/TransformationDescription.java | TransformationDescription.addStep | public void addStep(String operationName, List<String> sourceFields, String targetField,
Map<String, String> parameters) {
TransformationStep step = new TransformationStep();
step.setOperationName(operationName);
step.setSourceFields(sourceFields.toArray(new String[sourceFields.size()]));
step.setTargetField(targetField);
step.setOperationParams(parameters);
steps.add(step);
} | java | public void addStep(String operationName, List<String> sourceFields, String targetField,
Map<String, String> parameters) {
TransformationStep step = new TransformationStep();
step.setOperationName(operationName);
step.setSourceFields(sourceFields.toArray(new String[sourceFields.size()]));
step.setTargetField(targetField);
step.setOperationParams(parameters);
steps.add(step);
} | [
"public",
"void",
"addStep",
"(",
"String",
"operationName",
",",
"List",
"<",
"String",
">",
"sourceFields",
",",
"String",
"targetField",
",",
"Map",
"<",
"String",
",",
"String",
">",
"parameters",
")",
"{",
"TransformationStep",
"step",
"=",
"new",
"TransformationStep",
"(",
")",
";",
"step",
".",
"setOperationName",
"(",
"operationName",
")",
";",
"step",
".",
"setSourceFields",
"(",
"sourceFields",
".",
"toArray",
"(",
"new",
"String",
"[",
"sourceFields",
".",
"size",
"(",
")",
"]",
")",
")",
";",
"step",
".",
"setTargetField",
"(",
"targetField",
")",
";",
"step",
".",
"setOperationParams",
"(",
"parameters",
")",
";",
"steps",
".",
"add",
"(",
"step",
")",
";",
"}"
] | Adds a transformation step to this description | [
"Adds",
"a",
"transformation",
"step",
"to",
"this",
"description"
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/api/ekb/src/main/java/org/openengsb/core/ekb/api/transformation/TransformationDescription.java#L54-L62 | train |
openengsb/openengsb | api/ekb/src/main/java/org/openengsb/core/ekb/api/transformation/TransformationDescription.java | TransformationDescription.forwardField | public void forwardField(String sourceField, String targetField) {
TransformationStep step = new TransformationStep();
step.setTargetField(targetField);
step.setSourceFields(sourceField);
step.setOperationName("forward");
steps.add(step);
} | java | public void forwardField(String sourceField, String targetField) {
TransformationStep step = new TransformationStep();
step.setTargetField(targetField);
step.setSourceFields(sourceField);
step.setOperationName("forward");
steps.add(step);
} | [
"public",
"void",
"forwardField",
"(",
"String",
"sourceField",
",",
"String",
"targetField",
")",
"{",
"TransformationStep",
"step",
"=",
"new",
"TransformationStep",
"(",
")",
";",
"step",
".",
"setTargetField",
"(",
"targetField",
")",
";",
"step",
".",
"setSourceFields",
"(",
"sourceField",
")",
";",
"step",
".",
"setOperationName",
"(",
"\"forward\"",
")",
";",
"steps",
".",
"add",
"(",
"step",
")",
";",
"}"
] | Adds a forward transformation step to the transformation description. The value of the source field is copied to
the target field unchanged. Both fields need to have the same object type. | [
"Adds",
"a",
"forward",
"transformation",
"step",
"to",
"the",
"transformation",
"description",
".",
"The",
"value",
"of",
"the",
"source",
"field",
"is",
"copied",
"to",
"the",
"target",
"field",
"unchanged",
".",
"Both",
"fields",
"need",
"to",
"have",
"the",
"same",
"object",
"type",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/api/ekb/src/main/java/org/openengsb/core/ekb/api/transformation/TransformationDescription.java#L68-L74 | train |
openengsb/openengsb | api/ekb/src/main/java/org/openengsb/core/ekb/api/transformation/TransformationDescription.java | TransformationDescription.concatField | public void concatField(String targetField, String concatString, String... sourceFields) {
TransformationStep step = new TransformationStep();
step.setTargetField(targetField);
step.setSourceFields(sourceFields);
step.setOperationParameter(TransformationConstants.CONCAT_PARAM, concatString);
step.setOperationName("concat");
steps.add(step);
} | java | public void concatField(String targetField, String concatString, String... sourceFields) {
TransformationStep step = new TransformationStep();
step.setTargetField(targetField);
step.setSourceFields(sourceFields);
step.setOperationParameter(TransformationConstants.CONCAT_PARAM, concatString);
step.setOperationName("concat");
steps.add(step);
} | [
"public",
"void",
"concatField",
"(",
"String",
"targetField",
",",
"String",
"concatString",
",",
"String",
"...",
"sourceFields",
")",
"{",
"TransformationStep",
"step",
"=",
"new",
"TransformationStep",
"(",
")",
";",
"step",
".",
"setTargetField",
"(",
"targetField",
")",
";",
"step",
".",
"setSourceFields",
"(",
"sourceFields",
")",
";",
"step",
".",
"setOperationParameter",
"(",
"TransformationConstants",
".",
"CONCAT_PARAM",
",",
"concatString",
")",
";",
"step",
".",
"setOperationName",
"(",
"\"concat\"",
")",
";",
"steps",
".",
"add",
"(",
"step",
")",
";",
"}"
] | Adds a concat transformation step to the transformation description. The values of the source fields are
concatenated to the target field with the concat string between the source fields values. All fields need to be
of the type String. | [
"Adds",
"a",
"concat",
"transformation",
"step",
"to",
"the",
"transformation",
"description",
".",
"The",
"values",
"of",
"the",
"source",
"fields",
"are",
"concatenated",
"to",
"the",
"target",
"field",
"with",
"the",
"concat",
"string",
"between",
"the",
"source",
"fields",
"values",
".",
"All",
"fields",
"need",
"to",
"be",
"of",
"the",
"type",
"String",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/api/ekb/src/main/java/org/openengsb/core/ekb/api/transformation/TransformationDescription.java#L81-L88 | train |
openengsb/openengsb | api/ekb/src/main/java/org/openengsb/core/ekb/api/transformation/TransformationDescription.java | TransformationDescription.splitField | public void splitField(String sourceField, String targetField, String splitString, String index) {
TransformationStep step = new TransformationStep();
step.setTargetField(targetField);
step.setSourceFields(sourceField);
step.setOperationParameter(TransformationConstants.SPLIT_PARAM, splitString);
step.setOperationParameter(TransformationConstants.INDEX_PARAM, index);
step.setOperationName("split");
steps.add(step);
} | java | public void splitField(String sourceField, String targetField, String splitString, String index) {
TransformationStep step = new TransformationStep();
step.setTargetField(targetField);
step.setSourceFields(sourceField);
step.setOperationParameter(TransformationConstants.SPLIT_PARAM, splitString);
step.setOperationParameter(TransformationConstants.INDEX_PARAM, index);
step.setOperationName("split");
steps.add(step);
} | [
"public",
"void",
"splitField",
"(",
"String",
"sourceField",
",",
"String",
"targetField",
",",
"String",
"splitString",
",",
"String",
"index",
")",
"{",
"TransformationStep",
"step",
"=",
"new",
"TransformationStep",
"(",
")",
";",
"step",
".",
"setTargetField",
"(",
"targetField",
")",
";",
"step",
".",
"setSourceFields",
"(",
"sourceField",
")",
";",
"step",
".",
"setOperationParameter",
"(",
"TransformationConstants",
".",
"SPLIT_PARAM",
",",
"splitString",
")",
";",
"step",
".",
"setOperationParameter",
"(",
"TransformationConstants",
".",
"INDEX_PARAM",
",",
"index",
")",
";",
"step",
".",
"setOperationName",
"(",
"\"split\"",
")",
";",
"steps",
".",
"add",
"(",
"step",
")",
";",
"}"
] | Adds a split transformation step to the transformation description. The value of the source field is split based
on the split string into parts. Based on the given index, the result will be set to the target field. The index
needs to be an integer value. All fields need to be of the type String. | [
"Adds",
"a",
"split",
"transformation",
"step",
"to",
"the",
"transformation",
"description",
".",
"The",
"value",
"of",
"the",
"source",
"field",
"is",
"split",
"based",
"on",
"the",
"split",
"string",
"into",
"parts",
".",
"Based",
"on",
"the",
"given",
"index",
"the",
"result",
"will",
"be",
"set",
"to",
"the",
"target",
"field",
".",
"The",
"index",
"needs",
"to",
"be",
"an",
"integer",
"value",
".",
"All",
"fields",
"need",
"to",
"be",
"of",
"the",
"type",
"String",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/api/ekb/src/main/java/org/openengsb/core/ekb/api/transformation/TransformationDescription.java#L95-L103 | train |
openengsb/openengsb | api/ekb/src/main/java/org/openengsb/core/ekb/api/transformation/TransformationDescription.java | TransformationDescription.splitRegexField | public void splitRegexField(String sourceField, String targetField, String regexString, String index) {
TransformationStep step = new TransformationStep();
step.setTargetField(targetField);
step.setSourceFields(sourceField);
step.setOperationParameter(TransformationConstants.REGEX_PARAM, regexString);
step.setOperationParameter(TransformationConstants.INDEX_PARAM, index);
step.setOperationName("splitRegex");
steps.add(step);
} | java | public void splitRegexField(String sourceField, String targetField, String regexString, String index) {
TransformationStep step = new TransformationStep();
step.setTargetField(targetField);
step.setSourceFields(sourceField);
step.setOperationParameter(TransformationConstants.REGEX_PARAM, regexString);
step.setOperationParameter(TransformationConstants.INDEX_PARAM, index);
step.setOperationName("splitRegex");
steps.add(step);
} | [
"public",
"void",
"splitRegexField",
"(",
"String",
"sourceField",
",",
"String",
"targetField",
",",
"String",
"regexString",
",",
"String",
"index",
")",
"{",
"TransformationStep",
"step",
"=",
"new",
"TransformationStep",
"(",
")",
";",
"step",
".",
"setTargetField",
"(",
"targetField",
")",
";",
"step",
".",
"setSourceFields",
"(",
"sourceField",
")",
";",
"step",
".",
"setOperationParameter",
"(",
"TransformationConstants",
".",
"REGEX_PARAM",
",",
"regexString",
")",
";",
"step",
".",
"setOperationParameter",
"(",
"TransformationConstants",
".",
"INDEX_PARAM",
",",
"index",
")",
";",
"step",
".",
"setOperationName",
"(",
"\"splitRegex\"",
")",
";",
"steps",
".",
"add",
"(",
"step",
")",
";",
"}"
] | Adds a split regex transformation step to the transformation description. The value of the source field is split
based on the split string as regular expression into parts. Based on the given index, the result will be set to
the target field. The index needs to be an integer value. All fields need to be of the type String. | [
"Adds",
"a",
"split",
"regex",
"transformation",
"step",
"to",
"the",
"transformation",
"description",
".",
"The",
"value",
"of",
"the",
"source",
"field",
"is",
"split",
"based",
"on",
"the",
"split",
"string",
"as",
"regular",
"expression",
"into",
"parts",
".",
"Based",
"on",
"the",
"given",
"index",
"the",
"result",
"will",
"be",
"set",
"to",
"the",
"target",
"field",
".",
"The",
"index",
"needs",
"to",
"be",
"an",
"integer",
"value",
".",
"All",
"fields",
"need",
"to",
"be",
"of",
"the",
"type",
"String",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/api/ekb/src/main/java/org/openengsb/core/ekb/api/transformation/TransformationDescription.java#L110-L118 | train |
openengsb/openengsb | api/ekb/src/main/java/org/openengsb/core/ekb/api/transformation/TransformationDescription.java | TransformationDescription.substringField | public void substringField(String sourceField, String targetField, String from, String to) {
TransformationStep step = new TransformationStep();
step.setTargetField(targetField);
step.setSourceFields(sourceField);
step.setOperationParameter(TransformationConstants.SUBSTRING_FROM_PARAM, from);
step.setOperationParameter(TransformationConstants.SUBSTRING_TO_PARAM, to);
step.setOperationName("substring");
steps.add(step);
} | java | public void substringField(String sourceField, String targetField, String from, String to) {
TransformationStep step = new TransformationStep();
step.setTargetField(targetField);
step.setSourceFields(sourceField);
step.setOperationParameter(TransformationConstants.SUBSTRING_FROM_PARAM, from);
step.setOperationParameter(TransformationConstants.SUBSTRING_TO_PARAM, to);
step.setOperationName("substring");
steps.add(step);
} | [
"public",
"void",
"substringField",
"(",
"String",
"sourceField",
",",
"String",
"targetField",
",",
"String",
"from",
",",
"String",
"to",
")",
"{",
"TransformationStep",
"step",
"=",
"new",
"TransformationStep",
"(",
")",
";",
"step",
".",
"setTargetField",
"(",
"targetField",
")",
";",
"step",
".",
"setSourceFields",
"(",
"sourceField",
")",
";",
"step",
".",
"setOperationParameter",
"(",
"TransformationConstants",
".",
"SUBSTRING_FROM_PARAM",
",",
"from",
")",
";",
"step",
".",
"setOperationParameter",
"(",
"TransformationConstants",
".",
"SUBSTRING_TO_PARAM",
",",
"to",
")",
";",
"step",
".",
"setOperationName",
"(",
"\"substring\"",
")",
";",
"steps",
".",
"add",
"(",
"step",
")",
";",
"}"
] | Adds a substring step to the transformation description. The value of the source field is taken and it is tried
to build the substring from the given index from to the given index to. From and to must be Integers written as
String, the value of the source field must also be a String. | [
"Adds",
"a",
"substring",
"step",
"to",
"the",
"transformation",
"description",
".",
"The",
"value",
"of",
"the",
"source",
"field",
"is",
"taken",
"and",
"it",
"is",
"tried",
"to",
"build",
"the",
"substring",
"from",
"the",
"given",
"index",
"from",
"to",
"the",
"given",
"index",
"to",
".",
"From",
"and",
"to",
"must",
"be",
"Integers",
"written",
"as",
"String",
"the",
"value",
"of",
"the",
"source",
"field",
"must",
"also",
"be",
"a",
"String",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/api/ekb/src/main/java/org/openengsb/core/ekb/api/transformation/TransformationDescription.java#L139-L147 | train |
openengsb/openengsb | api/ekb/src/main/java/org/openengsb/core/ekb/api/transformation/TransformationDescription.java | TransformationDescription.valueField | public void valueField(String targetField, String value) {
TransformationStep step = new TransformationStep();
step.setTargetField(targetField);
step.setOperationParameter(TransformationConstants.VALUE_PARAM, value);
step.setOperationName("value");
steps.add(step);
} | java | public void valueField(String targetField, String value) {
TransformationStep step = new TransformationStep();
step.setTargetField(targetField);
step.setOperationParameter(TransformationConstants.VALUE_PARAM, value);
step.setOperationName("value");
steps.add(step);
} | [
"public",
"void",
"valueField",
"(",
"String",
"targetField",
",",
"String",
"value",
")",
"{",
"TransformationStep",
"step",
"=",
"new",
"TransformationStep",
"(",
")",
";",
"step",
".",
"setTargetField",
"(",
"targetField",
")",
";",
"step",
".",
"setOperationParameter",
"(",
"TransformationConstants",
".",
"VALUE_PARAM",
",",
"value",
")",
";",
"step",
".",
"setOperationName",
"(",
"\"value\"",
")",
";",
"steps",
".",
"add",
"(",
"step",
")",
";",
"}"
] | Adds a value step to the transformation description. The given value is written to the target field. | [
"Adds",
"a",
"value",
"step",
"to",
"the",
"transformation",
"description",
".",
"The",
"given",
"value",
"is",
"written",
"to",
"the",
"target",
"field",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/api/ekb/src/main/java/org/openengsb/core/ekb/api/transformation/TransformationDescription.java#L152-L158 | train |
openengsb/openengsb | api/ekb/src/main/java/org/openengsb/core/ekb/api/transformation/TransformationDescription.java | TransformationDescription.replaceField | public void replaceField(String sourceField, String targetField, String oldString, String newString) {
TransformationStep step = new TransformationStep();
step.setSourceFields(sourceField);
step.setTargetField(targetField);
step.setOperationParameter(TransformationConstants.REPLACE_OLD_PARAM, oldString);
step.setOperationParameter(TransformationConstants.REPLACE_NEW_PARAM, newString);
step.setOperationName("replace");
steps.add(step);
} | java | public void replaceField(String sourceField, String targetField, String oldString, String newString) {
TransformationStep step = new TransformationStep();
step.setSourceFields(sourceField);
step.setTargetField(targetField);
step.setOperationParameter(TransformationConstants.REPLACE_OLD_PARAM, oldString);
step.setOperationParameter(TransformationConstants.REPLACE_NEW_PARAM, newString);
step.setOperationName("replace");
steps.add(step);
} | [
"public",
"void",
"replaceField",
"(",
"String",
"sourceField",
",",
"String",
"targetField",
",",
"String",
"oldString",
",",
"String",
"newString",
")",
"{",
"TransformationStep",
"step",
"=",
"new",
"TransformationStep",
"(",
")",
";",
"step",
".",
"setSourceFields",
"(",
"sourceField",
")",
";",
"step",
".",
"setTargetField",
"(",
"targetField",
")",
";",
"step",
".",
"setOperationParameter",
"(",
"TransformationConstants",
".",
"REPLACE_OLD_PARAM",
",",
"oldString",
")",
";",
"step",
".",
"setOperationParameter",
"(",
"TransformationConstants",
".",
"REPLACE_NEW_PARAM",
",",
"newString",
")",
";",
"step",
".",
"setOperationName",
"(",
"\"replace\"",
")",
";",
"steps",
".",
"add",
"(",
"step",
")",
";",
"}"
] | Adds a replace step to the transformation description. The source and the target field need to be of String type.
Performs standard string replacement on the string of the source field and writes the result to the target field. | [
"Adds",
"a",
"replace",
"step",
"to",
"the",
"transformation",
"description",
".",
"The",
"source",
"and",
"the",
"target",
"field",
"need",
"to",
"be",
"of",
"String",
"type",
".",
"Performs",
"standard",
"string",
"replacement",
"on",
"the",
"string",
"of",
"the",
"source",
"field",
"and",
"writes",
"the",
"result",
"to",
"the",
"target",
"field",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/api/ekb/src/main/java/org/openengsb/core/ekb/api/transformation/TransformationDescription.java#L215-L223 | train |
openengsb/openengsb | api/ekb/src/main/java/org/openengsb/core/ekb/api/transformation/TransformationDescription.java | TransformationDescription.padField | public void padField(String sourceField, String targetField, String length, String character, String direction) {
TransformationStep step = new TransformationStep();
step.setSourceFields(sourceField);
step.setTargetField(targetField);
step.setOperationParameter(TransformationConstants.PAD_LENGTH_PARAM, length);
step.setOperationParameter(TransformationConstants.PAD_CHARACTER_PARAM, character);
step.setOperationParameter(TransformationConstants.PAD_DIRECTION_PARAM, direction);
step.setOperationName("pad");
steps.add(step);
} | java | public void padField(String sourceField, String targetField, String length, String character, String direction) {
TransformationStep step = new TransformationStep();
step.setSourceFields(sourceField);
step.setTargetField(targetField);
step.setOperationParameter(TransformationConstants.PAD_LENGTH_PARAM, length);
step.setOperationParameter(TransformationConstants.PAD_CHARACTER_PARAM, character);
step.setOperationParameter(TransformationConstants.PAD_DIRECTION_PARAM, direction);
step.setOperationName("pad");
steps.add(step);
} | [
"public",
"void",
"padField",
"(",
"String",
"sourceField",
",",
"String",
"targetField",
",",
"String",
"length",
",",
"String",
"character",
",",
"String",
"direction",
")",
"{",
"TransformationStep",
"step",
"=",
"new",
"TransformationStep",
"(",
")",
";",
"step",
".",
"setSourceFields",
"(",
"sourceField",
")",
";",
"step",
".",
"setTargetField",
"(",
"targetField",
")",
";",
"step",
".",
"setOperationParameter",
"(",
"TransformationConstants",
".",
"PAD_LENGTH_PARAM",
",",
"length",
")",
";",
"step",
".",
"setOperationParameter",
"(",
"TransformationConstants",
".",
"PAD_CHARACTER_PARAM",
",",
"character",
")",
";",
"step",
".",
"setOperationParameter",
"(",
"TransformationConstants",
".",
"PAD_DIRECTION_PARAM",
",",
"direction",
")",
";",
"step",
".",
"setOperationName",
"(",
"\"pad\"",
")",
";",
"steps",
".",
"add",
"(",
"step",
")",
";",
"}"
] | Adds a pad step to the transformation description. The source and the target field need to be of String type.
Performs padding operation on the string of the source field and writes the result to the target field. The
length describes to which size the padding should be done, the pad character describes which character to use for
the padding. The direction describes if the padding should be done at the start or at the end. The standard value
for the direction is at the beginning. Values for direction could be "Start" or "End". | [
"Adds",
"a",
"pad",
"step",
"to",
"the",
"transformation",
"description",
".",
"The",
"source",
"and",
"the",
"target",
"field",
"need",
"to",
"be",
"of",
"String",
"type",
".",
"Performs",
"padding",
"operation",
"on",
"the",
"string",
"of",
"the",
"source",
"field",
"and",
"writes",
"the",
"result",
"to",
"the",
"target",
"field",
".",
"The",
"length",
"describes",
"to",
"which",
"size",
"the",
"padding",
"should",
"be",
"done",
"the",
"pad",
"character",
"describes",
"which",
"character",
"to",
"use",
"for",
"the",
"padding",
".",
"The",
"direction",
"describes",
"if",
"the",
"padding",
"should",
"be",
"done",
"at",
"the",
"start",
"or",
"at",
"the",
"end",
".",
"The",
"standard",
"value",
"for",
"the",
"direction",
"is",
"at",
"the",
"beginning",
".",
"Values",
"for",
"direction",
"could",
"be",
"Start",
"or",
"End",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/api/ekb/src/main/java/org/openengsb/core/ekb/api/transformation/TransformationDescription.java#L244-L253 | train |
openengsb/openengsb | api/ekb/src/main/java/org/openengsb/core/ekb/api/transformation/TransformationDescription.java | TransformationDescription.removeLeadingField | public void removeLeadingField(String sourceField, String targetField, String regexString, String length) {
TransformationStep step = new TransformationStep();
step.setSourceFields(sourceField);
step.setTargetField(targetField);
step.setOperationParameter(TransformationConstants.REMOVELEADING_LENGTH_PARAM, length);
step.setOperationParameter(TransformationConstants.REGEX_PARAM, regexString);
step.setOperationName("removeleading");
steps.add(step);
} | java | public void removeLeadingField(String sourceField, String targetField, String regexString, String length) {
TransformationStep step = new TransformationStep();
step.setSourceFields(sourceField);
step.setTargetField(targetField);
step.setOperationParameter(TransformationConstants.REMOVELEADING_LENGTH_PARAM, length);
step.setOperationParameter(TransformationConstants.REGEX_PARAM, regexString);
step.setOperationName("removeleading");
steps.add(step);
} | [
"public",
"void",
"removeLeadingField",
"(",
"String",
"sourceField",
",",
"String",
"targetField",
",",
"String",
"regexString",
",",
"String",
"length",
")",
"{",
"TransformationStep",
"step",
"=",
"new",
"TransformationStep",
"(",
")",
";",
"step",
".",
"setSourceFields",
"(",
"sourceField",
")",
";",
"step",
".",
"setTargetField",
"(",
"targetField",
")",
";",
"step",
".",
"setOperationParameter",
"(",
"TransformationConstants",
".",
"REMOVELEADING_LENGTH_PARAM",
",",
"length",
")",
";",
"step",
".",
"setOperationParameter",
"(",
"TransformationConstants",
".",
"REGEX_PARAM",
",",
"regexString",
")",
";",
"step",
".",
"setOperationName",
"(",
"\"removeleading\"",
")",
";",
"steps",
".",
"add",
"(",
"step",
")",
";",
"}"
] | Adds a remove leading step to the transformation description. The source and the target field need to be of
String type. Based on the given regular expression string the beginning of the source string will be removed
until the given maximum length. If the length is 0, the maximum length is ignored. | [
"Adds",
"a",
"remove",
"leading",
"step",
"to",
"the",
"transformation",
"description",
".",
"The",
"source",
"and",
"the",
"target",
"field",
"need",
"to",
"be",
"of",
"String",
"type",
".",
"Based",
"on",
"the",
"given",
"regular",
"expression",
"string",
"the",
"beginning",
"of",
"the",
"source",
"string",
"will",
"be",
"removed",
"until",
"the",
"given",
"maximum",
"length",
".",
"If",
"the",
"length",
"is",
"0",
"the",
"maximum",
"length",
"is",
"ignored",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/api/ekb/src/main/java/org/openengsb/core/ekb/api/transformation/TransformationDescription.java#L260-L268 | train |
openengsb/openengsb | api/ekb/src/main/java/org/openengsb/core/ekb/api/transformation/TransformationDescription.java | TransformationDescription.instantiateField | public void instantiateField(String targetField, String targetType, String targetTypeInit, String... sourceFields) {
TransformationStep step = new TransformationStep();
step.setSourceFields(sourceFields);
step.setTargetField(targetField);
step.setOperationParameter(TransformationConstants.INSTANTIATE_TARGETTYPE_PARAM, targetType);
if (targetTypeInit != null) {
step.setOperationParameter(TransformationConstants.INSTANTIATE_INITMETHOD_PARAM, targetTypeInit);
}
step.setOperationName("instantiate");
steps.add(step);
} | java | public void instantiateField(String targetField, String targetType, String targetTypeInit, String... sourceFields) {
TransformationStep step = new TransformationStep();
step.setSourceFields(sourceFields);
step.setTargetField(targetField);
step.setOperationParameter(TransformationConstants.INSTANTIATE_TARGETTYPE_PARAM, targetType);
if (targetTypeInit != null) {
step.setOperationParameter(TransformationConstants.INSTANTIATE_INITMETHOD_PARAM, targetTypeInit);
}
step.setOperationName("instantiate");
steps.add(step);
} | [
"public",
"void",
"instantiateField",
"(",
"String",
"targetField",
",",
"String",
"targetType",
",",
"String",
"targetTypeInit",
",",
"String",
"...",
"sourceFields",
")",
"{",
"TransformationStep",
"step",
"=",
"new",
"TransformationStep",
"(",
")",
";",
"step",
".",
"setSourceFields",
"(",
"sourceFields",
")",
";",
"step",
".",
"setTargetField",
"(",
"targetField",
")",
";",
"step",
".",
"setOperationParameter",
"(",
"TransformationConstants",
".",
"INSTANTIATE_TARGETTYPE_PARAM",
",",
"targetType",
")",
";",
"if",
"(",
"targetTypeInit",
"!=",
"null",
")",
"{",
"step",
".",
"setOperationParameter",
"(",
"TransformationConstants",
".",
"INSTANTIATE_INITMETHOD_PARAM",
",",
"targetTypeInit",
")",
";",
"}",
"step",
".",
"setOperationName",
"(",
"\"instantiate\"",
")",
";",
"steps",
".",
"add",
"(",
"step",
")",
";",
"}"
] | Adds an instantiate step to the transformation description. An object defined through the given target type will
be created. For the instantiation the targetTypeInit method will be used. If this parameter is null, the
constructor of the targetType will be used with the object type of the source object as parameter. | [
"Adds",
"an",
"instantiate",
"step",
"to",
"the",
"transformation",
"description",
".",
"An",
"object",
"defined",
"through",
"the",
"given",
"target",
"type",
"will",
"be",
"created",
".",
"For",
"the",
"instantiation",
"the",
"targetTypeInit",
"method",
"will",
"be",
"used",
".",
"If",
"this",
"parameter",
"is",
"null",
"the",
"constructor",
"of",
"the",
"targetType",
"will",
"be",
"used",
"with",
"the",
"object",
"type",
"of",
"the",
"source",
"object",
"as",
"parameter",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/api/ekb/src/main/java/org/openengsb/core/ekb/api/transformation/TransformationDescription.java#L275-L285 | train |
openengsb/openengsb | components/edb/src/main/java/org/openengsb/core/edb/jpa/internal/util/QueryRequestCriteriaBuilder.java | QueryRequestCriteriaBuilder.convertParametersToPredicate | @SuppressWarnings({ "unchecked" })
private Predicate convertParametersToPredicate(Root<?> from, CriteriaQuery<?> query) {
List<Predicate> predicates = new ArrayList<>();
for (Map.Entry<String, Set<Object>> value : request.getParameters().entrySet()) {
Subquery<JPAEntry> subquery = buildJPAEntrySubquery(value.getKey(), value.getValue(), from, query);
predicates.add(builder.exists(subquery));
}
if (request.isAndJoined()) {
return builder.and(Iterables.toArray(predicates, Predicate.class));
} else {
return builder.or(Iterables.toArray(predicates, Predicate.class));
}
} | java | @SuppressWarnings({ "unchecked" })
private Predicate convertParametersToPredicate(Root<?> from, CriteriaQuery<?> query) {
List<Predicate> predicates = new ArrayList<>();
for (Map.Entry<String, Set<Object>> value : request.getParameters().entrySet()) {
Subquery<JPAEntry> subquery = buildJPAEntrySubquery(value.getKey(), value.getValue(), from, query);
predicates.add(builder.exists(subquery));
}
if (request.isAndJoined()) {
return builder.and(Iterables.toArray(predicates, Predicate.class));
} else {
return builder.or(Iterables.toArray(predicates, Predicate.class));
}
} | [
"@",
"SuppressWarnings",
"(",
"{",
"\"unchecked\"",
"}",
")",
"private",
"Predicate",
"convertParametersToPredicate",
"(",
"Root",
"<",
"?",
">",
"from",
",",
"CriteriaQuery",
"<",
"?",
">",
"query",
")",
"{",
"List",
"<",
"Predicate",
">",
"predicates",
"=",
"new",
"ArrayList",
"<>",
"(",
")",
";",
"for",
"(",
"Map",
".",
"Entry",
"<",
"String",
",",
"Set",
"<",
"Object",
">",
">",
"value",
":",
"request",
".",
"getParameters",
"(",
")",
".",
"entrySet",
"(",
")",
")",
"{",
"Subquery",
"<",
"JPAEntry",
">",
"subquery",
"=",
"buildJPAEntrySubquery",
"(",
"value",
".",
"getKey",
"(",
")",
",",
"value",
".",
"getValue",
"(",
")",
",",
"from",
",",
"query",
")",
";",
"predicates",
".",
"add",
"(",
"builder",
".",
"exists",
"(",
"subquery",
")",
")",
";",
"}",
"if",
"(",
"request",
".",
"isAndJoined",
"(",
")",
")",
"{",
"return",
"builder",
".",
"and",
"(",
"Iterables",
".",
"toArray",
"(",
"predicates",
",",
"Predicate",
".",
"class",
")",
")",
";",
"}",
"else",
"{",
"return",
"builder",
".",
"or",
"(",
"Iterables",
".",
"toArray",
"(",
"predicates",
",",
"Predicate",
".",
"class",
")",
")",
";",
"}",
"}"
] | Converts a query request parameter map for a query operation into a list of predicates which need to be added to
the criteria query. | [
"Converts",
"a",
"query",
"request",
"parameter",
"map",
"for",
"a",
"query",
"operation",
"into",
"a",
"list",
"of",
"predicates",
"which",
"need",
"to",
"be",
"added",
"to",
"the",
"criteria",
"query",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/edb/src/main/java/org/openengsb/core/edb/jpa/internal/util/QueryRequestCriteriaBuilder.java#L88-L100 | train |
aseovic/coherence-tools | core/src/main/java/com/seovic/core/processor/BinaryPropertyProcessor.java | BinaryPropertyProcessor.set | protected void set(PofValue target, Object value) {
navigator.navigate(target).setValue(value);
} | java | protected void set(PofValue target, Object value) {
navigator.navigate(target).setValue(value);
} | [
"protected",
"void",
"set",
"(",
"PofValue",
"target",
",",
"Object",
"value",
")",
"{",
"navigator",
".",
"navigate",
"(",
"target",
")",
".",
"setValue",
"(",
"value",
")",
";",
"}"
] | Set the property value into the specified PofValue object.
@param target PofValue to set the property value into
@param value new property value | [
"Set",
"the",
"property",
"value",
"into",
"the",
"specified",
"PofValue",
"object",
"."
] | 561a1d7e572ad98657fcd26beb1164891b0cd6fe | https://github.com/aseovic/coherence-tools/blob/561a1d7e572ad98657fcd26beb1164891b0cd6fe/core/src/main/java/com/seovic/core/processor/BinaryPropertyProcessor.java#L80-L82 | train |
bazaarvoice/curator-extensions | recipes/src/main/java/com/bazaarvoice/curator/recipes/NodeDiscovery.java | NodeDiscovery.getNodes | public Map<String, T> getNodes() {
return Maps.transformValues(Collections.unmodifiableMap(_nodes), input -> (input != null) ? input.orElse(null) : null);
} | java | public Map<String, T> getNodes() {
return Maps.transformValues(Collections.unmodifiableMap(_nodes), input -> (input != null) ? input.orElse(null) : null);
} | [
"public",
"Map",
"<",
"String",
",",
"T",
">",
"getNodes",
"(",
")",
"{",
"return",
"Maps",
".",
"transformValues",
"(",
"Collections",
".",
"unmodifiableMap",
"(",
"_nodes",
")",
",",
"input",
"->",
"(",
"input",
"!=",
"null",
")",
"?",
"input",
".",
"orElse",
"(",
"null",
")",
":",
"null",
")",
";",
"}"
] | Retrieve the available nodes.
@return The available nodes. | [
"Retrieve",
"the",
"available",
"nodes",
"."
] | eb1e1b478f1ae6aed602bb5d5cb481277203004e | https://github.com/bazaarvoice/curator-extensions/blob/eb1e1b478f1ae6aed602bb5d5cb481277203004e/recipes/src/main/java/com/bazaarvoice/curator/recipes/NodeDiscovery.java#L95-L97 | train |
bazaarvoice/curator-extensions | recipes/src/main/java/com/bazaarvoice/curator/recipes/NodeDiscovery.java | NodeDiscovery.loadExistingData | private synchronized void loadExistingData() {
for (ChildData childData : _pathCache.getCurrentData()) {
addNode(childData.getPath(), parseChildData(childData));
}
} | java | private synchronized void loadExistingData() {
for (ChildData childData : _pathCache.getCurrentData()) {
addNode(childData.getPath(), parseChildData(childData));
}
} | [
"private",
"synchronized",
"void",
"loadExistingData",
"(",
")",
"{",
"for",
"(",
"ChildData",
"childData",
":",
"_pathCache",
".",
"getCurrentData",
"(",
")",
")",
"{",
"addNode",
"(",
"childData",
".",
"getPath",
"(",
")",
",",
"parseChildData",
"(",
"childData",
")",
")",
";",
"}",
"}"
] | Loads all of the existing data from the underlying path cache. | [
"Loads",
"all",
"of",
"the",
"existing",
"data",
"from",
"the",
"underlying",
"path",
"cache",
"."
] | eb1e1b478f1ae6aed602bb5d5cb481277203004e | https://github.com/bazaarvoice/curator-extensions/blob/eb1e1b478f1ae6aed602bb5d5cb481277203004e/recipes/src/main/java/com/bazaarvoice/curator/recipes/NodeDiscovery.java#L179-L183 | train |
openengsb/openengsb | components/ekb/persistence-query-edb/src/main/java/org/openengsb/core/ekb/persistence/query/edb/internal/QueryInterfaceService.java | QueryInterfaceService.convertEDBCommitToEKBCommit | private EKBCommit convertEDBCommitToEKBCommit(EDBCommit commit) throws EKBException {
EKBCommit result = new EKBCommit();
Map<ModelDescription, Class<?>> cache = new HashMap<>();
result.setRevisionNumber(commit.getRevisionNumber());
result.setComment(commit.getComment());
result.setParentRevisionNumber(commit.getParentRevisionNumber());
result.setDomainId(commit.getDomainId());
result.setConnectorId(commit.getConnectorId());
result.setInstanceId(commit.getInstanceId());
for (EDBObject insert : commit.getInserts()) {
result.addInsert(createModelOfEDBObject(insert, cache));
}
for (EDBObject update : commit.getUpdates()) {
result.addUpdate(createModelOfEDBObject(update, cache));
}
for (String delete : commit.getDeletions()) {
EDBObject object = edbService.getObject(delete, commit.getTimestamp());
result.addDelete(createModelOfEDBObject(object, cache));
}
return result;
} | java | private EKBCommit convertEDBCommitToEKBCommit(EDBCommit commit) throws EKBException {
EKBCommit result = new EKBCommit();
Map<ModelDescription, Class<?>> cache = new HashMap<>();
result.setRevisionNumber(commit.getRevisionNumber());
result.setComment(commit.getComment());
result.setParentRevisionNumber(commit.getParentRevisionNumber());
result.setDomainId(commit.getDomainId());
result.setConnectorId(commit.getConnectorId());
result.setInstanceId(commit.getInstanceId());
for (EDBObject insert : commit.getInserts()) {
result.addInsert(createModelOfEDBObject(insert, cache));
}
for (EDBObject update : commit.getUpdates()) {
result.addUpdate(createModelOfEDBObject(update, cache));
}
for (String delete : commit.getDeletions()) {
EDBObject object = edbService.getObject(delete, commit.getTimestamp());
result.addDelete(createModelOfEDBObject(object, cache));
}
return result;
} | [
"private",
"EKBCommit",
"convertEDBCommitToEKBCommit",
"(",
"EDBCommit",
"commit",
")",
"throws",
"EKBException",
"{",
"EKBCommit",
"result",
"=",
"new",
"EKBCommit",
"(",
")",
";",
"Map",
"<",
"ModelDescription",
",",
"Class",
"<",
"?",
">",
">",
"cache",
"=",
"new",
"HashMap",
"<>",
"(",
")",
";",
"result",
".",
"setRevisionNumber",
"(",
"commit",
".",
"getRevisionNumber",
"(",
")",
")",
";",
"result",
".",
"setComment",
"(",
"commit",
".",
"getComment",
"(",
")",
")",
";",
"result",
".",
"setParentRevisionNumber",
"(",
"commit",
".",
"getParentRevisionNumber",
"(",
")",
")",
";",
"result",
".",
"setDomainId",
"(",
"commit",
".",
"getDomainId",
"(",
")",
")",
";",
"result",
".",
"setConnectorId",
"(",
"commit",
".",
"getConnectorId",
"(",
")",
")",
";",
"result",
".",
"setInstanceId",
"(",
"commit",
".",
"getInstanceId",
"(",
")",
")",
";",
"for",
"(",
"EDBObject",
"insert",
":",
"commit",
".",
"getInserts",
"(",
")",
")",
"{",
"result",
".",
"addInsert",
"(",
"createModelOfEDBObject",
"(",
"insert",
",",
"cache",
")",
")",
";",
"}",
"for",
"(",
"EDBObject",
"update",
":",
"commit",
".",
"getUpdates",
"(",
")",
")",
"{",
"result",
".",
"addUpdate",
"(",
"createModelOfEDBObject",
"(",
"update",
",",
"cache",
")",
")",
";",
"}",
"for",
"(",
"String",
"delete",
":",
"commit",
".",
"getDeletions",
"(",
")",
")",
"{",
"EDBObject",
"object",
"=",
"edbService",
".",
"getObject",
"(",
"delete",
",",
"commit",
".",
"getTimestamp",
"(",
")",
")",
";",
"result",
".",
"addDelete",
"(",
"createModelOfEDBObject",
"(",
"object",
",",
"cache",
")",
")",
";",
"}",
"return",
"result",
";",
"}"
] | Converts an EDBCommit object into an EKBCommit object. | [
"Converts",
"an",
"EDBCommit",
"object",
"into",
"an",
"EKBCommit",
"object",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/ekb/persistence-query-edb/src/main/java/org/openengsb/core/ekb/persistence/query/edb/internal/QueryInterfaceService.java#L149-L169 | train |
openengsb/openengsb | components/ekb/persistence-query-edb/src/main/java/org/openengsb/core/ekb/persistence/query/edb/internal/QueryInterfaceService.java | QueryInterfaceService.createModelOfEDBObject | private Object createModelOfEDBObject(EDBObject object, Map<ModelDescription, Class<?>> cache) {
try {
ModelDescription description = getDescriptionFromObject(object);
Class<?> modelClass;
if (cache.containsKey(description)) {
modelClass = cache.get(description);
} else {
modelClass = modelRegistry.loadModel(description);
cache.put(description, modelClass);
}
return edbConverter.convertEDBObjectToModel(modelClass, object);
} catch (IllegalArgumentException | ClassNotFoundException e) {
LOGGER.warn("Unable to create model of the object {}", object.getOID(), e);
return null;
}
} | java | private Object createModelOfEDBObject(EDBObject object, Map<ModelDescription, Class<?>> cache) {
try {
ModelDescription description = getDescriptionFromObject(object);
Class<?> modelClass;
if (cache.containsKey(description)) {
modelClass = cache.get(description);
} else {
modelClass = modelRegistry.loadModel(description);
cache.put(description, modelClass);
}
return edbConverter.convertEDBObjectToModel(modelClass, object);
} catch (IllegalArgumentException | ClassNotFoundException e) {
LOGGER.warn("Unable to create model of the object {}", object.getOID(), e);
return null;
}
} | [
"private",
"Object",
"createModelOfEDBObject",
"(",
"EDBObject",
"object",
",",
"Map",
"<",
"ModelDescription",
",",
"Class",
"<",
"?",
">",
">",
"cache",
")",
"{",
"try",
"{",
"ModelDescription",
"description",
"=",
"getDescriptionFromObject",
"(",
"object",
")",
";",
"Class",
"<",
"?",
">",
"modelClass",
";",
"if",
"(",
"cache",
".",
"containsKey",
"(",
"description",
")",
")",
"{",
"modelClass",
"=",
"cache",
".",
"get",
"(",
"description",
")",
";",
"}",
"else",
"{",
"modelClass",
"=",
"modelRegistry",
".",
"loadModel",
"(",
"description",
")",
";",
"cache",
".",
"put",
"(",
"description",
",",
"modelClass",
")",
";",
"}",
"return",
"edbConverter",
".",
"convertEDBObjectToModel",
"(",
"modelClass",
",",
"object",
")",
";",
"}",
"catch",
"(",
"IllegalArgumentException",
"|",
"ClassNotFoundException",
"e",
")",
"{",
"LOGGER",
".",
"warn",
"(",
"\"Unable to create model of the object {}\"",
",",
"object",
".",
"getOID",
"(",
")",
",",
"e",
")",
";",
"return",
"null",
";",
"}",
"}"
] | Converts an EDBObject instance into a model. For this, the method need to retrieve the model class to be able to
instantiate the corresponding model objects. If the conversion fails, null is returned. | [
"Converts",
"an",
"EDBObject",
"instance",
"into",
"a",
"model",
".",
"For",
"this",
"the",
"method",
"need",
"to",
"retrieve",
"the",
"model",
"class",
"to",
"be",
"able",
"to",
"instantiate",
"the",
"corresponding",
"model",
"objects",
".",
"If",
"the",
"conversion",
"fails",
"null",
"is",
"returned",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/ekb/persistence-query-edb/src/main/java/org/openengsb/core/ekb/persistence/query/edb/internal/QueryInterfaceService.java#L175-L190 | train |
openengsb/openengsb | components/ekb/persistence-query-edb/src/main/java/org/openengsb/core/ekb/persistence/query/edb/internal/QueryInterfaceService.java | QueryInterfaceService.getDescriptionFromObject | private ModelDescription getDescriptionFromObject(EDBObject obj) {
String modelName = obj.getString(EDBConstants.MODEL_TYPE);
String modelVersion = obj.getString(EDBConstants.MODEL_TYPE_VERSION);
if (modelName == null || modelVersion == null) {
throw new IllegalArgumentException("The object " + obj.getOID() + " contains no model information");
}
return new ModelDescription(modelName, modelVersion);
} | java | private ModelDescription getDescriptionFromObject(EDBObject obj) {
String modelName = obj.getString(EDBConstants.MODEL_TYPE);
String modelVersion = obj.getString(EDBConstants.MODEL_TYPE_VERSION);
if (modelName == null || modelVersion == null) {
throw new IllegalArgumentException("The object " + obj.getOID() + " contains no model information");
}
return new ModelDescription(modelName, modelVersion);
} | [
"private",
"ModelDescription",
"getDescriptionFromObject",
"(",
"EDBObject",
"obj",
")",
"{",
"String",
"modelName",
"=",
"obj",
".",
"getString",
"(",
"EDBConstants",
".",
"MODEL_TYPE",
")",
";",
"String",
"modelVersion",
"=",
"obj",
".",
"getString",
"(",
"EDBConstants",
".",
"MODEL_TYPE_VERSION",
")",
";",
"if",
"(",
"modelName",
"==",
"null",
"||",
"modelVersion",
"==",
"null",
")",
"{",
"throw",
"new",
"IllegalArgumentException",
"(",
"\"The object \"",
"+",
"obj",
".",
"getOID",
"(",
")",
"+",
"\" contains no model information\"",
")",
";",
"}",
"return",
"new",
"ModelDescription",
"(",
"modelName",
",",
"modelVersion",
")",
";",
"}"
] | Extracts the required values to lookup a model class from the given EDBObject. If this object does not contain
the required information, an IllegalArgumentException is thrown. | [
"Extracts",
"the",
"required",
"values",
"to",
"lookup",
"a",
"model",
"class",
"from",
"the",
"given",
"EDBObject",
".",
"If",
"this",
"object",
"does",
"not",
"contain",
"the",
"required",
"information",
"an",
"IllegalArgumentException",
"is",
"thrown",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/ekb/persistence-query-edb/src/main/java/org/openengsb/core/ekb/persistence/query/edb/internal/QueryInterfaceService.java#L196-L203 | train |
aseovic/coherence-tools | loader/src/main/java/com/seovic/loader/target/CoherenceCacheTarget.java | CoherenceCacheTarget.init | private void init(String cacheName, NamedCache cache,
IdGenerator idGenerator,
IdExtractor idExtractor) {
m_cacheName = cacheName;
m_cache = cache;
m_idGenerator = idGenerator;
m_idExtractor = idExtractor;
} | java | private void init(String cacheName, NamedCache cache,
IdGenerator idGenerator,
IdExtractor idExtractor) {
m_cacheName = cacheName;
m_cache = cache;
m_idGenerator = idGenerator;
m_idExtractor = idExtractor;
} | [
"private",
"void",
"init",
"(",
"String",
"cacheName",
",",
"NamedCache",
"cache",
",",
"IdGenerator",
"idGenerator",
",",
"IdExtractor",
"idExtractor",
")",
"{",
"m_cacheName",
"=",
"cacheName",
";",
"m_cache",
"=",
"cache",
";",
"m_idGenerator",
"=",
"idGenerator",
";",
"m_idExtractor",
"=",
"idExtractor",
";",
"}"
] | Initializes CoherenceCacheTarget instance.
@param cacheName the name of the cache to load objects into
@param cache the cache to load objects into
@param idGenerator identity generator to use to determine key
@param idExtractor identity extractor to use to determine key | [
"Initializes",
"CoherenceCacheTarget",
"instance",
"."
] | 561a1d7e572ad98657fcd26beb1164891b0cd6fe | https://github.com/aseovic/coherence-tools/blob/561a1d7e572ad98657fcd26beb1164891b0cd6fe/loader/src/main/java/com/seovic/loader/target/CoherenceCacheTarget.java#L148-L155 | train |
BrunoEberhard/minimal-j | src/main/java/org/minimalj/security/TextFileAuthentication.java | TextFileAuthentication.main | public static void main(String[] args) {
if (args.length < 2) {
System.err.println("Two arguments needed as username and password");
System.exit(-1);
}
User user = new User();
user.name = args[0];
user.password.setPassword(args[1].toCharArray());
for (int i = 2; i<args.length; i++) {
user.roles.add(new UserRole(args[i].trim()));
}
System.out.println(user.format());
} | java | public static void main(String[] args) {
if (args.length < 2) {
System.err.println("Two arguments needed as username and password");
System.exit(-1);
}
User user = new User();
user.name = args[0];
user.password.setPassword(args[1].toCharArray());
for (int i = 2; i<args.length; i++) {
user.roles.add(new UserRole(args[i].trim()));
}
System.out.println(user.format());
} | [
"public",
"static",
"void",
"main",
"(",
"String",
"[",
"]",
"args",
")",
"{",
"if",
"(",
"args",
".",
"length",
"<",
"2",
")",
"{",
"System",
".",
"err",
".",
"println",
"(",
"\"Two arguments needed as username and password\"",
")",
";",
"System",
".",
"exit",
"(",
"-",
"1",
")",
";",
"}",
"User",
"user",
"=",
"new",
"User",
"(",
")",
";",
"user",
".",
"name",
"=",
"args",
"[",
"0",
"]",
";",
"user",
".",
"password",
".",
"setPassword",
"(",
"args",
"[",
"1",
"]",
".",
"toCharArray",
"(",
")",
")",
";",
"for",
"(",
"int",
"i",
"=",
"2",
";",
"i",
"<",
"args",
".",
"length",
";",
"i",
"++",
")",
"{",
"user",
".",
"roles",
".",
"add",
"(",
"new",
"UserRole",
"(",
"args",
"[",
"i",
"]",
".",
"trim",
"(",
")",
")",
")",
";",
"}",
"System",
".",
"out",
".",
"println",
"(",
"user",
".",
"format",
"(",
")",
")",
";",
"}"
] | Can be used to create entries in the users textfile
@param args username and password | [
"Can",
"be",
"used",
"to",
"create",
"entries",
"in",
"the",
"users",
"textfile"
] | f7c5461b2b47a10b383aee1e2f1f150f6773703b | https://github.com/BrunoEberhard/minimal-j/blob/f7c5461b2b47a10b383aee1e2f1f150f6773703b/src/main/java/org/minimalj/security/TextFileAuthentication.java#L63-L75 | train |
openengsb/openengsb | components/common/src/main/java/org/openengsb/core/common/transformations/TransformationUtils.java | TransformationUtils.getDescriptionsFromXMLInputStream | public static List<TransformationDescription> getDescriptionsFromXMLInputStream(InputStream fileContent) {
List<TransformationDescription> desc = new ArrayList<TransformationDescription>();
try {
desc = loadDescrtipionsFromXMLInputSource(new InputSource(fileContent), null);
} catch (Exception e) {
LOGGER.error("Unable to read the descriptions from input stream. ", e);
}
return desc;
} | java | public static List<TransformationDescription> getDescriptionsFromXMLInputStream(InputStream fileContent) {
List<TransformationDescription> desc = new ArrayList<TransformationDescription>();
try {
desc = loadDescrtipionsFromXMLInputSource(new InputSource(fileContent), null);
} catch (Exception e) {
LOGGER.error("Unable to read the descriptions from input stream. ", e);
}
return desc;
} | [
"public",
"static",
"List",
"<",
"TransformationDescription",
">",
"getDescriptionsFromXMLInputStream",
"(",
"InputStream",
"fileContent",
")",
"{",
"List",
"<",
"TransformationDescription",
">",
"desc",
"=",
"new",
"ArrayList",
"<",
"TransformationDescription",
">",
"(",
")",
";",
"try",
"{",
"desc",
"=",
"loadDescrtipionsFromXMLInputSource",
"(",
"new",
"InputSource",
"(",
"fileContent",
")",
",",
"null",
")",
";",
"}",
"catch",
"(",
"Exception",
"e",
")",
"{",
"LOGGER",
".",
"error",
"(",
"\"Unable to read the descriptions from input stream. \"",
",",
"e",
")",
";",
"}",
"return",
"desc",
";",
"}"
] | Scans an input stream for transformation descriptions and returns all successfully read transformation
descriptions. | [
"Scans",
"an",
"input",
"stream",
"for",
"transformation",
"descriptions",
"and",
"returns",
"all",
"successfully",
"read",
"transformation",
"descriptions",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/common/src/main/java/org/openengsb/core/common/transformations/TransformationUtils.java#L45-L53 | train |
openengsb/openengsb | components/common/src/main/java/org/openengsb/core/common/transformations/TransformationUtils.java | TransformationUtils.getDescriptionsFromXMLFile | public static List<TransformationDescription> getDescriptionsFromXMLFile(File file) {
List<TransformationDescription> desc = new ArrayList<TransformationDescription>();
try {
return loadDescrtipionsFromXMLInputSource(new InputSource(file.getAbsolutePath()), file.getName());
} catch (Exception e) {
LOGGER.error("Unable to read the descriptions from file " + file.getAbsolutePath(), e);
}
return desc;
} | java | public static List<TransformationDescription> getDescriptionsFromXMLFile(File file) {
List<TransformationDescription> desc = new ArrayList<TransformationDescription>();
try {
return loadDescrtipionsFromXMLInputSource(new InputSource(file.getAbsolutePath()), file.getName());
} catch (Exception e) {
LOGGER.error("Unable to read the descriptions from file " + file.getAbsolutePath(), e);
}
return desc;
} | [
"public",
"static",
"List",
"<",
"TransformationDescription",
">",
"getDescriptionsFromXMLFile",
"(",
"File",
"file",
")",
"{",
"List",
"<",
"TransformationDescription",
">",
"desc",
"=",
"new",
"ArrayList",
"<",
"TransformationDescription",
">",
"(",
")",
";",
"try",
"{",
"return",
"loadDescrtipionsFromXMLInputSource",
"(",
"new",
"InputSource",
"(",
"file",
".",
"getAbsolutePath",
"(",
")",
")",
",",
"file",
".",
"getName",
"(",
")",
")",
";",
"}",
"catch",
"(",
"Exception",
"e",
")",
"{",
"LOGGER",
".",
"error",
"(",
"\"Unable to read the descriptions from file \"",
"+",
"file",
".",
"getAbsolutePath",
"(",
")",
",",
"e",
")",
";",
"}",
"return",
"desc",
";",
"}"
] | Scans a XML file for transformation descriptions and returns all successfully read transformation descriptions. | [
"Scans",
"a",
"XML",
"file",
"for",
"transformation",
"descriptions",
"and",
"returns",
"all",
"successfully",
"read",
"transformation",
"descriptions",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/common/src/main/java/org/openengsb/core/common/transformations/TransformationUtils.java#L58-L66 | train |
openengsb/openengsb | components/common/src/main/java/org/openengsb/core/common/transformations/TransformationUtils.java | TransformationUtils.loadDescrtipionsFromXMLInputSource | private static List<TransformationDescription> loadDescrtipionsFromXMLInputSource(InputSource source,
String fileName) throws Exception {
XMLReader xr = XMLReaderFactory.createXMLReader();
TransformationDescriptionXMLReader reader = new TransformationDescriptionXMLReader(fileName);
xr.setContentHandler(reader);
xr.parse(source);
return reader.getResult();
} | java | private static List<TransformationDescription> loadDescrtipionsFromXMLInputSource(InputSource source,
String fileName) throws Exception {
XMLReader xr = XMLReaderFactory.createXMLReader();
TransformationDescriptionXMLReader reader = new TransformationDescriptionXMLReader(fileName);
xr.setContentHandler(reader);
xr.parse(source);
return reader.getResult();
} | [
"private",
"static",
"List",
"<",
"TransformationDescription",
">",
"loadDescrtipionsFromXMLInputSource",
"(",
"InputSource",
"source",
",",
"String",
"fileName",
")",
"throws",
"Exception",
"{",
"XMLReader",
"xr",
"=",
"XMLReaderFactory",
".",
"createXMLReader",
"(",
")",
";",
"TransformationDescriptionXMLReader",
"reader",
"=",
"new",
"TransformationDescriptionXMLReader",
"(",
"fileName",
")",
";",
"xr",
".",
"setContentHandler",
"(",
"reader",
")",
";",
"xr",
".",
"parse",
"(",
"source",
")",
";",
"return",
"reader",
".",
"getResult",
"(",
")",
";",
"}"
] | Does the actual parsing. | [
"Does",
"the",
"actual",
"parsing",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/common/src/main/java/org/openengsb/core/common/transformations/TransformationUtils.java#L71-L78 | train |
aseovic/coherence-tools | loader/src/main/java/com/seovic/loader/target/AbstractBaseTarget.java | AbstractBaseTarget.getWriteableProperties | protected static List<PropertyDescriptor> getWriteableProperties(Class cls)
{
BeanWrapper beanWrapper = new BeanWrapperImpl(cls);
List<PropertyDescriptor> writeableProperties =
new ArrayList<PropertyDescriptor>();
PropertyDescriptor[] props = beanWrapper.getPropertyDescriptors();
for (PropertyDescriptor prop : props)
{
if (isWriteable(prop))
{
writeableProperties.add(prop);
}
}
return writeableProperties;
} | java | protected static List<PropertyDescriptor> getWriteableProperties(Class cls)
{
BeanWrapper beanWrapper = new BeanWrapperImpl(cls);
List<PropertyDescriptor> writeableProperties =
new ArrayList<PropertyDescriptor>();
PropertyDescriptor[] props = beanWrapper.getPropertyDescriptors();
for (PropertyDescriptor prop : props)
{
if (isWriteable(prop))
{
writeableProperties.add(prop);
}
}
return writeableProperties;
} | [
"protected",
"static",
"List",
"<",
"PropertyDescriptor",
">",
"getWriteableProperties",
"(",
"Class",
"cls",
")",
"{",
"BeanWrapper",
"beanWrapper",
"=",
"new",
"BeanWrapperImpl",
"(",
"cls",
")",
";",
"List",
"<",
"PropertyDescriptor",
">",
"writeableProperties",
"=",
"new",
"ArrayList",
"<",
"PropertyDescriptor",
">",
"(",
")",
";",
"PropertyDescriptor",
"[",
"]",
"props",
"=",
"beanWrapper",
".",
"getPropertyDescriptors",
"(",
")",
";",
"for",
"(",
"PropertyDescriptor",
"prop",
":",
"props",
")",
"{",
"if",
"(",
"isWriteable",
"(",
"prop",
")",
")",
"{",
"writeableProperties",
".",
"add",
"(",
"prop",
")",
";",
"}",
"}",
"return",
"writeableProperties",
";",
"}"
] | Returns a list of all writeable properties of a class.
@param cls class to obtain a list of writeable properties for
@return a list of writeable properties of the specified class | [
"Returns",
"a",
"list",
"of",
"all",
"writeable",
"properties",
"of",
"a",
"class",
"."
] | 561a1d7e572ad98657fcd26beb1164891b0cd6fe | https://github.com/aseovic/coherence-tools/blob/561a1d7e572ad98657fcd26beb1164891b0cd6fe/loader/src/main/java/com/seovic/loader/target/AbstractBaseTarget.java#L112-L126 | train |
aseovic/coherence-tools | core/src/main/java/com/seovic/core/persistence/AbstractJdbcCacheStore.java | AbstractJdbcCacheStore.load | @Transactional(readOnly = true)
public Object load(Object key) {
List<T> results = getJdbcTemplate().query(
getSelectSql(), getRowMapper(), getPrimaryKeyComponents(key));
return results.size() == 0 ? null : results.get(0);
} | java | @Transactional(readOnly = true)
public Object load(Object key) {
List<T> results = getJdbcTemplate().query(
getSelectSql(), getRowMapper(), getPrimaryKeyComponents(key));
return results.size() == 0 ? null : results.get(0);
} | [
"@",
"Transactional",
"(",
"readOnly",
"=",
"true",
")",
"public",
"Object",
"load",
"(",
"Object",
"key",
")",
"{",
"List",
"<",
"T",
">",
"results",
"=",
"getJdbcTemplate",
"(",
")",
".",
"query",
"(",
"getSelectSql",
"(",
")",
",",
"getRowMapper",
"(",
")",
",",
"getPrimaryKeyComponents",
"(",
"key",
")",
")",
";",
"return",
"results",
".",
"size",
"(",
")",
"==",
"0",
"?",
"null",
":",
"results",
".",
"get",
"(",
"0",
")",
";",
"}"
] | Load and return a single object from the data store.
@param key entry key that can be used to find the object in the data
store
@return loaded object or null if the object for the specified key was not
found | [
"Load",
"and",
"return",
"a",
"single",
"object",
"from",
"the",
"data",
"store",
"."
] | 561a1d7e572ad98657fcd26beb1164891b0cd6fe | https://github.com/aseovic/coherence-tools/blob/561a1d7e572ad98657fcd26beb1164891b0cd6fe/core/src/main/java/com/seovic/core/persistence/AbstractJdbcCacheStore.java#L101-L106 | train |
aseovic/coherence-tools | core/src/main/java/com/seovic/core/persistence/AbstractJdbcCacheStore.java | AbstractJdbcCacheStore.store | public void store(Object key, Object value) {
getJdbcTemplate().update(getMergeSql(),
new BeanPropertySqlParameterSource(value));
} | java | public void store(Object key, Object value) {
getJdbcTemplate().update(getMergeSql(),
new BeanPropertySqlParameterSource(value));
} | [
"public",
"void",
"store",
"(",
"Object",
"key",
",",
"Object",
"value",
")",
"{",
"getJdbcTemplate",
"(",
")",
".",
"update",
"(",
"getMergeSql",
"(",
")",
",",
"new",
"BeanPropertySqlParameterSource",
"(",
"value",
")",
")",
";",
"}"
] | Persist a single object into the data store.
@param key entry key of the object that should be persisted
@param value object to persist | [
"Persist",
"a",
"single",
"object",
"into",
"the",
"data",
"store",
"."
] | 561a1d7e572ad98657fcd26beb1164891b0cd6fe | https://github.com/aseovic/coherence-tools/blob/561a1d7e572ad98657fcd26beb1164891b0cd6fe/core/src/main/java/com/seovic/core/persistence/AbstractJdbcCacheStore.java#L117-L120 | train |
FedericoPecora/meta-csp-framework | src/main/java/org/metacsp/utility/UI/PlotSTPTemporalModule.java | PlotSTPTemporalModule.tableToString | String tableToString(Table table)
{
StringBuilder strb = new StringBuilder();
for(int row = 0; row < table.getRowCount(); row++)
{
for(int col = 0; col < table.getColumnCount(); col++)
{
strb.append(table.get(row, col));
strb.append(" ");
}
strb.append("\n");
}
return strb.toString();
} | java | String tableToString(Table table)
{
StringBuilder strb = new StringBuilder();
for(int row = 0; row < table.getRowCount(); row++)
{
for(int col = 0; col < table.getColumnCount(); col++)
{
strb.append(table.get(row, col));
strb.append(" ");
}
strb.append("\n");
}
return strb.toString();
} | [
"String",
"tableToString",
"(",
"Table",
"table",
")",
"{",
"StringBuilder",
"strb",
"=",
"new",
"StringBuilder",
"(",
")",
";",
"for",
"(",
"int",
"row",
"=",
"0",
";",
"row",
"<",
"table",
".",
"getRowCount",
"(",
")",
";",
"row",
"++",
")",
"{",
"for",
"(",
"int",
"col",
"=",
"0",
";",
"col",
"<",
"table",
".",
"getColumnCount",
"(",
")",
";",
"col",
"++",
")",
"{",
"strb",
".",
"append",
"(",
"table",
".",
"get",
"(",
"row",
",",
"col",
")",
")",
";",
"strb",
".",
"append",
"(",
"\" \"",
")",
";",
"}",
"strb",
".",
"append",
"(",
"\"\\n\"",
")",
";",
"}",
"return",
"strb",
".",
"toString",
"(",
")",
";",
"}"
] | end of inner class LabelLayout | [
"end",
"of",
"inner",
"class",
"LabelLayout"
] | 42aaef2e2b76d0f738427f0dd9653c4f62b40517 | https://github.com/FedericoPecora/meta-csp-framework/blob/42aaef2e2b76d0f738427f0dd9653c4f62b40517/src/main/java/org/metacsp/utility/UI/PlotSTPTemporalModule.java#L168-L182 | train |
openengsb/openengsb | api/core/src/main/java/org/openengsb/core/api/model/ModelWrapper.java | ModelWrapper.wrap | public static ModelWrapper wrap(Object model) {
if (!(isModel(model.getClass()))) {
throw new IllegalArgumentException("The given object is no model");
}
return new ModelWrapper((OpenEngSBModel) model);
} | java | public static ModelWrapper wrap(Object model) {
if (!(isModel(model.getClass()))) {
throw new IllegalArgumentException("The given object is no model");
}
return new ModelWrapper((OpenEngSBModel) model);
} | [
"public",
"static",
"ModelWrapper",
"wrap",
"(",
"Object",
"model",
")",
"{",
"if",
"(",
"!",
"(",
"isModel",
"(",
"model",
".",
"getClass",
"(",
")",
")",
")",
")",
"{",
"throw",
"new",
"IllegalArgumentException",
"(",
"\"The given object is no model\"",
")",
";",
"}",
"return",
"new",
"ModelWrapper",
"(",
"(",
"OpenEngSBModel",
")",
"model",
")",
";",
"}"
] | Creates a model wrapper object out of the given model object. Throws IllegalArgumentException in case the given
model object is no model. | [
"Creates",
"a",
"model",
"wrapper",
"object",
"out",
"of",
"the",
"given",
"model",
"object",
".",
"Throws",
"IllegalArgumentException",
"in",
"case",
"the",
"given",
"model",
"object",
"is",
"no",
"model",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/api/core/src/main/java/org/openengsb/core/api/model/ModelWrapper.java#L40-L45 | train |
openengsb/openengsb | api/core/src/main/java/org/openengsb/core/api/model/ModelWrapper.java | ModelWrapper.getModelDescription | public ModelDescription getModelDescription() {
String modelName = retrieveModelName();
String modelVersion = retrieveModelVersion();
if (modelName == null || modelVersion == null) {
throw new IllegalArgumentException("Unsufficient information to create model description.");
}
return new ModelDescription(modelName, modelVersion);
} | java | public ModelDescription getModelDescription() {
String modelName = retrieveModelName();
String modelVersion = retrieveModelVersion();
if (modelName == null || modelVersion == null) {
throw new IllegalArgumentException("Unsufficient information to create model description.");
}
return new ModelDescription(modelName, modelVersion);
} | [
"public",
"ModelDescription",
"getModelDescription",
"(",
")",
"{",
"String",
"modelName",
"=",
"retrieveModelName",
"(",
")",
";",
"String",
"modelVersion",
"=",
"retrieveModelVersion",
"(",
")",
";",
"if",
"(",
"modelName",
"==",
"null",
"||",
"modelVersion",
"==",
"null",
")",
"{",
"throw",
"new",
"IllegalArgumentException",
"(",
"\"Unsufficient information to create model description.\"",
")",
";",
"}",
"return",
"new",
"ModelDescription",
"(",
"modelName",
",",
"modelVersion",
")",
";",
"}"
] | Creates the model description object for the underlying model object. | [
"Creates",
"the",
"model",
"description",
"object",
"for",
"the",
"underlying",
"model",
"object",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/api/core/src/main/java/org/openengsb/core/api/model/ModelWrapper.java#L64-L71 | train |
openengsb/openengsb | api/core/src/main/java/org/openengsb/core/api/model/ModelWrapper.java | ModelWrapper.appendContextId | protected String appendContextId(Object modelId) {
return String.format("%s/%s", ContextHolder.get().getCurrentContextId(), modelId);
} | java | protected String appendContextId(Object modelId) {
return String.format("%s/%s", ContextHolder.get().getCurrentContextId(), modelId);
} | [
"protected",
"String",
"appendContextId",
"(",
"Object",
"modelId",
")",
"{",
"return",
"String",
".",
"format",
"(",
"\"%s/%s\"",
",",
"ContextHolder",
".",
"get",
"(",
")",
".",
"getCurrentContextId",
"(",
")",
",",
"modelId",
")",
";",
"}"
] | Appends the currentContext to the given model id. | [
"Appends",
"the",
"currentContext",
"to",
"the",
"given",
"model",
"id",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/api/core/src/main/java/org/openengsb/core/api/model/ModelWrapper.java#L186-L188 | train |
FedericoPecora/meta-csp-framework | src/main/java/org/metacsp/time/Interval.java | Interval.compareTo | @Override
public int compareTo(Object arg0) {
Interval that = (Interval)arg0;
return this.bounds.compareTo(that.getBounds());
} | java | @Override
public int compareTo(Object arg0) {
Interval that = (Interval)arg0;
return this.bounds.compareTo(that.getBounds());
} | [
"@",
"Override",
"public",
"int",
"compareTo",
"(",
"Object",
"arg0",
")",
"{",
"Interval",
"that",
"=",
"(",
"Interval",
")",
"arg0",
";",
"return",
"this",
".",
"bounds",
".",
"compareTo",
"(",
"that",
".",
"getBounds",
"(",
")",
")",
";",
"}"
] | Compares this to another Interval
@return {@code 1} if this Interval's lower bound is lower than the argument's, {@code 0} if they are the same, {@code 1} otherwise | [
"Compares",
"this",
"to",
"another",
"Interval"
] | 42aaef2e2b76d0f738427f0dd9653c4f62b40517 | https://github.com/FedericoPecora/meta-csp-framework/blob/42aaef2e2b76d0f738427f0dd9653c4f62b40517/src/main/java/org/metacsp/time/Interval.java#L89-L93 | train |
openengsb/openengsb | connector/userprojectsfile/src/main/java/org/openengsb/connector/userprojects/file/internal/file/RoleFileAccessObject.java | RoleFileAccessObject.findAllRoles | public List<Role> findAllRoles() {
List<Role> list = new ArrayList<>();
List<String> roleStrings;
try {
roleStrings = readLines(rolesFile);
} catch (IOException e) {
throw new FileBasedRuntimeException(e);
}
for (String roleString : roleStrings) {
if (StringUtils.isNotBlank(roleString)) {
String[] substrings =
StringUtils.splitByWholeSeparator(roleString, Configuration.get().getAssociationSeparator());
if (substrings.length < 1 || StringUtils.isBlank(substrings[0])) {
continue;
}
Role role = new Role(substrings[0]);
if (substrings.length > 1) {
role.setRoles(Arrays.asList(StringUtils.splitByWholeSeparator(substrings[1], Configuration.get()
.getValueSeparator())));
}
list.add(role);
}
}
return list;
} | java | public List<Role> findAllRoles() {
List<Role> list = new ArrayList<>();
List<String> roleStrings;
try {
roleStrings = readLines(rolesFile);
} catch (IOException e) {
throw new FileBasedRuntimeException(e);
}
for (String roleString : roleStrings) {
if (StringUtils.isNotBlank(roleString)) {
String[] substrings =
StringUtils.splitByWholeSeparator(roleString, Configuration.get().getAssociationSeparator());
if (substrings.length < 1 || StringUtils.isBlank(substrings[0])) {
continue;
}
Role role = new Role(substrings[0]);
if (substrings.length > 1) {
role.setRoles(Arrays.asList(StringUtils.splitByWholeSeparator(substrings[1], Configuration.get()
.getValueSeparator())));
}
list.add(role);
}
}
return list;
} | [
"public",
"List",
"<",
"Role",
">",
"findAllRoles",
"(",
")",
"{",
"List",
"<",
"Role",
">",
"list",
"=",
"new",
"ArrayList",
"<>",
"(",
")",
";",
"List",
"<",
"String",
">",
"roleStrings",
";",
"try",
"{",
"roleStrings",
"=",
"readLines",
"(",
"rolesFile",
")",
";",
"}",
"catch",
"(",
"IOException",
"e",
")",
"{",
"throw",
"new",
"FileBasedRuntimeException",
"(",
"e",
")",
";",
"}",
"for",
"(",
"String",
"roleString",
":",
"roleStrings",
")",
"{",
"if",
"(",
"StringUtils",
".",
"isNotBlank",
"(",
"roleString",
")",
")",
"{",
"String",
"[",
"]",
"substrings",
"=",
"StringUtils",
".",
"splitByWholeSeparator",
"(",
"roleString",
",",
"Configuration",
".",
"get",
"(",
")",
".",
"getAssociationSeparator",
"(",
")",
")",
";",
"if",
"(",
"substrings",
".",
"length",
"<",
"1",
"||",
"StringUtils",
".",
"isBlank",
"(",
"substrings",
"[",
"0",
"]",
")",
")",
"{",
"continue",
";",
"}",
"Role",
"role",
"=",
"new",
"Role",
"(",
"substrings",
"[",
"0",
"]",
")",
";",
"if",
"(",
"substrings",
".",
"length",
">",
"1",
")",
"{",
"role",
".",
"setRoles",
"(",
"Arrays",
".",
"asList",
"(",
"StringUtils",
".",
"splitByWholeSeparator",
"(",
"substrings",
"[",
"1",
"]",
",",
"Configuration",
".",
"get",
"(",
")",
".",
"getValueSeparator",
"(",
")",
")",
")",
")",
";",
"}",
"list",
".",
"add",
"(",
"role",
")",
";",
"}",
"}",
"return",
"list",
";",
"}"
] | Finds all the available roles.
@return the list of available roles | [
"Finds",
"all",
"the",
"available",
"roles",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/connector/userprojectsfile/src/main/java/org/openengsb/connector/userprojects/file/internal/file/RoleFileAccessObject.java#L45-L71 | train |
openengsb/openengsb | ui/common/src/main/java/org/openengsb/ui/common/editor/AttributeEditorUtil.java | AttributeEditorUtil.createFieldList | public static RepeatingView createFieldList(String id, Class<?> bean, Map<String, String> values) {
List<AttributeDefinition> attributes = MethodUtil.buildAttributesList(bean);
return createFieldList(id, attributes, values);
} | java | public static RepeatingView createFieldList(String id, Class<?> bean, Map<String, String> values) {
List<AttributeDefinition> attributes = MethodUtil.buildAttributesList(bean);
return createFieldList(id, attributes, values);
} | [
"public",
"static",
"RepeatingView",
"createFieldList",
"(",
"String",
"id",
",",
"Class",
"<",
"?",
">",
"bean",
",",
"Map",
"<",
"String",
",",
"String",
">",
"values",
")",
"{",
"List",
"<",
"AttributeDefinition",
">",
"attributes",
"=",
"MethodUtil",
".",
"buildAttributesList",
"(",
"bean",
")",
";",
"return",
"createFieldList",
"(",
"id",
",",
"attributes",
",",
"values",
")",
";",
"}"
] | creates a RepeatingView providing a suitable editor field for every property.
@param values map used for saving the data @see org.openengsb.ui.common.wicket.model.MapModel | [
"creates",
"a",
"RepeatingView",
"providing",
"a",
"suitable",
"editor",
"field",
"for",
"every",
"property",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/ui/common/src/main/java/org/openengsb/ui/common/editor/AttributeEditorUtil.java#L53-L56 | train |
openengsb/openengsb | ui/common/src/main/java/org/openengsb/ui/common/editor/AttributeEditorUtil.java | AttributeEditorUtil.createFieldList | public static RepeatingView createFieldList(String id, List<AttributeDefinition> attributes,
Map<String, String> values) {
RepeatingView fields = new RepeatingView(id);
for (AttributeDefinition a : attributes) {
WebMarkupContainer row = new WebMarkupContainer(a.getId());
MapModel<String, String> model = new MapModel<String, String>(values, a.getId());
row.add(createEditorField("row", model, a));
fields.add(row);
}
return fields;
} | java | public static RepeatingView createFieldList(String id, List<AttributeDefinition> attributes,
Map<String, String> values) {
RepeatingView fields = new RepeatingView(id);
for (AttributeDefinition a : attributes) {
WebMarkupContainer row = new WebMarkupContainer(a.getId());
MapModel<String, String> model = new MapModel<String, String>(values, a.getId());
row.add(createEditorField("row", model, a));
fields.add(row);
}
return fields;
} | [
"public",
"static",
"RepeatingView",
"createFieldList",
"(",
"String",
"id",
",",
"List",
"<",
"AttributeDefinition",
">",
"attributes",
",",
"Map",
"<",
"String",
",",
"String",
">",
"values",
")",
"{",
"RepeatingView",
"fields",
"=",
"new",
"RepeatingView",
"(",
"id",
")",
";",
"for",
"(",
"AttributeDefinition",
"a",
":",
"attributes",
")",
"{",
"WebMarkupContainer",
"row",
"=",
"new",
"WebMarkupContainer",
"(",
"a",
".",
"getId",
"(",
")",
")",
";",
"MapModel",
"<",
"String",
",",
"String",
">",
"model",
"=",
"new",
"MapModel",
"<",
"String",
",",
"String",
">",
"(",
"values",
",",
"a",
".",
"getId",
"(",
")",
")",
";",
"row",
".",
"add",
"(",
"createEditorField",
"(",
"\"row\"",
",",
"model",
",",
"a",
")",
")",
";",
"fields",
".",
"add",
"(",
"row",
")",
";",
"}",
"return",
"fields",
";",
"}"
] | creates a RepeatingView providing a suitable editor field for every attribute in the list.
@param values map used for saving the data @see org.openengsb.ui.common.wicket.model.MapModel | [
"creates",
"a",
"RepeatingView",
"providing",
"a",
"suitable",
"editor",
"field",
"for",
"every",
"attribute",
"in",
"the",
"list",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/ui/common/src/main/java/org/openengsb/ui/common/editor/AttributeEditorUtil.java#L63-L73 | train |
openengsb/openengsb | components/ekb/transformation-wonderland/src/main/java/org/openengsb/core/ekb/transformation/wonderland/internal/PropertyConnectionCalculator.java | PropertyConnectionCalculator.getPropertyConnections | public Map<String, Set<String>> getPropertyConnections(TransformationDescription description) {
Map<String, Set<String>> propertyMap = getSourceProperties(description.getSourceModel());
fillPropertyMap(propertyMap, description);
resolveTemporaryProperties(propertyMap);
deleteTemporaryProperties(propertyMap);
return propertyMap;
} | java | public Map<String, Set<String>> getPropertyConnections(TransformationDescription description) {
Map<String, Set<String>> propertyMap = getSourceProperties(description.getSourceModel());
fillPropertyMap(propertyMap, description);
resolveTemporaryProperties(propertyMap);
deleteTemporaryProperties(propertyMap);
return propertyMap;
} | [
"public",
"Map",
"<",
"String",
",",
"Set",
"<",
"String",
">",
">",
"getPropertyConnections",
"(",
"TransformationDescription",
"description",
")",
"{",
"Map",
"<",
"String",
",",
"Set",
"<",
"String",
">",
">",
"propertyMap",
"=",
"getSourceProperties",
"(",
"description",
".",
"getSourceModel",
"(",
")",
")",
";",
"fillPropertyMap",
"(",
"propertyMap",
",",
"description",
")",
";",
"resolveTemporaryProperties",
"(",
"propertyMap",
")",
";",
"deleteTemporaryProperties",
"(",
"propertyMap",
")",
";",
"return",
"propertyMap",
";",
"}"
] | Calculates the connections of properties of the source and target model of a transformation description. Returns
a map where the keys are the properties of the source model and the values are a set of property names which are
influenced if the key property is changed. | [
"Calculates",
"the",
"connections",
"of",
"properties",
"of",
"the",
"source",
"and",
"target",
"model",
"of",
"a",
"transformation",
"description",
".",
"Returns",
"a",
"map",
"where",
"the",
"keys",
"are",
"the",
"properties",
"of",
"the",
"source",
"model",
"and",
"the",
"values",
"are",
"a",
"set",
"of",
"property",
"names",
"which",
"are",
"influenced",
"if",
"the",
"key",
"property",
"is",
"changed",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/ekb/transformation-wonderland/src/main/java/org/openengsb/core/ekb/transformation/wonderland/internal/PropertyConnectionCalculator.java#L52-L58 | train |
openengsb/openengsb | components/ekb/transformation-wonderland/src/main/java/org/openengsb/core/ekb/transformation/wonderland/internal/PropertyConnectionCalculator.java | PropertyConnectionCalculator.getSourceProperties | private Map<String, Set<String>> getSourceProperties(ModelDescription description) {
Map<String, Set<String>> result = new LinkedHashMap<String, Set<String>>();
try {
Class<?> sourceModel = registry.loadModel(description);
while (sourceModel != null && !sourceModel.equals(Object.class)) {
for (Field field : sourceModel.getDeclaredFields()) {
result.put(field.getName(), new HashSet<String>());
}
sourceModel = sourceModel.getSuperclass();
}
} catch (ClassNotFoundException e) {
LOGGER.error("Unable to load model {}", description);
return result;
}
return result;
} | java | private Map<String, Set<String>> getSourceProperties(ModelDescription description) {
Map<String, Set<String>> result = new LinkedHashMap<String, Set<String>>();
try {
Class<?> sourceModel = registry.loadModel(description);
while (sourceModel != null && !sourceModel.equals(Object.class)) {
for (Field field : sourceModel.getDeclaredFields()) {
result.put(field.getName(), new HashSet<String>());
}
sourceModel = sourceModel.getSuperclass();
}
} catch (ClassNotFoundException e) {
LOGGER.error("Unable to load model {}", description);
return result;
}
return result;
} | [
"private",
"Map",
"<",
"String",
",",
"Set",
"<",
"String",
">",
">",
"getSourceProperties",
"(",
"ModelDescription",
"description",
")",
"{",
"Map",
"<",
"String",
",",
"Set",
"<",
"String",
">",
">",
"result",
"=",
"new",
"LinkedHashMap",
"<",
"String",
",",
"Set",
"<",
"String",
">",
">",
"(",
")",
";",
"try",
"{",
"Class",
"<",
"?",
">",
"sourceModel",
"=",
"registry",
".",
"loadModel",
"(",
"description",
")",
";",
"while",
"(",
"sourceModel",
"!=",
"null",
"&&",
"!",
"sourceModel",
".",
"equals",
"(",
"Object",
".",
"class",
")",
")",
"{",
"for",
"(",
"Field",
"field",
":",
"sourceModel",
".",
"getDeclaredFields",
"(",
")",
")",
"{",
"result",
".",
"put",
"(",
"field",
".",
"getName",
"(",
")",
",",
"new",
"HashSet",
"<",
"String",
">",
"(",
")",
")",
";",
"}",
"sourceModel",
"=",
"sourceModel",
".",
"getSuperclass",
"(",
")",
";",
"}",
"}",
"catch",
"(",
"ClassNotFoundException",
"e",
")",
"{",
"LOGGER",
".",
"error",
"(",
"\"Unable to load model {}\"",
",",
"description",
")",
";",
"return",
"result",
";",
"}",
"return",
"result",
";",
"}"
] | Returns a map where the keys are the properties of the model described by the given model description. The values
are empty sets. | [
"Returns",
"a",
"map",
"where",
"the",
"keys",
"are",
"the",
"properties",
"of",
"the",
"model",
"described",
"by",
"the",
"given",
"model",
"description",
".",
"The",
"values",
"are",
"empty",
"sets",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/ekb/transformation-wonderland/src/main/java/org/openengsb/core/ekb/transformation/wonderland/internal/PropertyConnectionCalculator.java#L64-L79 | train |
openengsb/openengsb | components/ekb/transformation-wonderland/src/main/java/org/openengsb/core/ekb/transformation/wonderland/internal/PropertyConnectionCalculator.java | PropertyConnectionCalculator.fillPropertyMap | private void fillPropertyMap(Map<String, Set<String>> map, TransformationDescription description) {
for (TransformationStep step : description.getTransformingSteps()) {
if (step.getSourceFields() == null) {
LOGGER.debug("Step {} is ignored since no source properties are defined");
continue;
}
String targetField = step.getTargetField();
if (!map.containsKey(targetField) && isTemporaryProperty(targetField)) {
LOGGER.debug("Add new property entry for field {}", targetField);
map.put(targetField, new HashSet<String>());
}
for (String sourceField : step.getSourceFields()) {
if (sourceField == null) {
continue;
}
String[] result = StringUtils.split(sourceField, ".");
String mapValue = result[0];
Set<String> targets = map.get(mapValue);
if (targets != null) {
targets.add(targetField);
} else {
LOGGER.error("Accessed property with the name {} which isn't existing", mapValue);
}
}
}
} | java | private void fillPropertyMap(Map<String, Set<String>> map, TransformationDescription description) {
for (TransformationStep step : description.getTransformingSteps()) {
if (step.getSourceFields() == null) {
LOGGER.debug("Step {} is ignored since no source properties are defined");
continue;
}
String targetField = step.getTargetField();
if (!map.containsKey(targetField) && isTemporaryProperty(targetField)) {
LOGGER.debug("Add new property entry for field {}", targetField);
map.put(targetField, new HashSet<String>());
}
for (String sourceField : step.getSourceFields()) {
if (sourceField == null) {
continue;
}
String[] result = StringUtils.split(sourceField, ".");
String mapValue = result[0];
Set<String> targets = map.get(mapValue);
if (targets != null) {
targets.add(targetField);
} else {
LOGGER.error("Accessed property with the name {} which isn't existing", mapValue);
}
}
}
} | [
"private",
"void",
"fillPropertyMap",
"(",
"Map",
"<",
"String",
",",
"Set",
"<",
"String",
">",
">",
"map",
",",
"TransformationDescription",
"description",
")",
"{",
"for",
"(",
"TransformationStep",
"step",
":",
"description",
".",
"getTransformingSteps",
"(",
")",
")",
"{",
"if",
"(",
"step",
".",
"getSourceFields",
"(",
")",
"==",
"null",
")",
"{",
"LOGGER",
".",
"debug",
"(",
"\"Step {} is ignored since no source properties are defined\"",
")",
";",
"continue",
";",
"}",
"String",
"targetField",
"=",
"step",
".",
"getTargetField",
"(",
")",
";",
"if",
"(",
"!",
"map",
".",
"containsKey",
"(",
"targetField",
")",
"&&",
"isTemporaryProperty",
"(",
"targetField",
")",
")",
"{",
"LOGGER",
".",
"debug",
"(",
"\"Add new property entry for field {}\"",
",",
"targetField",
")",
";",
"map",
".",
"put",
"(",
"targetField",
",",
"new",
"HashSet",
"<",
"String",
">",
"(",
")",
")",
";",
"}",
"for",
"(",
"String",
"sourceField",
":",
"step",
".",
"getSourceFields",
"(",
")",
")",
"{",
"if",
"(",
"sourceField",
"==",
"null",
")",
"{",
"continue",
";",
"}",
"String",
"[",
"]",
"result",
"=",
"StringUtils",
".",
"split",
"(",
"sourceField",
",",
"\".\"",
")",
";",
"String",
"mapValue",
"=",
"result",
"[",
"0",
"]",
";",
"Set",
"<",
"String",
">",
"targets",
"=",
"map",
".",
"get",
"(",
"mapValue",
")",
";",
"if",
"(",
"targets",
"!=",
"null",
")",
"{",
"targets",
".",
"add",
"(",
"targetField",
")",
";",
"}",
"else",
"{",
"LOGGER",
".",
"error",
"(",
"\"Accessed property with the name {} which isn't existing\"",
",",
"mapValue",
")",
";",
"}",
"}",
"}",
"}"
] | Fills the given map based on the transformation steps given in the transformation description. It analyzes the
transformation step and adds the target of the transformation step to the set of properties which are influenced
by the source property. | [
"Fills",
"the",
"given",
"map",
"based",
"on",
"the",
"transformation",
"steps",
"given",
"in",
"the",
"transformation",
"description",
".",
"It",
"analyzes",
"the",
"transformation",
"step",
"and",
"adds",
"the",
"target",
"of",
"the",
"transformation",
"step",
"to",
"the",
"set",
"of",
"properties",
"which",
"are",
"influenced",
"by",
"the",
"source",
"property",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/ekb/transformation-wonderland/src/main/java/org/openengsb/core/ekb/transformation/wonderland/internal/PropertyConnectionCalculator.java#L86-L112 | train |
openengsb/openengsb | components/ekb/transformation-wonderland/src/main/java/org/openengsb/core/ekb/transformation/wonderland/internal/PropertyConnectionCalculator.java | PropertyConnectionCalculator.resolveTemporaryProperties | private void resolveTemporaryProperties(Map<String, Set<String>> map) {
boolean temporaryPresent = false;
do {
temporaryPresent = false;
for (Map.Entry<String, Set<String>> entry : map.entrySet()) {
Set<String> newProperties = new HashSet<String>();
Iterator<String> properties = entry.getValue().iterator();
while (properties.hasNext()) {
String property = properties.next();
if (isTemporaryProperty(property)) {
LOGGER.debug("Resolve temporary field {} for property {}", entry.getKey(), property);
temporaryPresent = true;
newProperties.addAll(map.get(property));
properties.remove();
}
}
entry.getValue().addAll(newProperties);
}
} while (temporaryPresent);
} | java | private void resolveTemporaryProperties(Map<String, Set<String>> map) {
boolean temporaryPresent = false;
do {
temporaryPresent = false;
for (Map.Entry<String, Set<String>> entry : map.entrySet()) {
Set<String> newProperties = new HashSet<String>();
Iterator<String> properties = entry.getValue().iterator();
while (properties.hasNext()) {
String property = properties.next();
if (isTemporaryProperty(property)) {
LOGGER.debug("Resolve temporary field {} for property {}", entry.getKey(), property);
temporaryPresent = true;
newProperties.addAll(map.get(property));
properties.remove();
}
}
entry.getValue().addAll(newProperties);
}
} while (temporaryPresent);
} | [
"private",
"void",
"resolveTemporaryProperties",
"(",
"Map",
"<",
"String",
",",
"Set",
"<",
"String",
">",
">",
"map",
")",
"{",
"boolean",
"temporaryPresent",
"=",
"false",
";",
"do",
"{",
"temporaryPresent",
"=",
"false",
";",
"for",
"(",
"Map",
".",
"Entry",
"<",
"String",
",",
"Set",
"<",
"String",
">",
">",
"entry",
":",
"map",
".",
"entrySet",
"(",
")",
")",
"{",
"Set",
"<",
"String",
">",
"newProperties",
"=",
"new",
"HashSet",
"<",
"String",
">",
"(",
")",
";",
"Iterator",
"<",
"String",
">",
"properties",
"=",
"entry",
".",
"getValue",
"(",
")",
".",
"iterator",
"(",
")",
";",
"while",
"(",
"properties",
".",
"hasNext",
"(",
")",
")",
"{",
"String",
"property",
"=",
"properties",
".",
"next",
"(",
")",
";",
"if",
"(",
"isTemporaryProperty",
"(",
"property",
")",
")",
"{",
"LOGGER",
".",
"debug",
"(",
"\"Resolve temporary field {} for property {}\"",
",",
"entry",
".",
"getKey",
"(",
")",
",",
"property",
")",
";",
"temporaryPresent",
"=",
"true",
";",
"newProperties",
".",
"addAll",
"(",
"map",
".",
"get",
"(",
"property",
")",
")",
";",
"properties",
".",
"remove",
"(",
")",
";",
"}",
"}",
"entry",
".",
"getValue",
"(",
")",
".",
"addAll",
"(",
"newProperties",
")",
";",
"}",
"}",
"while",
"(",
"temporaryPresent",
")",
";",
"}"
] | Resolves the temporary properties of the given property map. It replaces the temporary properties in the values
of the given map with the values of the temporary property it replaces. This procedure is done until there are no
more temporary fields present in the values of the map. | [
"Resolves",
"the",
"temporary",
"properties",
"of",
"the",
"given",
"property",
"map",
".",
"It",
"replaces",
"the",
"temporary",
"properties",
"in",
"the",
"values",
"of",
"the",
"given",
"map",
"with",
"the",
"values",
"of",
"the",
"temporary",
"property",
"it",
"replaces",
".",
"This",
"procedure",
"is",
"done",
"until",
"there",
"are",
"no",
"more",
"temporary",
"fields",
"present",
"in",
"the",
"values",
"of",
"the",
"map",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/ekb/transformation-wonderland/src/main/java/org/openengsb/core/ekb/transformation/wonderland/internal/PropertyConnectionCalculator.java#L119-L138 | train |
openengsb/openengsb | components/ekb/transformation-wonderland/src/main/java/org/openengsb/core/ekb/transformation/wonderland/internal/PropertyConnectionCalculator.java | PropertyConnectionCalculator.deleteTemporaryProperties | private void deleteTemporaryProperties(Map<String, Set<String>> map) {
Iterator<String> iterator = map.keySet().iterator();
while (iterator.hasNext()) {
String key = iterator.next();
if (isTemporaryProperty(key)) {
LOGGER.debug("Delete temporary field {} from the connection result", key);
iterator.remove();
}
}
} | java | private void deleteTemporaryProperties(Map<String, Set<String>> map) {
Iterator<String> iterator = map.keySet().iterator();
while (iterator.hasNext()) {
String key = iterator.next();
if (isTemporaryProperty(key)) {
LOGGER.debug("Delete temporary field {} from the connection result", key);
iterator.remove();
}
}
} | [
"private",
"void",
"deleteTemporaryProperties",
"(",
"Map",
"<",
"String",
",",
"Set",
"<",
"String",
">",
">",
"map",
")",
"{",
"Iterator",
"<",
"String",
">",
"iterator",
"=",
"map",
".",
"keySet",
"(",
")",
".",
"iterator",
"(",
")",
";",
"while",
"(",
"iterator",
".",
"hasNext",
"(",
")",
")",
"{",
"String",
"key",
"=",
"iterator",
".",
"next",
"(",
")",
";",
"if",
"(",
"isTemporaryProperty",
"(",
"key",
")",
")",
"{",
"LOGGER",
".",
"debug",
"(",
"\"Delete temporary field {} from the connection result\"",
",",
"key",
")",
";",
"iterator",
".",
"remove",
"(",
")",
";",
"}",
"}",
"}"
] | Iterates over the map entries and removes all temporary properties so that a clean map can be returned to the
user which is interested in the property connections. | [
"Iterates",
"over",
"the",
"map",
"entries",
"and",
"removes",
"all",
"temporary",
"properties",
"so",
"that",
"a",
"clean",
"map",
"can",
"be",
"returned",
"to",
"the",
"user",
"which",
"is",
"interested",
"in",
"the",
"property",
"connections",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/ekb/transformation-wonderland/src/main/java/org/openengsb/core/ekb/transformation/wonderland/internal/PropertyConnectionCalculator.java#L144-L153 | train |
BrunoEberhard/minimal-j | src/main/java/org/minimalj/frontend/Frontend.java | Frontend.loginAtStart | public static boolean loginAtStart() {
boolean loginAtStart = Application.getInstance().isLoginRequired() || Configuration.get("MjLoginAtStart", "false").equals("true");
if (loginAtStart && !Backend.getInstance().isAuthenticationActive()) {
throw new IllegalStateException("Login required but authorization is not configured!");
}
return loginAtStart;
} | java | public static boolean loginAtStart() {
boolean loginAtStart = Application.getInstance().isLoginRequired() || Configuration.get("MjLoginAtStart", "false").equals("true");
if (loginAtStart && !Backend.getInstance().isAuthenticationActive()) {
throw new IllegalStateException("Login required but authorization is not configured!");
}
return loginAtStart;
} | [
"public",
"static",
"boolean",
"loginAtStart",
"(",
")",
"{",
"boolean",
"loginAtStart",
"=",
"Application",
".",
"getInstance",
"(",
")",
".",
"isLoginRequired",
"(",
")",
"||",
"Configuration",
".",
"get",
"(",
"\"MjLoginAtStart\"",
",",
"\"false\"",
")",
".",
"equals",
"(",
"\"true\"",
")",
";",
"if",
"(",
"loginAtStart",
"&&",
"!",
"Backend",
".",
"getInstance",
"(",
")",
".",
"isAuthenticationActive",
"(",
")",
")",
"{",
"throw",
"new",
"IllegalStateException",
"(",
"\"Login required but authorization is not configured!\"",
")",
";",
"}",
"return",
"loginAtStart",
";",
"}"
] | just a helper method for all frontends. Is it at the right place here? | [
"just",
"a",
"helper",
"method",
"for",
"all",
"frontends",
".",
"Is",
"it",
"at",
"the",
"right",
"place",
"here?"
] | f7c5461b2b47a10b383aee1e2f1f150f6773703b | https://github.com/BrunoEberhard/minimal-j/blob/f7c5461b2b47a10b383aee1e2f1f150f6773703b/src/main/java/org/minimalj/frontend/Frontend.java#L54-L60 | train |
BrunoEberhard/minimal-j | src/main/java/org/minimalj/frontend/Frontend.java | Frontend.createInput | public Optional<Input<String>> createInput(int maxLength, InputType inputType, InputComponentListener changeListener) {
return Optional.empty();
} | java | public Optional<Input<String>> createInput(int maxLength, InputType inputType, InputComponentListener changeListener) {
return Optional.empty();
} | [
"public",
"Optional",
"<",
"Input",
"<",
"String",
">",
">",
"createInput",
"(",
"int",
"maxLength",
",",
"InputType",
"inputType",
",",
"InputComponentListener",
"changeListener",
")",
"{",
"return",
"Optional",
".",
"empty",
"(",
")",
";",
"}"
] | Frontends may or may not provide special Inputs. Even a single Frontend
can sometimes support those Inputs and sometimes not. For example a HTML
Frontend depends on the used Browser. Firefox and Microsoft didn't
support date and time Inputs for a long time. Also the used device or the
user preferences can influence whether the returned Optional is empty or
contains an Input.
@param maxLength maximum input length
@param inputType TEXT, EMAIL, ...
@param changeListener listener attached to the Input
@return optional | [
"Frontends",
"may",
"or",
"may",
"not",
"provide",
"special",
"Inputs",
".",
"Even",
"a",
"single",
"Frontend",
"can",
"sometimes",
"support",
"those",
"Inputs",
"and",
"sometimes",
"not",
".",
"For",
"example",
"a",
"HTML",
"Frontend",
"depends",
"on",
"the",
"used",
"Browser",
".",
"Firefox",
"and",
"Microsoft",
"didn",
"t",
"support",
"date",
"and",
"time",
"Inputs",
"for",
"a",
"long",
"time",
".",
"Also",
"the",
"used",
"device",
"or",
"the",
"user",
"preferences",
"can",
"influence",
"whether",
"the",
"returned",
"Optional",
"is",
"empty",
"or",
"contains",
"an",
"Input",
"."
] | f7c5461b2b47a10b383aee1e2f1f150f6773703b | https://github.com/BrunoEberhard/minimal-j/blob/f7c5461b2b47a10b383aee1e2f1f150f6773703b/src/main/java/org/minimalj/frontend/Frontend.java#L98-L100 | train |
BrunoEberhard/minimal-j | src/main/java/org/minimalj/repository/sql/SqlRepository.java | SqlRepository.clear | public void clear() {
List<AbstractTable<?>> tableList = new ArrayList<AbstractTable<?>>(tables.values());
for (AbstractTable<?> table : tableList) {
table.clear();
}
} | java | public void clear() {
List<AbstractTable<?>> tableList = new ArrayList<AbstractTable<?>>(tables.values());
for (AbstractTable<?> table : tableList) {
table.clear();
}
} | [
"public",
"void",
"clear",
"(",
")",
"{",
"List",
"<",
"AbstractTable",
"<",
"?",
">",
">",
"tableList",
"=",
"new",
"ArrayList",
"<",
"AbstractTable",
"<",
"?",
">",
">",
"(",
"tables",
".",
"values",
"(",
")",
")",
";",
"for",
"(",
"AbstractTable",
"<",
"?",
">",
"table",
":",
"tableList",
")",
"{",
"table",
".",
"clear",
"(",
")",
";",
"}",
"}"
] | Use with care. Removes all content of all tables. Should only
be used for JUnit tests. | [
"Use",
"with",
"care",
".",
"Removes",
"all",
"content",
"of",
"all",
"tables",
".",
"Should",
"only",
"be",
"used",
"for",
"JUnit",
"tests",
"."
] | f7c5461b2b47a10b383aee1e2f1f150f6773703b | https://github.com/BrunoEberhard/minimal-j/blob/f7c5461b2b47a10b383aee1e2f1f150f6773703b/src/main/java/org/minimalj/repository/sql/SqlRepository.java#L217-L222 | train |
openengsb/openengsb | api/edb/src/main/java/org/openengsb/core/edb/api/EDBObject.java | EDBObject.getObject | @SuppressWarnings("unchecked")
public <T> T getObject(String key, Class<T> clazz) {
EDBObjectEntry entry = get(key);
return entry == null ? null : (T) entry.getValue();
} | java | @SuppressWarnings("unchecked")
public <T> T getObject(String key, Class<T> clazz) {
EDBObjectEntry entry = get(key);
return entry == null ? null : (T) entry.getValue();
} | [
"@",
"SuppressWarnings",
"(",
"\"unchecked\"",
")",
"public",
"<",
"T",
">",
"T",
"getObject",
"(",
"String",
"key",
",",
"Class",
"<",
"T",
">",
"clazz",
")",
"{",
"EDBObjectEntry",
"entry",
"=",
"get",
"(",
"key",
")",
";",
"return",
"entry",
"==",
"null",
"?",
"null",
":",
"(",
"T",
")",
"entry",
".",
"getValue",
"(",
")",
";",
"}"
] | Returns the value of the EDBObjectEntry for the given key, casted as the given class. Returns null if there is no
element for the given key, or the value for the given key is null. | [
"Returns",
"the",
"value",
"of",
"the",
"EDBObjectEntry",
"for",
"the",
"given",
"key",
"casted",
"as",
"the",
"given",
"class",
".",
"Returns",
"null",
"if",
"there",
"is",
"no",
"element",
"for",
"the",
"given",
"key",
"or",
"the",
"value",
"for",
"the",
"given",
"key",
"is",
"null",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/api/edb/src/main/java/org/openengsb/core/edb/api/EDBObject.java#L154-L158 | train |
openengsb/openengsb | api/edb/src/main/java/org/openengsb/core/edb/api/EDBObject.java | EDBObject.isDeleted | public final Boolean isDeleted() {
Boolean deleted = getObject(DELETED_CONST, Boolean.class);
return deleted != null ? deleted : false;
} | java | public final Boolean isDeleted() {
Boolean deleted = getObject(DELETED_CONST, Boolean.class);
return deleted != null ? deleted : false;
} | [
"public",
"final",
"Boolean",
"isDeleted",
"(",
")",
"{",
"Boolean",
"deleted",
"=",
"getObject",
"(",
"DELETED_CONST",
",",
"Boolean",
".",
"class",
")",
";",
"return",
"deleted",
"!=",
"null",
"?",
"deleted",
":",
"false",
";",
"}"
] | Returns true if the object is deleted. | [
"Returns",
"true",
"if",
"the",
"object",
"is",
"deleted",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/api/edb/src/main/java/org/openengsb/core/edb/api/EDBObject.java#L163-L166 | train |
openengsb/openengsb | api/edb/src/main/java/org/openengsb/core/edb/api/EDBObject.java | EDBObject.putEDBObjectEntry | public void putEDBObjectEntry(String key, Object value) {
putEDBObjectEntry(key, value, value.getClass());
} | java | public void putEDBObjectEntry(String key, Object value) {
putEDBObjectEntry(key, value, value.getClass());
} | [
"public",
"void",
"putEDBObjectEntry",
"(",
"String",
"key",
",",
"Object",
"value",
")",
"{",
"putEDBObjectEntry",
"(",
"key",
",",
"value",
",",
"value",
".",
"getClass",
"(",
")",
")",
";",
"}"
] | Adds an EDBObjectEntry to this EDBObject. It uses the type of the given object value as type parameter | [
"Adds",
"an",
"EDBObjectEntry",
"to",
"this",
"EDBObject",
".",
"It",
"uses",
"the",
"type",
"of",
"the",
"given",
"object",
"value",
"as",
"type",
"parameter"
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/api/edb/src/main/java/org/openengsb/core/edb/api/EDBObject.java#L192-L194 | train |
openengsb/openengsb | api/edb/src/main/java/org/openengsb/core/edb/api/EDBObject.java | EDBObject.appendEntry | private void appendEntry(Map.Entry<String, EDBObjectEntry> entry, StringBuilder builder) {
if (builder.length() > 2) {
builder.append(",");
}
builder.append(" \"").append(entry.getKey()).append("\"");
builder.append(" : ").append(entry.getValue());
} | java | private void appendEntry(Map.Entry<String, EDBObjectEntry> entry, StringBuilder builder) {
if (builder.length() > 2) {
builder.append(",");
}
builder.append(" \"").append(entry.getKey()).append("\"");
builder.append(" : ").append(entry.getValue());
} | [
"private",
"void",
"appendEntry",
"(",
"Map",
".",
"Entry",
"<",
"String",
",",
"EDBObjectEntry",
">",
"entry",
",",
"StringBuilder",
"builder",
")",
"{",
"if",
"(",
"builder",
".",
"length",
"(",
")",
">",
"2",
")",
"{",
"builder",
".",
"append",
"(",
"\",\"",
")",
";",
"}",
"builder",
".",
"append",
"(",
"\" \\\"\"",
")",
".",
"append",
"(",
"entry",
".",
"getKey",
"(",
")",
")",
".",
"append",
"(",
"\"\\\"\"",
")",
";",
"builder",
".",
"append",
"(",
"\" : \"",
")",
".",
"append",
"(",
"entry",
".",
"getValue",
"(",
")",
")",
";",
"}"
] | Analyzes the entry and write the specific information into the StringBuilder. | [
"Analyzes",
"the",
"entry",
"and",
"write",
"the",
"specific",
"information",
"into",
"the",
"StringBuilder",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/api/edb/src/main/java/org/openengsb/core/edb/api/EDBObject.java#L210-L216 | train |
openengsb/openengsb | components/edb/src/main/java/org/openengsb/core/edb/jpa/internal/util/EDBUtils.java | EDBUtils.convertJPAEntryToEDBObjectEntry | public static EDBObjectEntry convertJPAEntryToEDBObjectEntry(JPAEntry entry) {
for (EDBConverterStep step : steps) {
if (step.doesStepFit(entry.getType())) {
LOGGER.debug("EDBConverterStep {} fit for type {}", step.getClass().getName(), entry.getType());
return step.convertToEDBObjectEntry(entry);
}
}
LOGGER.error("No EDBConverterStep fit for JPAEntry {}", entry);
return null;
} | java | public static EDBObjectEntry convertJPAEntryToEDBObjectEntry(JPAEntry entry) {
for (EDBConverterStep step : steps) {
if (step.doesStepFit(entry.getType())) {
LOGGER.debug("EDBConverterStep {} fit for type {}", step.getClass().getName(), entry.getType());
return step.convertToEDBObjectEntry(entry);
}
}
LOGGER.error("No EDBConverterStep fit for JPAEntry {}", entry);
return null;
} | [
"public",
"static",
"EDBObjectEntry",
"convertJPAEntryToEDBObjectEntry",
"(",
"JPAEntry",
"entry",
")",
"{",
"for",
"(",
"EDBConverterStep",
"step",
":",
"steps",
")",
"{",
"if",
"(",
"step",
".",
"doesStepFit",
"(",
"entry",
".",
"getType",
"(",
")",
")",
")",
"{",
"LOGGER",
".",
"debug",
"(",
"\"EDBConverterStep {} fit for type {}\"",
",",
"step",
".",
"getClass",
"(",
")",
".",
"getName",
"(",
")",
",",
"entry",
".",
"getType",
"(",
")",
")",
";",
"return",
"step",
".",
"convertToEDBObjectEntry",
"(",
"entry",
")",
";",
"}",
"}",
"LOGGER",
".",
"error",
"(",
"\"No EDBConverterStep fit for JPAEntry {}\"",
",",
"entry",
")",
";",
"return",
"null",
";",
"}"
] | Converts a JPAEntry object into an EDBObjectEntry element. If there is a problem with the instantiation of the
type of the JPAEntry, the simple string object will be written in the resulting element. To instantiate the type
first the static method "valueOf" of the type will be tried. If that didn't work, then the constructor of the
object with a string parameter is used. If that didn't work either, the simple string will be set in the entry. | [
"Converts",
"a",
"JPAEntry",
"object",
"into",
"an",
"EDBObjectEntry",
"element",
".",
"If",
"there",
"is",
"a",
"problem",
"with",
"the",
"instantiation",
"of",
"the",
"type",
"of",
"the",
"JPAEntry",
"the",
"simple",
"string",
"object",
"will",
"be",
"written",
"in",
"the",
"resulting",
"element",
".",
"To",
"instantiate",
"the",
"type",
"first",
"the",
"static",
"method",
"valueOf",
"of",
"the",
"type",
"will",
"be",
"tried",
".",
"If",
"that",
"didn",
"t",
"work",
"then",
"the",
"constructor",
"of",
"the",
"object",
"with",
"a",
"string",
"parameter",
"is",
"used",
".",
"If",
"that",
"didn",
"t",
"work",
"either",
"the",
"simple",
"string",
"will",
"be",
"set",
"in",
"the",
"entry",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/edb/src/main/java/org/openengsb/core/edb/jpa/internal/util/EDBUtils.java#L48-L57 | train |
openengsb/openengsb | components/edb/src/main/java/org/openengsb/core/edb/jpa/internal/util/EDBUtils.java | EDBUtils.convertEDBObjectEntryToJPAEntry | public static JPAEntry convertEDBObjectEntryToJPAEntry(EDBObjectEntry entry, JPAObject owner) {
for (EDBConverterStep step : steps) {
if (step.doesStepFit(entry.getType())) {
LOGGER.debug("EDBConverterStep {} fit for type {}", step.getClass().getName(), entry.getType());
return step.convertToJPAEntry(entry, owner);
}
}
LOGGER.error("No EDBConverterStep fit for EDBObjectEntry {}", entry);
return null;
} | java | public static JPAEntry convertEDBObjectEntryToJPAEntry(EDBObjectEntry entry, JPAObject owner) {
for (EDBConverterStep step : steps) {
if (step.doesStepFit(entry.getType())) {
LOGGER.debug("EDBConverterStep {} fit for type {}", step.getClass().getName(), entry.getType());
return step.convertToJPAEntry(entry, owner);
}
}
LOGGER.error("No EDBConverterStep fit for EDBObjectEntry {}", entry);
return null;
} | [
"public",
"static",
"JPAEntry",
"convertEDBObjectEntryToJPAEntry",
"(",
"EDBObjectEntry",
"entry",
",",
"JPAObject",
"owner",
")",
"{",
"for",
"(",
"EDBConverterStep",
"step",
":",
"steps",
")",
"{",
"if",
"(",
"step",
".",
"doesStepFit",
"(",
"entry",
".",
"getType",
"(",
")",
")",
")",
"{",
"LOGGER",
".",
"debug",
"(",
"\"EDBConverterStep {} fit for type {}\"",
",",
"step",
".",
"getClass",
"(",
")",
".",
"getName",
"(",
")",
",",
"entry",
".",
"getType",
"(",
")",
")",
";",
"return",
"step",
".",
"convertToJPAEntry",
"(",
"entry",
",",
"owner",
")",
";",
"}",
"}",
"LOGGER",
".",
"error",
"(",
"\"No EDBConverterStep fit for EDBObjectEntry {}\"",
",",
"entry",
")",
";",
"return",
"null",
";",
"}"
] | Converts a JPAEntry object into an EDBObjectEntry. | [
"Converts",
"a",
"JPAEntry",
"object",
"into",
"an",
"EDBObjectEntry",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/edb/src/main/java/org/openengsb/core/edb/jpa/internal/util/EDBUtils.java#L62-L71 | train |
openengsb/openengsb | components/edb/src/main/java/org/openengsb/core/edb/jpa/internal/util/EDBUtils.java | EDBUtils.convertJPAObjectToEDBObject | public static EDBObject convertJPAObjectToEDBObject(JPAObject object) {
EDBObject result = new EDBObject(object.getOID());
for (JPAEntry kvp : object.getEntries()) {
EDBObjectEntry entry = convertJPAEntryToEDBObjectEntry(kvp);
result.put(entry.getKey(), entry);
}
result.setDeleted(object.isDeleted());
if (object.getTimestamp() != null) {
result.updateTimestamp(object.getTimestamp());
}
return result;
} | java | public static EDBObject convertJPAObjectToEDBObject(JPAObject object) {
EDBObject result = new EDBObject(object.getOID());
for (JPAEntry kvp : object.getEntries()) {
EDBObjectEntry entry = convertJPAEntryToEDBObjectEntry(kvp);
result.put(entry.getKey(), entry);
}
result.setDeleted(object.isDeleted());
if (object.getTimestamp() != null) {
result.updateTimestamp(object.getTimestamp());
}
return result;
} | [
"public",
"static",
"EDBObject",
"convertJPAObjectToEDBObject",
"(",
"JPAObject",
"object",
")",
"{",
"EDBObject",
"result",
"=",
"new",
"EDBObject",
"(",
"object",
".",
"getOID",
"(",
")",
")",
";",
"for",
"(",
"JPAEntry",
"kvp",
":",
"object",
".",
"getEntries",
"(",
")",
")",
"{",
"EDBObjectEntry",
"entry",
"=",
"convertJPAEntryToEDBObjectEntry",
"(",
"kvp",
")",
";",
"result",
".",
"put",
"(",
"entry",
".",
"getKey",
"(",
")",
",",
"entry",
")",
";",
"}",
"result",
".",
"setDeleted",
"(",
"object",
".",
"isDeleted",
"(",
")",
")",
";",
"if",
"(",
"object",
".",
"getTimestamp",
"(",
")",
"!=",
"null",
")",
"{",
"result",
".",
"updateTimestamp",
"(",
"object",
".",
"getTimestamp",
"(",
")",
")",
";",
"}",
"return",
"result",
";",
"}"
] | Converts a JPAObject object into an EDBObject. | [
"Converts",
"a",
"JPAObject",
"object",
"into",
"an",
"EDBObject",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/edb/src/main/java/org/openengsb/core/edb/jpa/internal/util/EDBUtils.java#L76-L87 | train |
openengsb/openengsb | components/edb/src/main/java/org/openengsb/core/edb/jpa/internal/util/EDBUtils.java | EDBUtils.convertEDBObjectToJPAObject | public static JPAObject convertEDBObjectToJPAObject(EDBObject object) {
JPAObject result = new JPAObject();
result.setTimestamp(object.getTimestamp());
result.setOID(object.getOID());
result.setDeleted(object.isDeleted());
List<JPAEntry> entries = new ArrayList<JPAEntry>();
for (EDBObjectEntry entry : object.values()) {
entries.add(convertEDBObjectEntryToJPAEntry(entry, result));
}
result.setEntries(entries);
return result;
} | java | public static JPAObject convertEDBObjectToJPAObject(EDBObject object) {
JPAObject result = new JPAObject();
result.setTimestamp(object.getTimestamp());
result.setOID(object.getOID());
result.setDeleted(object.isDeleted());
List<JPAEntry> entries = new ArrayList<JPAEntry>();
for (EDBObjectEntry entry : object.values()) {
entries.add(convertEDBObjectEntryToJPAEntry(entry, result));
}
result.setEntries(entries);
return result;
} | [
"public",
"static",
"JPAObject",
"convertEDBObjectToJPAObject",
"(",
"EDBObject",
"object",
")",
"{",
"JPAObject",
"result",
"=",
"new",
"JPAObject",
"(",
")",
";",
"result",
".",
"setTimestamp",
"(",
"object",
".",
"getTimestamp",
"(",
")",
")",
";",
"result",
".",
"setOID",
"(",
"object",
".",
"getOID",
"(",
")",
")",
";",
"result",
".",
"setDeleted",
"(",
"object",
".",
"isDeleted",
"(",
")",
")",
";",
"List",
"<",
"JPAEntry",
">",
"entries",
"=",
"new",
"ArrayList",
"<",
"JPAEntry",
">",
"(",
")",
";",
"for",
"(",
"EDBObjectEntry",
"entry",
":",
"object",
".",
"values",
"(",
")",
")",
"{",
"entries",
".",
"add",
"(",
"convertEDBObjectEntryToJPAEntry",
"(",
"entry",
",",
"result",
")",
")",
";",
"}",
"result",
".",
"setEntries",
"(",
"entries",
")",
";",
"return",
"result",
";",
"}"
] | Converts an EDBObject object into a JPAObject object. | [
"Converts",
"an",
"EDBObject",
"object",
"into",
"a",
"JPAObject",
"object",
"."
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/edb/src/main/java/org/openengsb/core/edb/jpa/internal/util/EDBUtils.java#L92-L103 | train |
openengsb/openengsb | components/edb/src/main/java/org/openengsb/core/edb/jpa/internal/util/EDBUtils.java | EDBUtils.convertEDBObjectsToJPAObjects | public static List<JPAObject> convertEDBObjectsToJPAObjects(List<EDBObject> objects) {
List<JPAObject> result = new ArrayList<JPAObject>();
for (EDBObject object : objects) {
result.add(convertEDBObjectToJPAObject(object));
}
return result;
} | java | public static List<JPAObject> convertEDBObjectsToJPAObjects(List<EDBObject> objects) {
List<JPAObject> result = new ArrayList<JPAObject>();
for (EDBObject object : objects) {
result.add(convertEDBObjectToJPAObject(object));
}
return result;
} | [
"public",
"static",
"List",
"<",
"JPAObject",
">",
"convertEDBObjectsToJPAObjects",
"(",
"List",
"<",
"EDBObject",
">",
"objects",
")",
"{",
"List",
"<",
"JPAObject",
">",
"result",
"=",
"new",
"ArrayList",
"<",
"JPAObject",
">",
"(",
")",
";",
"for",
"(",
"EDBObject",
"object",
":",
"objects",
")",
"{",
"result",
".",
"add",
"(",
"convertEDBObjectToJPAObject",
"(",
"object",
")",
")",
";",
"}",
"return",
"result",
";",
"}"
] | Converts a list of EDBObjects into a list of JPAObjects | [
"Converts",
"a",
"list",
"of",
"EDBObjects",
"into",
"a",
"list",
"of",
"JPAObjects"
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/edb/src/main/java/org/openengsb/core/edb/jpa/internal/util/EDBUtils.java#L108-L114 | train |
openengsb/openengsb | components/edb/src/main/java/org/openengsb/core/edb/jpa/internal/util/EDBUtils.java | EDBUtils.convertJPAObjectsToEDBObjects | public static List<EDBObject> convertJPAObjectsToEDBObjects(List<JPAObject> objects) {
List<EDBObject> result = new ArrayList<EDBObject>();
for (JPAObject object : objects) {
result.add(convertJPAObjectToEDBObject(object));
}
return result;
} | java | public static List<EDBObject> convertJPAObjectsToEDBObjects(List<JPAObject> objects) {
List<EDBObject> result = new ArrayList<EDBObject>();
for (JPAObject object : objects) {
result.add(convertJPAObjectToEDBObject(object));
}
return result;
} | [
"public",
"static",
"List",
"<",
"EDBObject",
">",
"convertJPAObjectsToEDBObjects",
"(",
"List",
"<",
"JPAObject",
">",
"objects",
")",
"{",
"List",
"<",
"EDBObject",
">",
"result",
"=",
"new",
"ArrayList",
"<",
"EDBObject",
">",
"(",
")",
";",
"for",
"(",
"JPAObject",
"object",
":",
"objects",
")",
"{",
"result",
".",
"add",
"(",
"convertJPAObjectToEDBObject",
"(",
"object",
")",
")",
";",
"}",
"return",
"result",
";",
"}"
] | Converts a list of JPAObjects into a list of EDBObjects | [
"Converts",
"a",
"list",
"of",
"JPAObjects",
"into",
"a",
"list",
"of",
"EDBObjects"
] | d39058000707f617cd405629f9bc7f17da7b414a | https://github.com/openengsb/openengsb/blob/d39058000707f617cd405629f9bc7f17da7b414a/components/edb/src/main/java/org/openengsb/core/edb/jpa/internal/util/EDBUtils.java#L119-L125 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.