code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
public Tree putObject(String path, Object value) {
return putObjectInternal(path, getNodeValue(value), false);
} | java |
public static Instance readInstance(File f) {
try (Reader in = makeIn(f)) {
return readInstance(in);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
} | java |
public static Instance readInstance(Reader r) {
try {
InstanceConverter c = new InstanceConverter();
return c.fromJSON(r);
} catch (JSONConverterException e) {
throw new IllegalArgumentException(e);
}
} | java |
public static void write(Instance instance, File f) {
try (OutputStreamWriter out = makeOut(f)) {
write(instance, out);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
} | java |
public static void write(Instance instance, Appendable a) {
try {
InstanceConverter c = new InstanceConverter();
c.toJSON(instance).writeJSONString(a);
} catch (IOException | JSONConverterException e) {
throw new IllegalArgumentException(e);
}
} | java |
public static ReconfigurationPlan readReconfigurationPlan(File f) {
try (Reader in = makeIn(f)) {
return readReconfigurationPlan(in);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
} | java |
public static ReconfigurationPlan readReconfigurationPlan(Reader r) {
try {
ReconfigurationPlanConverter c = new ReconfigurationPlanConverter();
return c.fromJSON(r);
} catch (JSONConverterException e) {
throw new IllegalArgumentException(e);
}
} | java |
public Collection<Node> getAssociatedPGroup(Node u) {
for (Collection<Node> pGrp : pGroups) {
if (pGrp.contains(u)) {
return pGrp;
}
}
return Collections.emptySet();
} | java |
static public Collection<URI> removeRedundantPaths(Collection<URI> uris) {
List<URI> result = new ArrayList<URI>();
for (URI uri : uris) {
String path = uri.getPath();
if (!path.endsWith("/")) { //$NON-NLS-1$
path += "/"; //$NON-NLS-1$
}
boolean addIt = true;
for (int i = 0; i < result.size(); i++) {
URI testUri = result.get(i);
if (!StringUtils.equals(testUri.getScheme(), uri.getScheme()) ||
!StringUtils.equals(testUri.getHost(), uri.getHost()) ||
testUri.getPort() != uri.getPort()) {
continue;
}
String test = testUri.getPath();
if (!test.endsWith("/")) { //$NON-NLS-1$
test += "/"; //$NON-NLS-1$
}
if (path.equals(test) || path.startsWith(test)) {
addIt = false;
break;
} else if (test.startsWith(path)) {
result.remove(i);
}
}
if (addIt)
result.add(uri);
}
// Now copy the trimmed list back to the original
return result;
} | java |
static Object convert(Object object, Class<?> otherType) {
if (otherType == BigDecimal.class) {
if (object instanceof BigInteger) {
return new BigDecimal((BigInteger) object);
} else if (object instanceof Number) {
return BigDecimal.valueOf(((Number) object).doubleValue());
}
} else if (otherType == BigInteger.class) {
if (!(object instanceof BigDecimal) && (object instanceof Number)) {
return BigInteger.valueOf(((Number) object).longValue());
}
}
return object;
} | java |
public InputStream getInputStream(HttpServletRequest request, MutableObject<byte[]> sourceMapResult) throws IOException {
// Check bytes before filename when reading and reverse order when setting.
// The following local variables intentionally hide the instance variables.
byte[] bytes = this.bytes;
byte[] sourceMap = this.sourceMap;
String filename = this.filename;
InputStream result = null;
if (bytes != null) {
// Cache data is already in memory. Don't need to de-serialize it.
result = new ByteArrayInputStream(bytes);
if (sourceMapResult != null && sourceMapSize > 0) {
sourceMapResult.setValue(sourceMap);
}
} else if (filename != null){
// De-serialize data from cache
ICacheManager cmgr = ((IAggregator)request.getAttribute(IAggregator.AGGREGATOR_REQATTRNAME)).getCacheManager();
File file = new File(cmgr.getCacheDir(), filename);
if (sourceMapSize == 0) {
// No source map data in cache entry so just stream the file.
result = new FileInputStream(file);
} else {
// Entry contains source map data so that means it's a serialized CacheData
// instance. De-serialize the object and extract the data.
CacheData data;
ObjectInputStream is = new ObjectInputStream(
new FileInputStream(file));
try {
data = (CacheData)is.readObject();
} catch (ClassNotFoundException e) {
throw new IOException(e.getMessage(), e);
} finally {
IOUtils.closeQuietly(is);
}
bytes = data.bytes;
sourceMap = data.sourceMap;
if (sourceMapResult != null) {
sourceMapResult.setValue(sourceMap);
}
result = new ByteArrayInputStream(bytes);
}
} else {
throw new IOException();
}
return result;
} | java |
public InputStream tryGetInputStream(HttpServletRequest request, MutableObject<byte[]> sourceMapResult) throws IOException {
InputStream result = null;
// Check bytes before filename when reading and reverse order when setting
if (bytes != null || filename != null) {
try {
result = getInputStream(request, sourceMapResult);
} catch (Exception e) {
if (LayerImpl.log.isLoggable(Level.SEVERE)) {
LayerImpl.log.log(Level.SEVERE, e.getMessage(), e);
}
// just return null
}
}
return result;
} | java |
public void setData(byte[] bytes, byte[] sourceMap) {
this.sourceMap = sourceMap;
sourceMapSize = sourceMap != null ? sourceMap.length : 0;
setBytes(bytes);
} | java |
public synchronized void delete(final ICacheManager mgr) {
delete = true;
if (filename != null) {
mgr.deleteFileDelayed(filename);
}
} | java |
public void persist(final ICacheManager mgr) throws IOException {
if (delete) return;
if (sourceMapSize == 0) {
// No source map. Just stream the file
mgr.createCacheFileAsync("layer.", //$NON-NLS-1$
new ByteArrayInputStream(bytes),
new CreateCompletionCallback(mgr));
} else {
// cache entry contains source map info. Create a CacheData instance
// and serialize object.
Object data = new CacheData(bytes, sourceMap);
mgr.externalizeCacheObjectAsync("layer.", //$NON-NLS-1$
data,
new CreateCompletionCallback(mgr));
}
} | java |
public void register(ConstraintConverter<? extends Constraint> c) {
java2json.put(c.getSupportedConstraint(), c);
json2java.put(c.getJSONId(), c);
} | java |
public Constraint fromJSON(Model mo, JSONObject in) throws JSONConverterException {
checkKeys(in, "id");
Object id = in.get("id");
ConstraintConverter<? extends Constraint> c = json2java.get(id.toString());
if (c == null) {
throw new JSONConverterException("No converter available for a constraint having id '" + id + "'");
}
return c.fromJSON(mo, in);
} | java |
public JSONObject toJSON(Constraint o) throws JSONConverterException {
ConstraintConverter c = java2json.get(o.getClass());
if (c == null) {
throw new JSONConverterException("No converter available for a constraint with the '" + o.getClass() + "' className");
}
return c.toJSON(o);
} | java |
public List<SatConstraint> listFromJSON(Model mo, JSONArray in) throws JSONConverterException {
List<SatConstraint> l = new ArrayList<>(in.size());
for (Object o : in) {
if (!(o instanceof JSONObject)) {
throw new JSONConverterException("Expected an array of JSONObject but got an array of " + o.getClass().getName());
}
l.add((SatConstraint) fromJSON(mo, (JSONObject) o));
}
return l;
} | java |
public JSONArray toJSON(Collection<SatConstraint> e) throws JSONConverterException {
JSONArray arr = new JSONArray();
for (SatConstraint cstr : e) {
arr.add(toJSON(cstr));
}
return arr;
} | java |
public synchronized void clear() {
_layerCache.clear();
_moduleCache.clear();
_gzipCache.clear();
for (IGenericCache cache : _namedCaches.values()) {
cache.clear();
}
} | java |
public String toGrammarRules() {
StringBuffer sb = new StringBuffer();
System.out.println("R0 -> " + this.r0String);
for (int i = 1; i <= this.theRules.size(); i++) {
RePairRule r = this.theRules.get(i);
sb.append(THE_R).append(r.ruleNumber).append(" -> ").append(r.toRuleString()).append(" : ")
.append(r.expandedRuleString).append(", ").append(r.occurrences).append("\n");
}
return sb.toString();
} | java |
public GrammarRules toGrammarRulesData() {
GrammarRules res = new GrammarRules();
GrammarRuleRecord r0 = new GrammarRuleRecord();
r0.setRuleNumber(0);
r0.setRuleString(this.r0String);
r0.setExpandedRuleString(this.r0ExpandedString);
r0.setOccurrences(new int[] { 0 });
r0.setMeanLength(-1);
r0.setMinMaxLength(new int[] { -1 });
res.addRule(r0);
for (RePairRule rule : theRules.values()) {
// System.out.println("processing the rule " + rule.ruleNumber);
GrammarRuleRecord rec = new GrammarRuleRecord();
rec.setRuleNumber(rule.ruleNumber);
rec.setRuleString(rule.toRuleString());
rec.setExpandedRuleString(rule.expandedRuleString);
rec.setRuleYield(countSpaces(rule.expandedRuleString));
rec.setOccurrences(rule.getOccurrences());
rec.setRuleIntervals(rule.getRuleIntervals());
rec.setRuleLevel(rule.getLevel());
rec.setMinMaxLength(rule.getLengths());
rec.setMeanLength(mean(rule.getRuleIntervals()));
res.addRule(rec);
}
// count the rule use
for (GrammarRuleRecord r : res) {
String str = r.getRuleString();
String[] tokens = str.split("\\s+");
for (String t : tokens) {
if (t.startsWith("R")) {
Integer ruleId = Integer.valueOf(t.substring(1));
GrammarRuleRecord rr = res.get(ruleId);
// System.out.print(rr.getRuleUseFrequency() + " ");
int newFreq = rr.getRuleUseFrequency() + 1;
rr.setRuleUseFrequency(newFreq);
// System.out.println(rr.getRuleUseFrequency());
}
}
}
return res;
} | java |
public void buildIntervals(SAXRecords records, double[] originalTimeSeries,
int slidingWindowSize) {
records.buildIndex();
for (int ruleIdx = 1; ruleIdx <= this.theRules.size(); ruleIdx++) {
RePairRule rr = this.theRules.get(ruleIdx);
String[] split = rr.expandedRuleString.split(" ");
for (int strPos : rr.getOccurrences()) {
Integer tsPos = records.mapStringIndexToTSPosition(strPos + split.length - 1);
if (null == tsPos) {
rr.ruleIntervals.add(new RuleInterval(records.mapStringIndexToTSPosition(strPos),
originalTimeSeries.length + 1)); // +1 cause right point is excluded
}
else {
rr.ruleIntervals.add(new RuleInterval(records.mapStringIndexToTSPosition(strPos),
records.mapStringIndexToTSPosition(strPos + split.length - 1) + slidingWindowSize));
}
}
}
} | java |
private static Class<?> fromPrimitive(Class<?> clazz) {
Class<?> clazz2 = PRIMITIVE_TO_CLASS.get(clazz);
return clazz2 == null ? clazz : clazz2;
} | java |
private static DiagnosticGroup findNamedDiagnosticGroup(String name) {
final String sourceMethod = "findNamedDiagnosticGroup"; //$NON-NLS-1$
final boolean isTraceLogging = log.isLoggable(Level.FINER);
if (isTraceLogging) {
log.entering(sourceClass, sourceMethod, new Object[]{name});
}
DiagnosticGroup result = null;
Class<DiagnosticGroups> clazz = DiagnosticGroups.class;
// iterate through the public static fields looking for a match
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
int modifier = field.getModifiers();
if (field.getType().isAssignableFrom(DiagnosticGroup.class) &&
(modifier & Modifier.STATIC) != 0 && (modifier & Modifier.PUBLIC) != 0 &&
field.getName().equals(name)) {
try {
result = (DiagnosticGroup)field.get(null);
break;
} catch (Exception e) {
// Shouldn't ever happen with public static fields
if (log.isLoggable(Level.WARNING)) {
log.logp(Level.WARNING, sourceClass, sourceMethod, e.getMessage(), e);
}
}
}
}
if (isTraceLogging) {
log.exiting(sourceMethod, sourceMethod, result);
}
return result;
} | java |
protected String postcss(HttpServletRequest request, String css, IResource res) throws IOException {
if (threadScopes == null) {
return css;
}
Context cx = Context.enter();
Scriptable threadScope = null;
String result = null;
try {
threadScope = threadScopes.poll(SCOPE_POOL_TIMEOUT_SECONDS, TimeUnit.SECONDS);
if (threadScope == null) {
throw new TimeoutException("Timeout waiting for thread scope"); //$NON-NLS-1$
}
Scriptable scope = cx.newObject(threadScope);
scope.setParentScope(threadScope);
Scriptable postcssInstance = (Scriptable)threadScope.get(POSTCSS_INSTANCE, scope);
Function postcssProcessor = (Function)postcssInstance.getPrototype().get(PROCESS, postcssInstance);
Object processed = postcssProcessor.call(cx, scope, postcssInstance, new Object[]{css, postcssOptions});
result = Context.toString(processed);
} catch (JavaScriptException e) {
// Add module info
String message = "Error parsing " + res.getURI() + "\r\n" + e.getMessage(); //$NON-NLS-1$ //$NON-NLS-2$
throw new IOException(message, e);
} catch (InterruptedException e) {
throw new RuntimeException(e);
} catch (TimeoutException e) {
throw new RuntimeException(e);
}
finally {
if (threadScope != null) {
// put the thread scope back in the queue now that we're done with it
threadScopes.add(threadScope);
}
Context.exit();
}
return result;
} | java |
protected Scriptable createThreadScope(Context cx, Scriptable protoScope) {
// Create the scope object
Scriptable scope = cx.newObject(protoScope);
scope.setPrototype(protoScope);
scope.setParentScope(null);
// Set "global" variable to point to global scope
scope.put("global", scope, scope); //$NON-NLS-1$
// Evaluate PostCSS javascript
postcssJsScript.exec(cx, scope);
// Initialize the plugins array that we pass to PostCSS
NativeArray plugins = (NativeArray)cx.newArray(scope, 0);
// Get reference to Array.prototype.push() so that we can add elements
Function pushFn = (Function)plugins.getPrototype().get("push", scope); //$NON-NLS-1$
/*
* Now load and initialize plugins
*/
for (PluginInfo info : pluginInfoList) {
// Set up new scope for defining the module so that module.exports is not shared between plugins
Scriptable defineScope = cx.newObject(scope);
defineScope.setParentScope(scope);
amdDefineShimScript.exec(cx, defineScope);
Scriptable moduleVar = (Scriptable)defineScope.get(MODULE, defineScope);
info.moduleScript.exec(cx, defineScope);
// Retrieve the module reference and initialize the plugin
Function module = (Function)moduleVar.get(EXPORTS, moduleVar);
Scriptable plugin = (Scriptable)info.initializer.call(cx, scope, scope, new Object[]{module});
// Add the plugin to the array
pushFn.call(cx, scope, plugins, new Object[]{plugin});
}
// Create an instance of the PostCSS processor and save to a variable in thread scope
Function postcss = (Function)scope.get(POSTCSS, scope);
postcssOptions = (Scriptable)Context.javaToJS(POSTCSS_OPTIONS, scope);
Scriptable postcssInstance = (Scriptable)postcss.call(cx, scope, scope, new Object[]{plugins});
scope.put(POSTCSS_INSTANCE, scope, postcssInstance);
return scope;
} | java |
public String dequote(String in) {
String result = in.trim();
if (result.charAt(0) == '"' && result.charAt(result.length()-1) == '"') {
return result.substring(1, result.length()-1);
}
if (result.charAt(0) == '\'' && result.charAt(result.length()-1) == '\'') {
return result.substring(1, result.length()-1);
}
return result;
} | java |
public tr tr(int index) {
while (trList.size() <= index) {
trList.add(new tr());
}
return trList.get(index);
} | java |
public tr addTr(Map<String, Object> attrMap) {
tr tr = new tr();
tr.setAttr(attrMap);
trList.add(tr);
return tr;
} | java |
public <T extends AbstractJaxb> TableBuilder addTr(List<Object> tdList)
throws TagTypeUnmatchException {
return addTr(tdList, null);
} | java |
@SuppressWarnings("unchecked")
public <T extends AbstractJaxb> TableBuilder addTr(List<Object> tdList,
Map<String, Object> attrMap) throws TagTypeUnmatchException {
tr tr = new tr();
tr.setAttr(attrMap);
for (Object obj : tdList) {
if (obj instanceof String) {
tr.addTd((String) obj);
} else if (obj instanceof AbstractJaxb) {
tr.addTd((T) obj);
} else {
throw new TagTypeUnmatchException(
"String or other tag object expected but tdList contains "
+ obj.getClass().getName());
}
}
trList.add(tr);
return this;
} | java |
public tbody tbody(int index) {
while (tbodyList.size() <= index) {
tbodyList.add(new tbody());
}
return tbodyList.get(index);
} | java |
public TableBuilder addTbody(List<List<Object>> trList)
throws TagTypeUnmatchException {
addTbody(trList, null);
return this;
} | java |
public Table build() {
Table table = new Table();
Thead _thead = thead.buildThead();
if (_thead != null) {
table.setThead(_thead);
}
Tfoot _tfoot = tfoot.buildTfoot();
if (_tfoot != null) {
table.setTfoot(_tfoot);
}
for (tbody _tbody : tbodyList) {
table.getTbody().add(_tbody.buildTbody());
}
for (tr _tr : trList) {
table.getTr().add(_tr.buildTr());
}
return table;
} | java |
protected String getVersion() {
Manifest manifest = ManifestLoader.loadManifest(getClass());
String versionNumber = null;
if (manifest != null) {
versionNumber = ManifestLoader.getValue(manifest, Attributes.Name.IMPLEMENTATION_VERSION);
if (versionNumber == null) {
versionNumber = ManifestLoader.getValue(manifest, Attributes.Name.SPECIFICATION_VERSION);
}
}
if (versionNumber == null) {
versionNumber = SNAPSHOT;
}
return versionNumber;
} | java |
protected void setValueInternal(String argument, char separator, GenericType<?> propertyType) {
if (this.valueAlreadySet) {
CliOptionDuplicateException exception = new CliOptionDuplicateException(getParameterContainer().getName());
CliStyleHandling.EXCEPTION.handle(getLogger(), exception);
}
// TODO: separator currently ignored!
Object value = getDependencies().getConverter().convertValue(argument, getParameterContainer(),
propertyType.getAssignmentClass(), propertyType);
setValueInternal(value);
this.valueAlreadySet = true;
} | java |
public static TIntIntHashMap makeVMIndex(Collection<Instance> instances) {
TIntIntHashMap index = new TIntIntHashMap();
int p = 0;
for (Instance i : instances) {
Mapping m = i.getModel().getMapping();
for (Node n : m.getOnlineNodes()) {
for (VM v : m.getRunningVMs(n)) {
index.put(v.id(), p);
}
for (VM v : m.getSleepingVMs(n)) {
index.put(v.id(), p);
}
}
for (VM v : m.getReadyVMs()) {
index.put(v.id(), p);
}
p++;
}
return index;
} | java |
public static TIntIntHashMap makeNodeIndex(Collection<Instance> instances) {
TIntIntHashMap index = new TIntIntHashMap();
int p = 0;
for (Instance i : instances) {
Mapping m = i.getModel().getMapping();
for (Node n : m.getOfflineNodes()) {
index.put(n.id(), p);
}
for (Node n : m.getOnlineNodes()) {
index.put(n.id(), p);
}
p++;
}
return index;
} | java |
public void initialize(AbstractDetectorStreamProvider provider, DetectorStreamProcessor lastProcessor) {
List<DetectorStreamProcessorFactory> factoryList = provider.getProcessorFactoryList();
int factoryCount = factoryList.size();
DetectorStreamBufferImpl buffer = new DetectorStreamBufferImpl(lastProcessor, null, this.byteArrayPool);
for (int factoryIndex = factoryCount - 1; factoryIndex >= 0; factoryIndex--) {
DetectorStreamProcessorFactory factory = factoryList.get(factoryIndex);
DetectorStreamProcessor processor = factory.createProcessor();
buffer = new DetectorStreamBufferImpl(processor, buffer, this.byteArrayPool);
}
this.firstBuffer = buffer;
} | java |
@Override
protected String doInBackground(String... params) {
// get the string from params, which is an array
String user = params[0];
String password = params[1];
String bugTitle = params[2];
String bugDescription = params[3];
String deviceInfo = params[4];
String targetUser = params[5];
String targetRepository = params[6];
String extraInfo = params[7];
String gitToken = params[8];
IssueService service;
if (user.equals("")) {
service = new IssueService(new GitHubClient().setOAuth2Token(gitToken));
} else {
service = new IssueService(new GitHubClient().setCredentials(user, password));
}
Issue issue = new Issue().setTitle(bugTitle).setBody(bugDescription + "\n\n" + deviceInfo + "\n\nExtra Info: " + extraInfo);
try {
issue = service.createIssue(targetUser, targetRepository, issue);
return "ok";
} catch (IOException e) {
e.printStackTrace();
return e.toString();
}
} | java |
@Override
protected void onPostExecute(String result) {
super.onPostExecute(result);
if (result.equals("ok")) {
progress.dismiss();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
mActivity.showDoneAnimation();
} else {
((Activity) mContext).finish();
}
} else if (result.equals("org.eclipse.egit.github.core.client.RequestException: Bad credentials (401)")){
progress.dismiss();
new AlertDialog.Builder(mContext)
.setTitle("Unable to send report")
.setMessage("Wrong username or password or invalid access token.")
.setPositiveButton("Try again", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
// do nothing
}
})
.setIcon(R.drawable.gittyreporter_ic_mood_bad_black_24dp)
.show();
} else {
progress.dismiss();
new AlertDialog.Builder(mContext)
.setTitle("Unable to send report")
.setMessage("An unexpected error occurred. If the problem persists, contact the app developer.")
.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
((Activity)mContext).finish();
}
})
.setIcon(R.drawable.gittyreporter_ic_mood_bad_black_24dp)
.show();
}
} | java |
public static void main(String[] args) throws Exception {
getparseArticle();
geoparseUppercaseArticle();
resolveStanfordEntities();
// And we're done...
System.out.println("\n\"That's all folks!\"");
} | java |
private static void getparseArticle() throws Exception {
// Instantiate a CLAVIN GeoParser using the StanfordExtractor
GeoParser parser = GeoParserFactory.getDefault("./IndexDirectory", new StanfordExtractor(), 1, 1, false);
// Unstructured text file about Somalia to be geoparsed
File inputFile = new File("src/test/resources/sample-docs/Somalia-doc.txt");
// Grab the contents of the text file as a String
String inputString = TextUtils.fileToString(inputFile);
// Parse location names in the text into geographic entities
List<ResolvedLocation> resolvedLocations = parser.parse(inputString);
// Display the ResolvedLocations found for the location names
for (ResolvedLocation resolvedLocation : resolvedLocations)
System.out.println(resolvedLocation);
} | java |
private static void resolveStanfordEntities() throws IOException, ClavinException {
/*#####################################################################
*
* Start with Stanford NER -- no need to get CLAVIN involved for now.
*
*###################################################################*/
// instantiate Stanford NER entity extractor
InputStream mpis = WorkflowDemoNERD.class.getClassLoader().getResourceAsStream("models/english.all.3class.distsim.prop");
Properties mp = new Properties();
mp.load(mpis);
AbstractSequenceClassifier<CoreMap> namedEntityRecognizer =
CRFClassifier.getJarClassifier("/models/english.all.3class.distsim.crf.ser.gz", mp);
// Unstructured text file about Somalia to be geoparsed
File inputFile = new File("src/test/resources/sample-docs/Somalia-doc.txt");
// Grab the contents of the text file as a String
String inputString = TextUtils.fileToString(inputFile);
// extract entities from input text using Stanford NER
List<Triple<String, Integer, Integer>> entitiesFromNER = namedEntityRecognizer.classifyToCharacterOffsets(inputString);
/*#####################################################################
*
* Now, CLAVIN comes into play...
*
*###################################################################*/
// convert Stanford NER output to ClavinLocationResolver input
List<LocationOccurrence> locationsForCLAVIN = convertNERtoCLAVIN(entitiesFromNER, inputString);
// instantiate the CLAVIN location resolver
ClavinLocationResolver clavinLocationResolver = new ClavinLocationResolver(new LuceneGazetteer(new File("./IndexDirectory")));
// resolve location entities extracted from input text
List<ResolvedLocation> resolvedLocations = clavinLocationResolver.resolveLocations(locationsForCLAVIN, 1, 1, false);
// Display the ResolvedLocations found for the location names
for (ResolvedLocation resolvedLocation : resolvedLocations)
System.out.println(resolvedLocation);
} | java |
public Set<String> getDependentFeatures() throws IOException {
final boolean entryExitLogging = log.isLoggable(Level.FINER);
final String methodName = "getDependentFeatures"; //$NON-NLS-1$
if (entryExitLogging) {
log.entering(DependencyList.class.getName(), methodName);
}
if (!initialized) {
initialize();
}
if (entryExitLogging) {
log.exiting(DependencyList.class.getName(), methodName, dependentFeatures);
}
return dependentFeatures;
} | java |
public void setLabel(String label) {
final boolean entryExitLogging = log.isLoggable(Level.FINER);
final String methodName = "setLabel"; //$NON-NLS-1$
if (entryExitLogging) {
log.entering(DependencyList.class.getName(), methodName, new Object[]{label});
}
this.label = label;
if (entryExitLogging) {
log.exiting(DependencyList.class.getName(), methodName);
}
} | java |
synchronized void initialize() throws IOException {
if (initialized) {
return;
}
final boolean traceLogging = log.isLoggable(Level.FINEST);
final boolean entryExitLogging = log.isLoggable(Level.FINER);
final String methodName = "initialize"; //$NON-NLS-1$
if (entryExitLogging) {
log.entering(DependencyList.class.getName(), methodName);
}
// A call to getDeclaredDependencies is made to ensure that the time stamp calculated to mark the beginning of finding the expanded
//dependencies is done only after forming the dependency map is completed.
aggr.getDependencies().getDelcaredDependencies("require"); //$NON-NLS-1$
long stamp = aggr.getDependencies().getLastModified(); // save time stamp
try {
explicitDeps = new ModuleDeps();
expandedDeps = new ModuleDeps();
if (traceLogging) {
log.finest("dependent features = " + dependentFeatures); //$NON-NLS-1$
}
for (String name : names) {
processDep(name, explicitDeps, null, new HashSet<String>(), null);
}
// Now expand the explicit dependencies
resolveAliases = true;
for (Map.Entry<String, ModuleDepInfo> entry : explicitDeps.entrySet()) {
expandDependencies(entry.getKey(), entry.getValue(), expandedDeps);
}
expandedDeps.keySet().removeAll(IDependencies.excludes);
// Resolve feature conditionals based on the specified feature set. This is
// necessary because we don't specify features when doing has! plugin branching
// so that dependent features that are discovered by has! plugin branching don't
// vary based on the specified features.
explicitDeps.resolveWith(features, coerceUndefinedToFalse);
expandedDeps.resolveWith(features, coerceUndefinedToFalse);
if (traceLogging) {
log.finest("explicitDeps after applying features: " + explicitDeps); //$NON-NLS-1$
log.finest("expandedDeps after applying features: " + expandedDeps); //$NON-NLS-1$
}
if (stamp != aggr.getDependencies().getLastModified()) {
// if time stamp has changed, that means that dependencies have been
// updated while we were processing them. Throw an exception to avoid
// caching the response with possibly corrupt dependency info.
throw new IllegalStateException("" + stamp + "!=" + aggr.getDependencies().getLastModified()); //$NON-NLS-1$ //$NON-NLS-2$
}
} finally {
initialized = true;
}
if (entryExitLogging) {
log.exiting(DependencyList.class.getName(), methodName);
}
} | java |
void expandDependencies(String name, ModuleDepInfo depInfo, ModuleDeps expandedDependencies) throws IOException {
final String methodName = "expandDependencies"; //$NON-NLS-1$
final boolean traceLogging = log.isLoggable(Level.FINEST);
final boolean entryExitLogging = log.isLoggable(Level.FINER);
if (entryExitLogging) {
log.entering(DependencyList.class.getName(), methodName, new Object[]{name, depInfo, expandedDependencies});
}
List<String> dependencies = new ArrayList<String>();
List<String> declaredDeps = aggr.getDependencies().getDelcaredDependencies(name);
if (traceLogging) {
log.finest("declaredDeps for " + name + " = " + declaredDeps); //$NON-NLS-1$ //$NON-NLS-2$
}
if (declaredDeps != null) {
dependencies.addAll(declaredDeps);
}
if (includeRequireDeps) {
List<String> requireDeps = aggr.getDependencies().getRequireDependencies(name);
if (requireDeps != null && requireDeps.size() > 0) {
if (traceLogging) {
log.finest("requireDeps for " + name + " = " + requireDeps); //$NON-NLS-1$ //$NON-NLS-2$
}
dependencies.addAll(requireDeps);
}
}
if (dependencies != null) {
for (String dep : dependencies) {
ModuleDeps moduleDeps = new ModuleDeps();
processDep(dep, moduleDeps, depInfo, new HashSet<String>(), name);
for (Map.Entry<String, ModuleDepInfo> entry : moduleDeps.entrySet()) {
if (traceLogging) {
log.finest("Adding " + entry + " to expandedDependencies"); //$NON-NLS-1$ //$NON-NLS-2$
}
if (expandedDependencies.add(entry.getKey(), new ModuleDepInfo(entry.getValue()))) {
expandDependencies(entry.getKey(), entry.getValue(), expandedDependencies);
}
}
}
}
if (entryExitLogging) {
log.exiting(DependencyList.class.getName(), methodName);
}
} | java |
private Model makeModel() {
Model mo = new DefaultModel();
Mapping mapping = mo.getMapping();
int nbNodes = 300;
int nbVMs = 6 * nbNodes;
//Memory usage/consumption in GB
ShareableResource rcMem = new ShareableResource("mem");
//A resource representing the bandwidth usage/consumption of the elements in GB
ShareableResource rcBW = new ShareableResource("bandwidth");
nodes = new ArrayList<>(nbNodes);
for (int i = 0; i < nbNodes; i++) {
Node n = mo.newNode();
nodes.add(n);
mapping.addOnlineNode(n);
//Each node provides a 10GB bandwidth and 32 GB RAM to its VMs
rcBW.setCapacity(n, 10);
rcMem.setCapacity(n, 32);
}
for (int i = 0; i < nbVMs; i++) {
VM vm = mo.newVM();
//Basic balancing through a round-robin: 6 VMs per node
mapping.addRunningVM(vm, nodes.get(i % nodes.size()));
//Each VM uses currently a 1GB bandwidth and 1,2 or 3 GB RAM
rcBW.setConsumption(vm, 1);
rcMem.setConsumption(vm, i % 5 + 1);
}
mo.attach(rcBW);
mo.attach(rcMem);
return mo;
} | java |
@Override
public boolean applyAction(Model c) {
if (c.getMapping().isOffline(node)) {
c.getMapping().addOnlineNode(node);
return true;
}
return false;
} | java |
@Override
public boolean applyAction(Model m) {
Mapping map = m.getMapping();
if (map.isOnline(node) &&
map.isRunning(vm) &&
map.getVMLocation(vm).equals(node)) {
map.addReadyVM(vm);
return true;
}
return false;
} | java |
static String formatMessage(String fmt, Object[] args) {
MessageFormat formatter = new MessageFormat(fmt);
Format[] formats = formatter.getFormatsByArgumentIndex();
StringBuffer msg = new StringBuffer();
formatter.format(args, msg, null);
if (args.length > formats.length) {
// We have extra arguements that were not included in the format string.
// Append them to the result
for (int i = formats.length; i < args.length; i++) {
msg.append(i == formats.length ? ": " : ", ") //$NON-NLS-1$ //$NON-NLS-2$
.append(args[i].toString());
}
}
return msg.toString();
} | java |
static void logResuming(String callerClass, String callerMethod, Object waitObj, long start) {
long elapsed = (System.currentTimeMillis() - start)/1000;
log.logp(Level.WARNING, callerClass, callerMethod,
Messages.SignalUtil_2, new Object[]{Thread.currentThread().getId(), elapsed, waitObj});
} | java |
protected boolean writeResponse(InputStream in, HttpServletRequest request, HttpServletResponse response) throws IOException {
final String sourceMethod = "writeResponse"; //$NON-NLS-1$
final boolean isTraceLogging = log.isLoggable(Level.FINER);
if (isTraceLogging) {
log.entering(AbstractAggregatorImpl.class.getName(), sourceMethod, new Object[]{in, response});
}
boolean success = true;
int n = 0;
byte[] buffer = new byte[4096];
OutputStream out = response.getOutputStream();
try {
while (-1 != (n = in.read(buffer))) {
try {
out.write(buffer, 0, n);
} catch (IOException e) {
// Error writing to the output stream, probably because the connection
// was closed by the client. Don't attempt to write anything else to
// the response and just log the error using FINE level logging.
logException(request, Level.FINE, sourceMethod, e);
success = false;
break;
}
}
} finally {
IOUtils.closeQuietly(in);
IOUtils.closeQuietly(out);
}
if (isTraceLogging) {
log.exiting(AbstractAggregatorImpl.class.getName(), sourceMethod, success);
}
return success;
} | java |
void logException(HttpServletRequest req, Level level, String sourceMethod, Throwable t) {
if (log.isLoggable(level)) {
StringBuffer sb = new StringBuffer();
// add the request URI and query args
String uri = req.getRequestURI();
if (uri != null) {
sb.append(uri);
String queryArgs = req.getQueryString();
if (queryArgs != null) {
sb.append("?").append(queryArgs); //$NON-NLS-1$
}
}
// append the exception class name
sb.append(": ").append(t.getClass().getName()); //$NON-NLS-1$
// append the exception message
sb.append(" - ").append(t.getMessage() != null ? t.getMessage() : "null"); //$NON-NLS-1$//$NON-NLS-2$
log.logp(level, AbstractAggregatorImpl.class.getName(), sourceMethod, sb.toString(), t);
}
} | java |
public String getPropValue (String propName){
String propValue = null;
propValue = System.getProperty(propName);
IServiceReference[] refs = null;
if (propValue == null) {
try {
refs = getPlatformServices().getServiceReferences(IVariableResolver.class.getName(), "(name=" + getName() + ")"); //$NON-NLS-1$ //$NON-NLS-2$
} catch (PlatformServicesException e) {
if (log.isLoggable(Level.SEVERE)) {
log.log(Level.SEVERE, e.getMessage(), e);
}
}
if (refs != null) {
for (IServiceReference sr : refs) {
IVariableResolver resolver = (IVariableResolver)getPlatformServices().getService(sr);
try {
propValue = resolver.resolve(propName);
if (propValue != null) {
break;
}
} finally {
getPlatformServices().ungetService(sr);
}
}
}
}
return propValue;
} | java |
protected void notifyRequestListeners(RequestNotifierAction action, HttpServletRequest req, HttpServletResponse resp) throws IOException {
// notify any listeners that the config has been updated
IServiceReference[] refs = null;
try {
refs = getPlatformServices().getServiceReferences(IRequestListener.class.getName(), "(name="+getName()+")"); //$NON-NLS-1$ //$NON-NLS-2$
} catch (PlatformServicesException e) {
if (log.isLoggable(Level.SEVERE)) {
log.log(Level.SEVERE, e.getMessage(), e);
}
}
if (refs != null) {
for (IServiceReference ref : refs) {
IRequestListener listener = (IRequestListener)getPlatformServices().getService(ref);
try {
if (action == RequestNotifierAction.start) {
listener.startRequest(req, resp);
} else {
listener.endRequest(req, resp);
}
} finally {
getPlatformServices().ungetService(ref);
}
}
}
} | java |
protected void notifyConfigListeners(long seq) throws IOException {
IServiceReference[] refs = null;
try {
refs = getPlatformServices().getServiceReferences(IConfigListener.class.getName(), "(name="+getName()+")"); //$NON-NLS-1$ //$NON-NLS-2$
} catch (PlatformServicesException e) {
if (log.isLoggable(Level.SEVERE)) {
log.log(Level.SEVERE, e.getMessage(), e);
}
}
if (refs != null) {
for (IServiceReference ref : refs) {
IConfigListener listener =
(IConfigListener)getPlatformServices().getService(ref);
if (listener != null) {
try {
listener.configLoaded(config, seq);
} catch (Throwable t) {
if (log.isLoggable(Level.SEVERE)) {
log.log(Level.SEVERE, t.getMessage(), t);
}
throw new IOException(t);
} finally {
getPlatformServices().ungetService(ref);
}
}
}
}
} | java |
protected void registerExtension(IAggregatorExtension ext, IAggregatorExtension before) {
final String sourceMethod = "registerExtension"; //$NON-NLS-1$
boolean isTraceLogging = log.isLoggable(Level.FINER);
if (isTraceLogging) {
log.entering(AbstractAggregatorImpl.class.getName(), sourceMethod, new Object[]{ext, before});
}
// validate type
String id = ext.getExtensionPointId();
if (IHttpTransportExtensionPoint.ID.equals(id)) {
if (before != null) {
throw new IllegalArgumentException(before.getExtensionPointId());
}
httpTransportExtension = ext;
} else {
List<IAggregatorExtension> list;
if (IResourceFactoryExtensionPoint.ID.equals(id)) {
list = resourceFactoryExtensions;
} else if (IResourceConverterExtensionPoint.ID.equals(id)) {
list = resourceConverterExtensions;
} else if (IModuleBuilderExtensionPoint.ID.equals(id)) {
list = moduleBuilderExtensions;
} else if (IServiceProviderExtensionPoint.ID.equals(id)) {
list = serviceProviderExtensions;
} else {
throw new IllegalArgumentException(id);
}
if (before == null) {
list.add(ext);
} else {
// find the extension to insert the item in front of
boolean inserted = false;
for (int i = 0; i < list.size(); i++) {
if (list.get(i) == before) {
list.add(i, ext);
inserted = true;
break;
}
}
if (!inserted) {
throw new IllegalArgumentException();
}
}
// If this is a service provider extension then register the specified service with the
// OSGi service registry if an interface name is provided.
if (IServiceProviderExtensionPoint.ID.equals(id)) {
String interfaceName = ext.getAttribute(IServiceProviderExtensionPoint.SERVICE_ATTRIBUTE);
if (interfaceName != null) {
try {
Dictionary<String, String> props = new Hashtable<String, String>();
// Copy init-params from extension to service dictionary
Set<String> attributeNames = new HashSet<String>(ext.getAttributeNames());
attributeNames.removeAll(Arrays.asList(new String[]{"class", IServiceProviderExtensionPoint.SERVICE_ATTRIBUTE})); //$NON-NLS-1$
for (String propName : attributeNames) {
props.put(propName, ext.getAttribute(propName));
}
// Set name property to aggregator name
props.put("name", getName()); //$NON-NLS-1$
registrations.add(getPlatformServices().registerService(interfaceName, ext.getInstance(), props));
} catch (Exception e) {
if (log.isLoggable(Level.WARNING)) {
log.log(Level.WARNING, e.getMessage(), e);
}
}
}
}
}
if (isTraceLogging) {
log.exiting(AbstractAggregatorImpl.class.getName(), sourceMethod);
}
} | java |
public void initialize(IConfig config)
throws Exception {
// Check last-modified times of resources in the overrides folders. These resources
// are considered to be dynamic in a production environment and we want to
// detect new/changed resources in these folders on startup so that we can clear
// caches, etc.
OverrideFoldersTreeWalker walker = new OverrideFoldersTreeWalker(this, config);
walker.walkTree();
cacheMgr = newCacheManager(walker.getLastModified());
deps = newDependencies(walker.getLastModifiedJS());
resourcePaths = getPathsAndAliases(getInitParams());
// Notify listeners
this.config = config;
notifyConfigListeners(1);
} | java |
protected Map<String, URI> getPathsAndAliases(InitParams initParams) {
final String sourceMethod = "getPahtsAndAliases"; //$NON-NLS-1$
boolean isTraceLogging = log.isLoggable(Level.FINER);
if (isTraceLogging) {
log.entering(AbstractAggregatorImpl.class.getName(), sourceMethod, new Object[]{initParams});
}
Map<String, URI> resourcePaths = new HashMap<String, URI>();
List<String> aliases = initParams.getValues(InitParams.ALIAS_INITPARAM);
for (String alias : aliases) {
addAlias(alias, null, "alias", resourcePaths); //$NON-NLS-1$
}
List<String> resourceIds = initParams.getValues(InitParams.RESOURCEID_INITPARAM);
for (String resourceId : resourceIds) {
aliases = initParams.getValues(resourceId + ":alias"); //$NON-NLS-1$
List<String> baseNames = initParams.getValues(resourceId + ":base-name"); //$NON-NLS-1$
if (aliases == null || aliases.size() != 1) {
throw new IllegalArgumentException(resourceId + ":aliases"); //$NON-NLS-1$
}
if (baseNames == null || baseNames.size() != 1) {
throw new IllegalArgumentException(resourceId + ":base-name"); //$NON-NLS-1$
}
String alias = aliases.get(0);
String baseName = baseNames.get(0);
// make sure not root path
boolean isPathComp = false;
for (String part : alias.split("/")) { //$NON-NLS-1$
if (part.length() > 0) {
isPathComp = true;
break;
}
}
// Make sure basename doesn't start with '/'
if (baseName.startsWith("/")) { //$NON-NLS-1$
throw new IllegalArgumentException("Root relative base-name not allowed: " + baseName); //$NON-NLS-1$
}
if (!isPathComp) {
throw new IllegalArgumentException(resourceId + ":alias = " + alias); //$NON-NLS-1$
}
addAlias(alias, URI.create(baseName), resourceId + ":alias", resourcePaths); //$NON-NLS-1$
}
if (isTraceLogging) {
log.exiting(AbstractAggregatorImpl.class.getName(), sourceMethod, resourcePaths);
}
return Collections.unmodifiableMap(resourcePaths);
} | java |
@SuppressWarnings({ "unchecked", "rawtypes" })
protected void registerLayerListener() {
Dictionary dict = new Properties();
dict.put("name", getName()); //$NON-NLS-1$
registrations.add(getPlatformServices().registerService(
ILayerListener.class.getName(), new AggregatorLayerListener(this), dict));
} | java |
public BooleanTerm andWith(BooleanTerm other) {
if (isFalse() || other.isFalse()) {
// anding with false, the result is false
return BooleanTerm.FALSE;
}
if (other.isTrue()) {
// anding with true, the result is unchanged
return this;
}
if (isTrue()) {
// anding with true, other is unchanged
return other;
}
Set<BooleanVar> result = new HashSet<BooleanVar>(this);
for (BooleanVar var : other) {
if (result.contains(var.negate())) {
// If the same term has the same var with opposite states
// then the resulting term is false;
return BooleanTerm.FALSE;
}
result.add(var);
}
return new BooleanTerm(result);
} | java |
static public byte[] zip(InputStream in) throws IOException {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
VariableGZIPOutputStream compress = new VariableGZIPOutputStream(bos, 10240); // is 10k too big?
compress.setLevel(Deflater.BEST_COMPRESSION);
Writer writer = new OutputStreamWriter(compress, "UTF-8"); //$NON-NLS-1$
// Copy the data from the input stream to the output, compressing as we go.
CopyUtil.copy(in, writer);
return bos.toByteArray();
} | java |
static public byte[] unzip(InputStream in) throws IOException {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
CopyUtil.copy(new GZIPInputStream(in), bos);
return bos.toByteArray();
} | java |
public static String bind(String message, Object binding) {
return internalBind(message, null, String.valueOf(binding), null);
} | java |
public static void initializeMessages(final String bundleName, final Class clazz) {
if (System.getSecurityManager() == null) {
load(bundleName, clazz);
return;
}
AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
load(bundleName, clazz);
return null;
}
});
} | java |
private Number parseNumber(String numberValue, Object valueSource) throws WrongValueTypeException {
try {
Double d = Double.valueOf(numberValue);
return this.mathUtil.toSimplestNumber(d);
} catch (NumberFormatException e) {
throw new WrongValueTypeException(e, numberValue, valueSource, Number.class);
}
} | java |
public List<LocationOccurrence> extractLocationNames(String text) {
if (text == null)
throw new IllegalArgumentException("text input to extractLocationNames should not be null");
// extract entities as <Entity Type, Start Index, Stop Index>
return convertNERtoCLAVIN(namedEntityRecognizer.classifyToCharacterOffsets(text), text);
} | java |
public static List<LocationOccurrence> convertNERtoCLAVIN
(List<Triple<String, Integer, Integer>> entities, String text) {
List<LocationOccurrence> locations = new ArrayList<LocationOccurrence>();
if (entities != null) {
// iterate over each entity Triple
for (Triple<String, Integer, Integer> entity : entities) {
// check if the entity is a "Location"
if (entity.first.equalsIgnoreCase("LOCATION")) {
// build a LocationOccurrence object
locations.add(new LocationOccurrence(text.substring(entity.second, entity.third), entity.second));
}
}
}
return locations;
} | java |
protected String getFunctionDescription(String functionName) {
String className = getClass().getSimpleName();
StringBuilder buffer = new StringBuilder(functionName.length() + className.length() + 4);
buffer.append(FUNCTION_NAME_PREFIX);
buffer.append(functionName);
buffer.append(" [");
buffer.append(className);
buffer.append("]");
return buffer.toString();
} | java |
public BooleanFormula andWith(BooleanFormula other) {
if (other.isTrue()) {
return this;
}
if (other.isFalse() || isFalse()) {
if (booleanTerms == null) {
booleanTerms = new HashSet<BooleanTerm>();
} else {
booleanTerms.clear();
}
isSimplified = true;
return this;
}
if (isTrue()) {
booleanTerms = new HashSet<BooleanTerm>(other.booleanTerms);
return this;
}
BooleanFormula newTerms = new BooleanFormula();
for (BooleanTerm otherTerm : other) {
for (BooleanTerm term : booleanTerms) {
BooleanTerm newTerm = term.andWith(otherTerm);
if (newTerm != null) {
newTerms.add(newTerm);
}
}
}
booleanTerms = newTerms.booleanTerms;
isSimplified = newTerms.isSimplified;
return this;
} | java |
public boolean removeTerms(Set<BooleanTerm> toRemove) {
boolean modified = false;
if (toRemove == null || toRemove.iterator() == null) {
modified = booleanTerms == null || size() != 0;
booleanTerms = new HashSet<BooleanTerm>();
} else if (booleanTerms != null) {
modified = removeAll(toRemove);
}
return modified;
} | java |
@Override
public boolean addAll(Collection<? extends BooleanTerm> terms) {
boolean modified = false;
// a null booleanTerms means that the expression is
// already true, so no need to modify it
if (terms == null) {
modified = booleanTerms != null;
booleanTerms = null;
} else if (booleanTerms != null) {
for (BooleanTerm term : terms) {
modified |= add(term);
}
}
return modified;
} | java |
public static TaskMonitor build(IntVar start, IntVar duration, IntVar end) {
return new TaskMonitor(start, duration, end);
} | java |
@Override
public boolean containsNode(long id) {
return nodeIdMapping.containsKey(id) && !isRemoved(nodes.get(nodeIdMapping.get(id)));
} | java |
@Override
public boolean applyAction(Model m) {
Mapping map = m.getMapping();
if (!map.contains(id)) {
map.addReadyVM(id);
return true;
}
return false;
} | java |
public void visitResourceNames(String packageName, boolean includeSubPackages, ClassLoader classLoader, ResourceVisitor visitor) {
try {
String path = packageName.replace('.', '/');
if (path.isEmpty()) {
LOG.debug("Scanning entire classpath...");
} else {
LOG.trace("Scanning for resources on classpath for {}", path);
}
StringBuilder qualifiedNameBuilder = new StringBuilder(path);
if (qualifiedNameBuilder.length() > 0) {
qualifiedNameBuilder.append('/');
}
String pathWithPrefix = qualifiedNameBuilder.toString();
int qualifiedNamePrefixLength = qualifiedNameBuilder.length();
Enumeration<URL> urls = classLoader.getResources(path);
Set<String> urlSet = new HashSet<>();
while (urls.hasMoreElements()) {
URL url = urls.nextElement();
visitResourceUrl(includeSubPackages, visitor, pathWithPrefix, qualifiedNameBuilder, qualifiedNamePrefixLength, url, urlSet);
}
if (path.isEmpty()) {
visitResourceClassloader(includeSubPackages, classLoader, visitor, pathWithPrefix, qualifiedNameBuilder, qualifiedNamePrefixLength, urlSet);
visitResourceClasspath(includeSubPackages, visitor, qualifiedNameBuilder, pathWithPrefix, qualifiedNamePrefixLength, urlSet);
}
} catch (IOException e) {
throw new IllegalStateException("Error reading resources.", e);
}
} | java |
public boolean setPartitions(Collection<Collection<Node>> parts) {
if (!isDisjoint(parts)) {
return false;
}
partitions = parts;
return true;
} | java |
public int run(String... args) {
CliParser parser = getParserBuilder().build(this);
try {
CliModeObject mode = parser.parseParameters(args);
if (this.help) {
assert (mode.getId().equals(CliMode.ID_HELP));
printHelp(parser);
return 0;
}
validate(mode);
return run(mode);
} catch (Exception e) {
return handleError(e, parser);
} finally {
getStandardOutput().flush();
getStandardError().flush();
}
} | java |
public static <T> List<T> sortedCollection(Collection<T> coll) {
List<T> list = new LinkedList<T>(coll);
Collections.sort(list, new UComp<T>());
return list;
} | java |
public static <T> String stringImg(Collection<T> coll) {
StringBuffer buffer = new StringBuffer();
buffer.append("[ ");
for(T t : sortedCollection(coll)) {
buffer.append(t);
buffer.append(" ");
}
buffer.append("]");
return buffer.toString();
} | java |
public static <T> String stringImg(T[] v) {
if(v == null) return "null";
StringBuffer buffer = new StringBuffer();
Arrays.sort(v, new UComp<T>());
for(int i=0; i<v.length; i++) {
buffer.append(v[i]);
buffer.append("\n");
}
return buffer.toString();
} | java |
@Override
public List<Sync> buildConstraint(BtrPlaceTree t, List<BtrpOperand> args) {
if (!checkConformance(t, args)) {
return Collections.emptyList();
}
@SuppressWarnings("unchecked")
List<VM> s = (List<VM>) params[0].transform(this, t, args.get(0));
if (s == null) {
return Collections.emptyList();
}
if (s.size() < 2) {
t.ignoreError("Parameter '" + params[0].getName() + "' expects a list of at least 2 VMs");
return Collections.emptyList();
}
return Collections.singletonList(new Sync(s));
} | java |
public static int getPrecisionFormat(@Nonnull final String mapcode) throws UnknownPrecisionFormatException {
// First, decode to ASCII.
final String decodedMapcode = convertStringToPlainAscii(mapcode).toUpperCase();
// Syntax needs to be OK.
if (!PATTERN_MAPCODE.matcher(decodedMapcode).matches()) {
throw new UnknownPrecisionFormatException(decodedMapcode + " is not a correctly formatted mapcode code; " +
"the regular expression for the mapcode code syntax is: " + REGEX_MAPCODE);
}
// Precision part should be OK.
final Matcher matcherPrecision = PATTERN_PRECISION.matcher(decodedMapcode);
if (!matcherPrecision.find()) {
return 0;
}
final int length = matcherPrecision.end() - matcherPrecision.start() - 1;
assert (1 <= length) && (length <= 8);
return length;
} | java |
public static boolean isValidMapcodeFormat(@Nonnull final String mapcode) throws IllegalArgumentException {
checkNonnull("mapcode", mapcode);
try {
// Throws an exception if the format is incorrect.
getPrecisionFormat(mapcode.toUpperCase());
return true;
} catch (final UnknownPrecisionFormatException ignored) {
return false;
}
} | java |
public static boolean containsTerritory(@Nonnull final String mapcode) throws IllegalArgumentException {
checkMapcodeCode("mapcode", mapcode);
return PATTERN_TERRITORY.matcher(mapcode.toUpperCase().trim()).find();
} | java |
@Nonnull
static String convertStringToPlainAscii(@Nonnull final String string) {
return Decoder.decodeUTF16(string.toUpperCase());
} | java |
public static RePairGrammar buildGrammar(SAXRecords saxRecords) {
RePairGrammar grammar = NewRepair.parse(saxRecords.getSAXString(SPACE));
return grammar;
} | java |
public static RePairGrammar buildGrammar(String inputString) {
RePairGrammar grammar = NewRepair.parse(inputString);
return grammar;
} | java |
public String getValue(String name) {
String result = null;
for (InitParam initParam : initParams) {
if (initParam.getName().equals(name)) {
result = initParam.getValue();
break;
}
}
return result;
} | java |
public Collection<String> getNames() {
Collection<String> names = new HashSet<String>();
for (InitParam initParam : initParams) {
names.add(initParam.getName());
}
return names;
} | java |
public void setRefreshDelayInSeconds(int refreshDelayInSeconds) {
ValueOutOfRangeException.checkRange(Integer.valueOf(refreshDelayInSeconds), MIN_DELAY, Integer.valueOf(Integer.MAX_VALUE),
getClass().getSimpleName() + ".refreshDelayInSeconds");
this.refreshDelayInSeconds = refreshDelayInSeconds;
} | java |
public void register(ModelViewConverter<? extends ModelView> c) {
java2json.put(c.getSupportedView(), c);
json2java.put(c.getJSONId(), c);
} | java |
public ModelView fromJSON(Model mo, JSONObject in) throws JSONConverterException {
checkKeys(in, ModelViewConverter.IDENTIFIER);
Object id = in.get(ModelViewConverter.IDENTIFIER);
ModelViewConverter<? extends ModelView> c = json2java.get(id.toString());
if (c == null) {
throw new JSONConverterException("No converter available for a view having id '" + id + "'");
}
return c.fromJSON(mo, in);
} | java |
public JSONObject toJSON(ModelView o) throws JSONConverterException {
ModelViewConverter c = java2json.get(o.getClass());
if (c == null) {
throw new JSONConverterException("No converter available for a view with the '" + o.getClass() + "' className");
}
return c.toJSON(o);
} | java |
public DistanceElement getElement(long id) {
if (!vector.containsKey(id))
vector.put(id, new DistanceElement(id));
return vector.get(id);
} | java |
public void printPathTo(long targetId) {
System.out.println(getPath(targetId).stream().map(String::valueOf).reduce((s1, s2) -> s1 + " -> " + s2).get());
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.