code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
@Override
public final Boolean optBool(final String key) {
if (this.obj.optString(key, null) == null) {
return null;
} else {
return this.obj.optBoolean(key);
}
} | java |
public final PJsonObject optJSONObject(final String key) {
final JSONObject val = this.obj.optJSONObject(key);
return val != null ? new PJsonObject(this, val, key) : null;
} | java |
public final PJsonArray getJSONArray(final String key) {
final JSONArray val = this.obj.optJSONArray(key);
if (val == null) {
throw new ObjectMissingException(this, key);
}
return new PJsonArray(this, val, key);
} | java |
public final PJsonArray optJSONArray(final String key, final PJsonArray defaultValue) {
PJsonArray result = optJSONArray(key);
return result != null ? result : defaultValue;
} | java |
@Override
public final boolean has(final String key) {
String result = this.obj.optString(key, null);
return result != null;
} | java |
public void setAttributes(final Map<String, Attribute> attributes) {
this.internalAttributes = attributes;
this.allAttributes.putAll(attributes);
} | java |
public void setAttribute(final String name, final Attribute attribute) {
if (name.equals("datasource")) {
this.allAttributes.putAll(((DataSourceAttribute) attribute).getAttributes());
} else if (this.copyAttributes.contains(name)) {
this.allAttributes.put(name, attribute);
}
} | java |
@Nonnull
public String getBody() {
if (body == null) {
return storage == null ? DEFAULT_BODY : DEFAULT_BODY_STORAGE;
} else {
return body;
}
} | java |
private boolean isTileVisible(final ReferencedEnvelope tileBounds) {
if (FloatingPointUtil.equals(this.transformer.getRotation(), 0.0)) {
return true;
}
final GeometryFactory gfac = new GeometryFactory();
final Optional<Geometry> rotatedMapBounds = getRotatedMapBounds(gfac);
if (rotatedMapBounds.isPresent()) {
return rotatedMapBounds.get().intersects(gfac.toGeometry(tileBounds));
} else {
// in case of an error, we simply load the tile
return true;
}
} | java |
private List<Rule> getStyleRules(final String styleProperty) {
final List<Rule> styleRules = new ArrayList<>(this.json.size());
for (Iterator<String> iterator = this.json.keys(); iterator.hasNext(); ) {
String styleKey = iterator.next();
if (styleKey.equals(JSON_STYLE_PROPERTY) ||
styleKey.equals(MapfishStyleParserPlugin.JSON_VERSION)) {
continue;
}
PJsonObject styleJson = this.json.getJSONObject(styleKey);
final List<Rule> currentRules = createStyleRule(styleKey, styleJson, styleProperty);
for (Rule currentRule: currentRules) {
if (currentRule != null) {
styleRules.add(currentRule);
}
}
}
return styleRules;
} | java |
public void setHeaders(final Set<String> names) {
// transform to lower-case because header names should be case-insensitive
Set<String> lowerCaseNames = new HashSet<>();
for (String name: names) {
lowerCaseNames.add(name.toLowerCase());
}
this.headerNames = lowerCaseNames;
} | java |
public static Multimap<String, String> convertToMultiMap(final PObject objectParams) {
Multimap<String, String> params = HashMultimap.create();
if (objectParams != null) {
Iterator<String> customParamsIter = objectParams.keys();
while (customParamsIter.hasNext()) {
String key = customParamsIter.next();
if (objectParams.isArray(key)) {
final PArray array = objectParams.optArray(key);
for (int i = 0; i < array.size(); i++) {
params.put(key, array.getString(i));
}
} else {
params.put(key, objectParams.optString(key, ""));
}
}
}
return params;
} | java |
public Envelope getMaxExtent() {
final int minX = 0;
final int maxX = 1;
final int minY = 2;
final int maxY = 3;
return new Envelope(this.maxExtent[minX], this.maxExtent[minY], this.maxExtent[maxX],
this.maxExtent[maxY]);
} | java |
public final void setConfigurationFiles(final Map<String, String> configurationFiles)
throws URISyntaxException {
this.configurationFiles.clear();
this.configurationFileLastModifiedTimes.clear();
for (Map.Entry<String, String> entry: configurationFiles.entrySet()) {
if (!entry.getValue().contains(":/")) {
// assume is a file
this.configurationFiles.put(entry.getKey(), new File(entry.getValue()).toURI());
} else {
this.configurationFiles.put(entry.getKey(), new URI(entry.getValue()));
}
}
if (this.configFileLoader != null) {
this.validateConfigurationFiles();
}
} | java |
public final ZoomToFeatures copy() {
ZoomToFeatures obj = new ZoomToFeatures();
obj.zoomType = this.zoomType;
obj.minScale = this.minScale;
obj.minMargin = this.minMargin;
return obj;
} | java |
public String getFullContentType() {
final String url = this.url.toExternalForm().substring("data:".length());
final int endIndex = url.indexOf(',');
if (endIndex >= 0) {
final String contentType = url.substring(0, endIndex);
if (!contentType.isEmpty()) {
return contentType;
}
}
return "text/plain;charset=US-ASCII";
} | java |
@Override
public final Optional<Boolean> tryOverrideValidation(final MatchInfo matchInfo) throws SocketException,
UnknownHostException, MalformedURLException {
for (AddressHostMatcher addressHostMatcher: this.matchersForHost) {
if (addressHostMatcher.matches(matchInfo)) {
return Optional.empty();
}
}
return Optional.of(false);
} | java |
public final void setHost(final String host) throws UnknownHostException {
this.host = host;
final InetAddress[] inetAddresses = InetAddress.getAllByName(host);
for (InetAddress address: inetAddresses) {
final AddressHostMatcher matcher = new AddressHostMatcher();
matcher.setIp(address.getHostAddress());
this.matchersForHost.add(matcher);
}
} | java |
@SuppressWarnings("unchecked")
public Multimap<String, Processor> getAllRequiredAttributes() {
Multimap<String, Processor> requiredInputs = HashMultimap.create();
for (ProcessorGraphNode root: this.roots) {
final BiMap<String, String> inputMapper = root.getInputMapper();
for (String attr: inputMapper.keySet()) {
requiredInputs.put(attr, root.getProcessor());
}
final Object inputParameter = root.getProcessor().createInputParameter();
if (inputParameter instanceof Values) {
continue;
} else if (inputParameter != null) {
final Class<?> inputParameterClass = inputParameter.getClass();
final Set<String> requiredAttributesDefinedInInputParameter =
getAttributeNames(inputParameterClass,
FILTER_ONLY_REQUIRED_ATTRIBUTES);
for (String attName: requiredAttributesDefinedInInputParameter) {
try {
if (inputParameterClass.getField(attName).getType() == Values.class) {
continue;
}
} catch (NoSuchFieldException e) {
throw new RuntimeException(e);
}
String mappedName = ProcessorUtils.getInputValueName(
root.getProcessor().getInputPrefix(),
inputMapper, attName);
requiredInputs.put(mappedName, root.getProcessor());
}
}
}
return requiredInputs;
} | java |
public Set<Processor<?, ?>> getAllProcessors() {
IdentityHashMap<Processor<?, ?>, Void> all = new IdentityHashMap<>();
for (ProcessorGraphNode<?, ?> root: this.roots) {
for (Processor p: root.getAllProcessors()) {
all.put(p, null);
}
}
return all.keySet();
} | java |
public void validate(final List<Throwable> validationErrors) {
if (this.matchers == null) {
validationErrors.add(new IllegalArgumentException(
"Matchers cannot be null. There should be at least a !acceptAll matcher"));
}
if (this.matchers != null && this.matchers.isEmpty()) {
validationErrors.add(new IllegalArgumentException(
"There are no url matchers defined. There should be at least a " +
"!acceptAll matcher"));
}
} | java |
@PostConstruct
public final void init() throws URISyntaxException {
final String address = getConfig(ADDRESS, null);
if (address != null) {
final URI uri = new URI("udp://" + address);
final String prefix = getConfig(PREFIX, "mapfish-print").replace("%h", getHostname());
final int period = Integer.parseInt(getConfig(PERIOD, "10"));
LOGGER.info("Starting a StatsD reporter targeting {} with prefix {} and period {}s",
uri, prefix, period);
this.reporter = StatsDReporter.forRegistry(this.metricRegistry)
.prefixedWith(prefix)
.build(uri.getHost(), uri.getPort());
this.reporter.start(period, TimeUnit.SECONDS);
}
} | java |
public static MapBounds adjustBoundsToScaleAndMapSize(
final GenericMapAttributeValues mapValues,
final Rectangle paintArea,
final MapBounds bounds,
final double dpi) {
MapBounds newBounds = bounds;
if (mapValues.isUseNearestScale()) {
newBounds = newBounds.adjustBoundsToNearestScale(
mapValues.getZoomLevels(),
mapValues.getZoomSnapTolerance(),
mapValues.getZoomLevelSnapStrategy(),
mapValues.getZoomSnapGeodetic(),
paintArea, dpi);
}
newBounds = new BBoxMapBounds(newBounds.toReferencedEnvelope(paintArea));
if (mapValues.isUseAdjustBounds()) {
newBounds = newBounds.adjustedEnvelope(paintArea);
}
return newBounds;
} | java |
public static SVGGraphics2D createSvgGraphics(final Dimension size)
throws ParserConfigurationException {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document document = db.getDOMImplementation().createDocument(null, "svg", null);
SVGGeneratorContext ctx = SVGGeneratorContext.createDefault(document);
ctx.setStyleHandler(new OpacityAdjustingStyleHandler());
ctx.setComment("Generated by GeoTools2 with Batik SVG Generator");
SVGGraphics2D g2d = new SVGGraphics2D(ctx, true);
g2d.setSVGCanvasSize(size);
return g2d;
} | java |
public static void saveSvgFile(final SVGGraphics2D graphics2d, final File path) throws IOException {
try (FileOutputStream fs = new FileOutputStream(path);
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fs, StandardCharsets.UTF_8);
Writer osw = new BufferedWriter(outputStreamWriter)
) {
graphics2d.stream(osw, true);
}
} | java |
@Nonnull
private ReferencedEnvelope getFeatureBounds(
final MfClientHttpRequestFactory clientHttpRequestFactory,
final MapAttributeValues mapValues, final ExecutionContext context) {
final MapfishMapContext mapContext = createMapContext(mapValues);
String layerName = mapValues.zoomToFeatures.layer;
ReferencedEnvelope bounds = new ReferencedEnvelope();
for (MapLayer layer: mapValues.getLayers()) {
context.stopIfCanceled();
if ((!StringUtils.isEmpty(layerName) && layerName.equals(layer.getName())) ||
(StringUtils.isEmpty(layerName) && layer instanceof AbstractFeatureSourceLayer)) {
AbstractFeatureSourceLayer featureLayer = (AbstractFeatureSourceLayer) layer;
FeatureSource<?, ?> featureSource =
featureLayer.getFeatureSource(clientHttpRequestFactory, mapContext);
FeatureCollection<?, ?> features;
try {
features = featureSource.getFeatures();
} catch (IOException e) {
throw ExceptionUtils.getRuntimeException(e);
}
if (!features.isEmpty()) {
final ReferencedEnvelope curBounds = features.getBounds();
bounds.expandToInclude(curBounds);
}
}
}
return bounds;
} | java |
public final File getJasperCompilation(final Configuration configuration) {
File jasperCompilation = new File(getWorking(configuration), "jasper-bin");
createIfMissing(jasperCompilation, "Jasper Compilation");
return jasperCompilation;
} | java |
public final File getTaskDirectory() {
createIfMissing(this.working, "Working");
try {
return Files.createTempDirectory(this.working.toPath(), TASK_DIR_PREFIX).toFile();
} catch (IOException e) {
throw new AssertionError("Unable to create temporary directory in '" + this.working + "'");
}
} | java |
public final void removeDirectory(final File directory) {
try {
FileUtils.deleteDirectory(directory);
} catch (IOException e) {
LOGGER.error("Unable to delete directory '{}'", directory);
}
} | java |
public final File getBuildFileFor(
final Configuration configuration, final File jasperFileXml,
final String extension, final Logger logger) {
final String configurationAbsolutePath = configuration.getDirectory().getPath();
final int prefixToConfiguration = configurationAbsolutePath.length() + 1;
final String parentDir = jasperFileXml.getAbsoluteFile().getParent();
final String relativePathToFile;
if (configurationAbsolutePath.equals(parentDir)) {
relativePathToFile = FilenameUtils.getBaseName(jasperFileXml.getName());
} else {
final String relativePathToContainingDirectory = parentDir.substring(prefixToConfiguration);
relativePathToFile = relativePathToContainingDirectory + File.separator +
FilenameUtils.getBaseName(jasperFileXml.getName());
}
final File buildFile = new File(getJasperCompilation(configuration), relativePathToFile + extension);
if (!buildFile.getParentFile().exists() && !buildFile.getParentFile().mkdirs()) {
logger.error("Unable to create directory for containing compiled jasper report templates: {}",
buildFile.getParentFile());
}
return buildFile;
} | java |
public static URI createRestURI(
final String matrixId, final int row, final int col,
final WMTSLayerParam layerParam) throws URISyntaxException {
String path = layerParam.baseURL;
if (layerParam.dimensions != null) {
for (int i = 0; i < layerParam.dimensions.length; i++) {
String dimension = layerParam.dimensions[i];
String value = layerParam.dimensionParams.optString(dimension);
if (value == null) {
value = layerParam.dimensionParams.getString(dimension.toUpperCase());
}
path = path.replace("{" + dimension + "}", value);
}
}
path = path.replace("{TileMatrixSet}", layerParam.matrixSet);
path = path.replace("{TileMatrix}", matrixId);
path = path.replace("{TileRow}", String.valueOf(row));
path = path.replace("{TileCol}", String.valueOf(col));
path = path.replace("{style}", layerParam.style);
path = path.replace("{Layer}", layerParam.layer);
return new URI(path);
} | java |
public final String getPath(final String key) {
StringBuilder result = new StringBuilder();
addPathTo(result);
result.append(".");
result.append(getPathElement(key));
return result.toString();
} | java |
protected final void addPathTo(final StringBuilder result) {
if (this.parent != null) {
this.parent.addPathTo(result);
if (!(this.parent instanceof PJsonArray)) {
result.append(".");
}
}
result.append(getPathElement(this.contextName));
} | java |
public static void main(final String[] args) {
if (System.getProperty("db.name") == null) {
System.out.println("Not running in multi-instance mode: no DB to connect to");
System.exit(1);
}
while (true) {
try {
Class.forName("org.postgresql.Driver");
DriverManager.getConnection("jdbc:postgresql://" + System.getProperty("db.host") + ":5432/" +
System.getProperty("db.name"),
System.getProperty("db.username"),
System.getProperty("db.password"));
System.out.println("Opened database successfully. Running in multi-instance mode");
System.exit(0);
return;
} catch (Exception e) {
System.out.println("Failed to connect to the DB: " + e.toString());
try {
Thread.sleep(1000);
} catch (InterruptedException e1) {
//ignored
}
}
}
} | java |
private void started(final ProcessorGraphNode processorGraphNode) {
this.processorLock.lock();
try {
this.runningProcessors.put(processorGraphNode.getProcessor(), null);
} finally {
this.processorLock.unlock();
}
} | java |
public boolean isRunning(final ProcessorGraphNode processorGraphNode) {
this.processorLock.lock();
try {
return this.runningProcessors.containsKey(processorGraphNode.getProcessor());
} finally {
this.processorLock.unlock();
}
} | java |
public boolean isFinished(final ProcessorGraphNode processorGraphNode) {
this.processorLock.lock();
try {
return this.executedProcessors.containsKey(processorGraphNode.getProcessor());
} finally {
this.processorLock.unlock();
}
} | java |
public void finished(final ProcessorGraphNode processorGraphNode) {
this.processorLock.lock();
try {
this.runningProcessors.remove(processorGraphNode.getProcessor());
this.executedProcessors.put(processorGraphNode.getProcessor(), null);
} finally {
this.processorLock.unlock();
}
} | java |
public final void draw() {
AffineTransform transform = new AffineTransform(this.transform);
transform.concatenate(getAlignmentTransform());
// draw the background box
this.graphics2d.setTransform(transform);
this.graphics2d.setColor(this.params.getBackgroundColor());
this.graphics2d.fillRect(0, 0, this.settings.getSize().width, this.settings.getSize().height);
//draw the labels
this.graphics2d.setColor(this.params.getFontColor());
drawLabels(transform, this.params.getOrientation(), this.params.getLabelRotation());
//sets the transformation for drawing the bar and do it
final AffineTransform lineTransform = new AffineTransform(transform);
setLineTranslate(lineTransform);
if (this.params.getOrientation() == Orientation.VERTICAL_LABELS_LEFT ||
this.params.getOrientation() == Orientation.VERTICAL_LABELS_RIGHT) {
final AffineTransform rotate = AffineTransform.getQuadrantRotateInstance(1);
lineTransform.concatenate(rotate);
}
this.graphics2d.setTransform(lineTransform);
this.graphics2d.setStroke(new BasicStroke(this.settings.getLineWidth()));
this.graphics2d.setColor(this.params.getColor());
drawBar();
} | java |
private AffineTransform getAlignmentTransform() {
final int offsetX;
switch (this.settings.getParams().getAlign()) {
case LEFT:
offsetX = 0;
break;
case RIGHT:
offsetX = this.settings.getMaxSize().width - this.settings.getSize().width;
break;
case CENTER:
default:
offsetX = (int) Math
.floor(this.settings.getMaxSize().width / 2.0 - this.settings.getSize().width / 2.0);
break;
}
final int offsetY;
switch (this.settings.getParams().getVerticalAlign()) {
case TOP:
offsetY = 0;
break;
case BOTTOM:
offsetY = this.settings.getMaxSize().height - this.settings.getSize().height;
break;
case MIDDLE:
default:
offsetY = (int) Math.floor(this.settings.getMaxSize().height / 2.0 -
this.settings.getSize().height / 2.0);
break;
}
return AffineTransform.getTranslateInstance(Math.round(offsetX), Math.round(offsetY));
} | java |
protected final MapfishMapContext getLayerTransformer(final MapfishMapContext transformer) {
MapfishMapContext layerTransformer = transformer;
if (!FloatingPointUtil.equals(transformer.getRotation(), 0.0) && !this.supportsNativeRotation()) {
// if a rotation is set and the rotation can not be handled natively
// by the layer, we have to adjust the bounds and map size
layerTransformer = new MapfishMapContext(
transformer,
transformer.getRotatedBoundsAdjustedForPreciseRotatedMapSize(),
transformer.getRotatedMapSize(),
0,
transformer.getDPI(),
transformer.isForceLongitudeFirst(),
transformer.isDpiSensitiveStyle());
}
return layerTransformer;
} | java |
public static void log(final String templateName, final Template template, final Values values) {
new ValuesLogger().doLog(templateName, template, values);
} | java |
private static String getFileName(@Nullable final MapPrinter mapPrinter, final PJsonObject spec) {
String fileName = spec.optString(Constants.OUTPUT_FILENAME_KEY);
if (fileName != null) {
return fileName;
}
if (mapPrinter != null) {
final Configuration config = mapPrinter.getConfiguration();
final String templateName = spec.getString(Constants.JSON_LAYOUT_KEY);
final Template template = config.getTemplate(templateName);
if (template.getOutputFilename() != null) {
return template.getOutputFilename();
}
if (config.getOutputFilename() != null) {
return config.getOutputFilename();
}
}
return "mapfish-print-report";
} | java |
protected PrintResult withOpenOutputStream(final PrintAction function) throws Exception {
final File reportFile = getReportFile();
final Processor.ExecutionContext executionContext;
try (FileOutputStream out = new FileOutputStream(reportFile);
BufferedOutputStream bout = new BufferedOutputStream(out)) {
executionContext = function.run(bout);
}
return new PrintResult(reportFile.length(), executionContext);
} | java |
static Style get(final GridParam params) {
final StyleBuilder builder = new StyleBuilder();
final Symbolizer pointSymbolizer = crossSymbolizer("shape://plus", builder, CROSS_SIZE,
params.gridColor);
final Style style = builder.createStyle(pointSymbolizer);
final List<Symbolizer> symbolizers = style.featureTypeStyles().get(0).rules().get(0).symbolizers();
if (params.haloRadius > 0.0) {
Symbolizer halo = crossSymbolizer("cross", builder, CROSS_SIZE + params.haloRadius * 2.0,
params.haloColor);
symbolizers.add(0, halo);
}
return style;
} | java |
public Scale get(final int index, final DistanceUnit unit) {
return new Scale(this.scaleDenominators[index], unit, PDF_DPI);
} | java |
public double[] getScaleDenominators() {
double[] dest = new double[this.scaleDenominators.length];
System.arraycopy(this.scaleDenominators, 0, dest, 0, this.scaleDenominators.length);
return dest;
} | java |
public final SimpleFeatureCollection autoTreat(final Template template, final String features)
throws IOException {
SimpleFeatureCollection featuresCollection = treatStringAsURL(template, features);
if (featuresCollection == null) {
featuresCollection = treatStringAsGeoJson(features);
}
return featuresCollection;
} | java |
public final SimpleFeatureCollection treatStringAsURL(final Template template, final String geoJsonUrl)
throws IOException {
URL url;
try {
url = FileUtils.testForLegalFileUrl(template.getConfiguration(), new URL(geoJsonUrl));
} catch (MalformedURLException e) {
return null;
}
final String geojsonString;
if (url.getProtocol().equalsIgnoreCase("file")) {
geojsonString = IOUtils.toString(url, Constants.DEFAULT_CHARSET.name());
} else {
geojsonString = URIUtils.toString(this.httpRequestFactory, url);
}
return treatStringAsGeoJson(geojsonString);
} | java |
@Override
public boolean supportsNativeRotation() {
return this.params.useNativeAngle &&
(this.params.serverType == WmsLayerParam.ServerType.MAPSERVER ||
this.params.serverType == WmsLayerParam.ServerType.GEOSERVER);
} | java |
protected static File platformIndependentUriToFile(final URI fileURI) {
File file;
try {
file = new File(fileURI);
} catch (IllegalArgumentException e) {
if (fileURI.toString().startsWith("file://")) {
file = new File(fileURI.toString().substring("file://".length()));
} else {
throw e;
}
}
return file;
} | java |
public static String getContext(final PObject[] objs) {
StringBuilder result = new StringBuilder("(");
boolean first = true;
for (PObject obj: objs) {
if (!first) {
result.append('|');
}
first = false;
result.append(obj.getCurrentPath());
}
result.append(')');
return result.toString();
} | java |
public final void save(final PrintJobStatusExtImpl entry) {
getSession().merge(entry);
getSession().flush();
getSession().evict(entry);
} | java |
public final Object getValue(final String id, final String property) {
final CriteriaBuilder builder = getSession().getCriteriaBuilder();
final CriteriaQuery<Object> criteria = builder.createQuery(Object.class);
final Root<PrintJobStatusExtImpl> root = criteria.from(PrintJobStatusExtImpl.class);
criteria.select(root.get(property));
criteria.where(builder.equal(root.get("referenceId"), id));
return getSession().createQuery(criteria).uniqueResult();
} | java |
public final void cancelOld(
final long starttimeThreshold, final long checkTimeThreshold, final String message) {
final CriteriaBuilder builder = getSession().getCriteriaBuilder();
final CriteriaUpdate<PrintJobStatusExtImpl> update =
builder.createCriteriaUpdate(PrintJobStatusExtImpl.class);
final Root<PrintJobStatusExtImpl> root = update.from(PrintJobStatusExtImpl.class);
update.where(builder.and(
builder.equal(root.get("status"), PrintJobStatus.Status.WAITING),
builder.or(
builder.lessThan(root.get("entry").get("startTime"), starttimeThreshold),
builder.and(builder.isNotNull(root.get("lastCheckTime")),
builder.lessThan(root.get("lastCheckTime"), checkTimeThreshold))
)
));
update.set(root.get("status"), PrintJobStatus.Status.CANCELLED);
update.set(root.get("error"), message);
getSession().createQuery(update).executeUpdate();
} | java |
public final void updateLastCheckTime(final String id, final long lastCheckTime) {
final CriteriaBuilder builder = getSession().getCriteriaBuilder();
final CriteriaUpdate<PrintJobStatusExtImpl> update =
builder.createCriteriaUpdate(PrintJobStatusExtImpl.class);
final Root<PrintJobStatusExtImpl> root = update.from(PrintJobStatusExtImpl.class);
update.where(builder.equal(root.get("referenceId"), id));
update.set(root.get("lastCheckTime"), lastCheckTime);
getSession().createQuery(update).executeUpdate();
} | java |
public final int deleteOld(final long checkTimeThreshold) {
final CriteriaBuilder builder = getSession().getCriteriaBuilder();
final CriteriaDelete<PrintJobStatusExtImpl> delete =
builder.createCriteriaDelete(PrintJobStatusExtImpl.class);
final Root<PrintJobStatusExtImpl> root = delete.from(PrintJobStatusExtImpl.class);
delete.where(builder.and(builder.isNotNull(root.get("lastCheckTime")),
builder.lessThan(root.get("lastCheckTime"), checkTimeThreshold)));
return getSession().createQuery(delete).executeUpdate();
} | java |
public final List<PrintJobStatusExtImpl> poll(final int size) {
final CriteriaBuilder builder = getSession().getCriteriaBuilder();
final CriteriaQuery<PrintJobStatusExtImpl> criteria =
builder.createQuery(PrintJobStatusExtImpl.class);
final Root<PrintJobStatusExtImpl> root = criteria.from(PrintJobStatusExtImpl.class);
root.alias("pj");
criteria.where(builder.equal(root.get("status"), PrintJobStatus.Status.WAITING));
criteria.orderBy(builder.asc(root.get("entry").get("startTime")));
final Query<PrintJobStatusExtImpl> query = getSession().createQuery(criteria);
query.setMaxResults(size);
// LOCK but don't wait for release (since this is run continuously
// anyway, no wait prevents deadlock)
query.setLockMode("pj", LockMode.UPGRADE_NOWAIT);
try {
return query.getResultList();
} catch (PessimisticLockException ex) {
// Another process was polling at the same time. We can ignore this error
return Collections.emptyList();
}
} | java |
public final PrintJobResultExtImpl getResult(final URI reportURI) {
final CriteriaBuilder builder = getSession().getCriteriaBuilder();
final CriteriaQuery<PrintJobResultExtImpl> criteria =
builder.createQuery(PrintJobResultExtImpl.class);
final Root<PrintJobResultExtImpl> root = criteria.from(PrintJobResultExtImpl.class);
criteria.where(builder.equal(root.get("reportURI"), reportURI.toString()));
return getSession().createQuery(criteria).uniqueResult();
} | java |
public void delete(final String referenceId) {
final CriteriaBuilder builder = getSession().getCriteriaBuilder();
final CriteriaDelete<PrintJobStatusExtImpl> delete =
builder.createCriteriaDelete(PrintJobStatusExtImpl.class);
final Root<PrintJobStatusExtImpl> root = delete.from(PrintJobStatusExtImpl.class);
delete.where(builder.equal(root.get("referenceId"), referenceId));
getSession().createQuery(delete).executeUpdate();
} | java |
public final void configureAccess(final Template template, final ApplicationContext context) {
final Configuration configuration = template.getConfiguration();
AndAccessAssertion accessAssertion = context.getBean(AndAccessAssertion.class);
accessAssertion.setPredicates(configuration.getAccessAssertion(), template.getAccessAssertion());
this.access = accessAssertion;
} | java |
protected final <T> StyleSupplier<T> createStyleSupplier(
final Template template,
final String styleRef) {
return new StyleSupplier<T>() {
@Override
public Style load(
final MfClientHttpRequestFactory requestFactory,
final T featureSource) {
final StyleParser parser = AbstractGridCoverageLayerPlugin.this.styleParser;
return OptionalUtils.or(
() -> template.getStyle(styleRef),
() -> parser.loadStyle(template.getConfiguration(), requestFactory, styleRef))
.orElse(template.getConfiguration().getDefaultStyle(NAME));
}
};
} | java |
private void store(final PrintJobStatus printJobStatus) throws JSONException {
JSONObject metadata = new JSONObject();
metadata.put(JSON_REQUEST_DATA, printJobStatus.getEntry().getRequestData().getInternalObj());
metadata.put(JSON_STATUS, printJobStatus.getStatus().toString());
metadata.put(JSON_START_DATE, printJobStatus.getStartTime());
metadata.put(JSON_REQUEST_COUNT, printJobStatus.getRequestCount());
if (printJobStatus.getCompletionDate() != null) {
metadata.put(JSON_COMPLETION_DATE, printJobStatus.getCompletionTime());
}
metadata.put(JSON_ACCESS_ASSERTION, this.assertionPersister.marshal(printJobStatus.getAccess()));
if (printJobStatus.getError() != null) {
metadata.put(JSON_ERROR, printJobStatus.getError());
}
if (printJobStatus.getResult() != null) {
metadata.put(JSON_REPORT_URI, printJobStatus.getResult().getReportURIString());
metadata.put(JSON_FILENAME, printJobStatus.getResult().getFileName());
metadata.put(JSON_FILE_EXT, printJobStatus.getResult().getFileExtension());
metadata.put(JSON_MIME_TYPE, printJobStatus.getResult().getMimeType());
}
this.registry.put(RESULT_METADATA + printJobStatus.getReferenceId(), metadata);
} | java |
public static boolean canParseColor(final String colorString) {
try {
return ColorParser.toColor(colorString) != null;
} catch (Exception exc) {
return false;
}
} | java |
private static Dimension adaptTileDimensions(
final Dimension pixels, final int maxWidth, final int maxHeight) {
return new Dimension(adaptTileDimension(pixels.width, maxWidth),
adaptTileDimension(pixels.height, maxHeight));
} | java |
public static Multimap<String, String> getParameters(final String rawQuery) {
Multimap<String, String> result = HashMultimap.create();
if (rawQuery == null) {
return result;
}
StringTokenizer tokens = new StringTokenizer(rawQuery, "&");
while (tokens.hasMoreTokens()) {
String pair = tokens.nextToken();
int pos = pair.indexOf('=');
String key;
String value;
if (pos == -1) {
key = pair;
value = "";
} else {
try {
key = URLDecoder.decode(pair.substring(0, pos), "UTF-8");
value = URLDecoder.decode(pair.substring(pos + 1), "UTF-8");
} catch (UnsupportedEncodingException e) {
throw ExceptionUtils.getRuntimeException(e);
}
}
result.put(key, value);
}
return result;
} | java |
public static URI setQueryParams(final URI initialUri, final Multimap<String, String> queryParams) {
StringBuilder queryString = new StringBuilder();
for (Map.Entry<String, String> entry: queryParams.entries()) {
if (queryString.length() > 0) {
queryString.append("&");
}
queryString.append(entry.getKey()).append("=").append(entry.getValue());
}
try {
if (initialUri.getHost() == null && initialUri.getAuthority() != null) {
return new URI(initialUri.getScheme(), initialUri.getAuthority(), initialUri.getPath(),
queryString.toString(),
initialUri.getFragment());
} else {
return new URI(initialUri.getScheme(), initialUri.getUserInfo(), initialUri.getHost(),
initialUri.getPort(),
initialUri.getPath(),
queryString.toString(), initialUri.getFragment());
}
} catch (URISyntaxException e) {
throw ExceptionUtils.getRuntimeException(e);
}
} | java |
public static URI setPath(final URI initialUri, final String path) {
String finalPath = path;
if (!finalPath.startsWith("/")) {
finalPath = '/' + path;
}
try {
if (initialUri.getHost() == null && initialUri.getAuthority() != null) {
return new URI(initialUri.getScheme(), initialUri.getAuthority(), finalPath,
initialUri.getQuery(),
initialUri.getFragment());
} else {
return new URI(initialUri.getScheme(), initialUri.getUserInfo(), initialUri.getHost(),
initialUri.getPort(),
finalPath, initialUri.getQuery(), initialUri.getFragment());
}
} catch (URISyntaxException e) {
throw ExceptionUtils.getRuntimeException(e);
}
} | java |
public final PJsonArray toJSON() {
JSONArray jsonArray = new JSONArray();
final int size = this.array.size();
for (int i = 0; i < size; i++) {
final Object o = get(i);
if (o instanceof PYamlObject) {
PYamlObject pYamlObject = (PYamlObject) o;
jsonArray.put(pYamlObject.toJSON().getInternalObj());
} else if (o instanceof PYamlArray) {
PYamlArray pYamlArray = (PYamlArray) o;
jsonArray.put(pYamlArray.toJSON().getInternalArray());
} else {
jsonArray.put(o);
}
}
return new PJsonArray(null, jsonArray, getContextName());
} | java |
@PostConstruct
public void checkUniqueSchemes() {
Multimap<String, ConfigFileLoaderPlugin> schemeToPluginMap = HashMultimap.create();
for (ConfigFileLoaderPlugin plugin: getLoaderPlugins()) {
schemeToPluginMap.put(plugin.getUriScheme(), plugin);
}
StringBuilder violations = new StringBuilder();
for (String scheme: schemeToPluginMap.keySet()) {
final Collection<ConfigFileLoaderPlugin> plugins = schemeToPluginMap.get(scheme);
if (plugins.size() > 1) {
violations.append("\n\n* ").append("There are has multiple ")
.append(ConfigFileLoaderPlugin.class.getSimpleName())
.append(" plugins that support the scheme: '").append(scheme).append('\'')
.append(":\n\t").append(plugins);
}
}
if (violations.length() > 0) {
throw new IllegalStateException(violations.toString());
}
} | java |
public Set<String> getSupportedUriSchemes() {
Set<String> schemes = new HashSet<>();
for (ConfigFileLoaderPlugin loaderPlugin: this.getLoaderPlugins()) {
schemes.add(loaderPlugin.getUriScheme());
}
return schemes;
} | java |
public static CoordinateReferenceSystem parseProjection(
final String projection, final Boolean longitudeFirst) {
try {
if (longitudeFirst == null) {
return CRS.decode(projection);
} else {
return CRS.decode(projection, longitudeFirst);
}
} catch (NoSuchAuthorityCodeException e) {
throw new RuntimeException(projection + " was not recognized as a crs code", e);
} catch (FactoryException e) {
throw new RuntimeException("Error occurred while parsing: " + projection, e);
}
} | java |
public final double[] getDpiSuggestions() {
if (this.dpiSuggestions == null) {
List<Double> list = new ArrayList<>();
for (double suggestion: DEFAULT_DPI_VALUES) {
if (suggestion <= this.maxDpi) {
list.add(suggestion);
}
}
double[] suggestions = new double[list.size()];
for (int i = 0; i < suggestions.length; i++) {
suggestions[i] = list.get(i);
}
return suggestions;
}
return this.dpiSuggestions;
} | java |
protected BufferedImage createErrorImage(final Rectangle area) {
final BufferedImage bufferedImage = new BufferedImage(area.width, area.height, TYPE_INT_ARGB_PRE);
final Graphics2D graphics = bufferedImage.createGraphics();
try {
graphics.setBackground(ColorParser.toColor(this.configuration.getTransparentTileErrorColor()));
graphics.clearRect(0, 0, area.width, area.height);
return bufferedImage;
} finally {
graphics.dispose();
}
} | java |
protected BufferedImage fetchImage(
@Nonnull final ClientHttpRequest request, @Nonnull final MapfishMapContext transformer)
throws IOException {
final String baseMetricName = getClass().getName() + ".read." +
StatsUtils.quotePart(request.getURI().getHost());
final Timer.Context timerDownload = this.registry.timer(baseMetricName).time();
try (ClientHttpResponse httpResponse = request.execute()) {
if (httpResponse.getStatusCode() != HttpStatus.OK) {
final String message = String.format(
"Invalid status code for %s (%d!=%d). The response was: '%s'",
request.getURI(), httpResponse.getStatusCode().value(),
HttpStatus.OK.value(), httpResponse.getStatusText());
this.registry.counter(baseMetricName + ".error").inc();
if (getFailOnError()) {
throw new RuntimeException(message);
} else {
LOGGER.info(message);
return createErrorImage(transformer.getPaintArea());
}
}
final List<String> contentType = httpResponse.getHeaders().get("Content-Type");
if (contentType == null || contentType.size() != 1) {
LOGGER.debug("The image {} didn't return a valid content type header.",
request.getURI());
} else if (!contentType.get(0).startsWith("image/")) {
final byte[] data;
try (InputStream body = httpResponse.getBody()) {
data = IOUtils.toByteArray(body);
}
LOGGER.debug("We get a wrong image for {}, content type: {}\nresult:\n{}",
request.getURI(), contentType.get(0),
new String(data, StandardCharsets.UTF_8));
this.registry.counter(baseMetricName + ".error").inc();
return createErrorImage(transformer.getPaintArea());
}
final BufferedImage image = ImageIO.read(httpResponse.getBody());
if (image == null) {
LOGGER.warn("Cannot read image from %a", request.getURI());
this.registry.counter(baseMetricName + ".error").inc();
if (getFailOnError()) {
throw new RuntimeException("Cannot read image from " + request.getURI());
} else {
return createErrorImage(transformer.getPaintArea());
}
}
timerDownload.stop();
return image;
} catch (Throwable e) {
this.registry.counter(baseMetricName + ".error").inc();
throw e;
}
} | java |
@SafeVarargs
public static <T> Set<T> create(final T... values) {
Set<T> result = new HashSet<>(values.length);
Collections.addAll(result, values);
return result;
} | java |
@SuppressWarnings({"deprecation", "WeakerAccess"})
protected void removeShutdownHook(ClassLoaderLeakPreventor preventor, Thread shutdownHook) {
final String displayString = "'" + shutdownHook + "' of type " + shutdownHook.getClass().getName();
preventor.error("Removing shutdown hook: " + displayString);
Runtime.getRuntime().removeShutdownHook(shutdownHook);
if(executeShutdownHooks) { // Shutdown hooks should be executed
preventor.info("Executing shutdown hook now: " + displayString);
// Make sure it's from protected ClassLoader
shutdownHook.start(); // Run cleanup immediately
if(shutdownHookWaitMs > 0) { // Wait for shutdown hook to finish
try {
shutdownHook.join(shutdownHookWaitMs); // Wait for thread to run
}
catch (InterruptedException e) {
// Do nothing
}
if(shutdownHook.isAlive()) {
preventor.warn(shutdownHook + "still running after " + shutdownHookWaitMs + " ms - Stopping!");
shutdownHook.stop();
}
}
}
} | java |
protected static int getIntInitParameter(ServletContext servletContext, String parameterName, int defaultValue) {
final String parameterString = servletContext.getInitParameter(parameterName);
if(parameterString != null && parameterString.trim().length() > 0) {
try {
return Integer.parseInt(parameterString);
}
catch (NumberFormatException e) {
// Do nothing, return default value
}
}
return defaultValue;
} | java |
@SuppressWarnings("WeakerAccess")
protected void clearRmiTargetsMap(ClassLoaderLeakPreventor preventor, Map<?, ?> rmiTargetsMap) {
try {
final Field cclField = preventor.findFieldOfClass("sun.rmi.transport.Target", "ccl");
preventor.debug("Looping " + rmiTargetsMap.size() + " RMI Targets to find leaks");
for(Iterator<?> iter = rmiTargetsMap.values().iterator(); iter.hasNext(); ) {
Object target = iter.next(); // sun.rmi.transport.Target
ClassLoader ccl = (ClassLoader) cclField.get(target);
if(preventor.isClassLoaderOrChild(ccl)) {
preventor.warn("Removing RMI Target: " + target);
iter.remove();
}
}
}
catch (Exception ex) {
preventor.error(ex);
}
} | java |
@SuppressWarnings("WeakerAccess")
protected boolean isJettyWithJMX(ClassLoaderLeakPreventor preventor) {
final ClassLoader classLoader = preventor.getClassLoader();
try {
// If package org.eclipse.jetty is found, we may be running under jetty
if (classLoader.getResource("org/eclipse/jetty") == null) {
return false;
}
Class.forName("org.eclipse.jetty.jmx.MBeanContainer", false, classLoader.getParent()); // JMX enabled?
Class.forName("org.eclipse.jetty.webapp.WebAppContext", false, classLoader.getParent());
}
catch(Exception ex) { // For example ClassNotFoundException
return false;
}
// Seems we are running in Jetty with JMX enabled
return true;
} | java |
public long[] keys() {
long[] values = new long[size];
int idx = 0;
for (Entry entry : table) {
while (entry != null) {
values[idx++] = entry.key;
entry = entry.next;
}
}
return values;
} | java |
public Entry<T>[] entries() {
@SuppressWarnings("unchecked")
Entry<T>[] entries = new Entry[size];
int idx = 0;
for (Entry entry : table) {
while (entry != null) {
entries[idx++] = entry;
entry = entry.next;
}
}
return entries;
} | java |
public boolean add(long key) {
final int index = ((((int) (key >>> 32)) ^ ((int) (key))) & 0x7fffffff) % capacity;
final Entry entryOriginal = table[index];
for (Entry entry = entryOriginal; entry != null; entry = entry.next) {
if (entry.key == key) {
return false;
}
}
table[index] = new Entry(key, entryOriginal);
size++;
if (size > threshold) {
setCapacity(2 * capacity);
}
return true;
} | java |
public boolean remove(long key) {
int index = ((((int) (key >>> 32)) ^ ((int) (key))) & 0x7fffffff) % capacity;
Entry previous = null;
Entry entry = table[index];
while (entry != null) {
Entry next = entry.next;
if (entry.key == key) {
if (previous == null) {
table[index] = next;
} else {
previous.next = next;
}
size--;
return true;
}
previous = entry;
entry = next;
}
return false;
} | java |
public VALUE put(KEY key, VALUE object) {
CacheEntry<VALUE> entry;
if (referenceType == ReferenceType.WEAK) {
entry = new CacheEntry<>(new WeakReference<>(object), null);
} else if (referenceType == ReferenceType.SOFT) {
entry = new CacheEntry<>(new SoftReference<>(object), null);
} else {
entry = new CacheEntry<>(null, object);
}
countPutCountSinceEviction++;
countPut++;
if (isExpiring && nextCleanUpTimestamp == 0) {
nextCleanUpTimestamp = System.currentTimeMillis() + expirationMillis + 1;
}
CacheEntry<VALUE> oldEntry;
synchronized (this) {
if (values.size() >= maxSize) {
evictToTargetSize(maxSize - 1);
}
oldEntry = values.put(key, entry);
}
return getValueForRemoved(oldEntry);
} | java |
public void putAll(Map<KEY, VALUE> mapDataToPut) {
int targetSize = maxSize - mapDataToPut.size();
if (maxSize > 0 && values.size() > targetSize) {
evictToTargetSize(targetSize);
}
Set<Entry<KEY, VALUE>> entries = mapDataToPut.entrySet();
for (Entry<KEY, VALUE> entry : entries) {
put(entry.getKey(), entry.getValue());
}
} | java |
public VALUE get(KEY key) {
CacheEntry<VALUE> entry;
synchronized (this) {
entry = values.get(key);
}
VALUE value;
if (entry != null) {
if (isExpiring) {
long age = System.currentTimeMillis() - entry.timeCreated;
if (age < expirationMillis) {
value = getValue(key, entry);
} else {
countExpired++;
synchronized (this) {
values.remove(key);
}
value = null;
}
} else {
value = getValue(key, entry);
}
} else {
value = null;
}
if (value != null) {
countHit++;
} else {
countMiss++;
}
return value;
} | java |
public static int copyAllBytes(InputStream in, OutputStream out) throws IOException {
int byteCount = 0;
byte[] buffer = new byte[BUFFER_SIZE];
while (true) {
int read = in.read(buffer);
if (read == -1) {
break;
}
out.write(buffer, 0, read);
byteCount += read;
}
return byteCount;
} | java |
public synchronized int get() {
if (available == 0) {
return -1;
}
byte value = buffer[idxGet];
idxGet = (idxGet + 1) % capacity;
available--;
return value;
} | java |
public synchronized int get(byte[] dst, int off, int len) {
if (available == 0) {
return 0;
}
// limit is last index to read + 1
int limit = idxGet < idxPut ? idxPut : capacity;
int count = Math.min(limit - idxGet, len);
System.arraycopy(buffer, idxGet, dst, off, count);
idxGet += count;
if (idxGet == capacity) {
// Array end reached, check if we have more
int count2 = Math.min(len - count, idxPut);
if (count2 > 0) {
System.arraycopy(buffer, 0, dst, off + count, count2);
idxGet = count2;
count += count2;
} else {
idxGet = 0;
}
}
available -= count;
return count;
} | java |
public synchronized boolean put(byte value) {
if (available == capacity) {
return false;
}
buffer[idxPut] = value;
idxPut = (idxPut + 1) % capacity;
available++;
return true;
} | java |
public synchronized int put(byte[] src, int off, int len) {
if (available == capacity) {
return 0;
}
// limit is last index to put + 1
int limit = idxPut < idxGet ? idxGet : capacity;
int count = Math.min(limit - idxPut, len);
System.arraycopy(src, off, buffer, idxPut, count);
idxPut += count;
if (idxPut == capacity) {
// Array end reached, check if we have more
int count2 = Math.min(len - count, idxGet);
if (count2 > 0) {
System.arraycopy(src, off + count, buffer, 0, count2);
idxPut = count2;
count += count2;
} else {
idxPut = 0;
}
}
available += count;
return count;
} | java |
public synchronized int skip(int count) {
if (count > available) {
count = available;
}
idxGet = (idxGet + count) % capacity;
available -= count;
return count;
} | java |
public static Object readObject(File file) throws IOException,
ClassNotFoundException {
FileInputStream fileIn = new FileInputStream(file);
ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(fileIn));
try {
return in.readObject();
} finally {
IoUtils.safeClose(in);
}
} | java |
public static void writeObject(File file, Object object) throws IOException {
FileOutputStream fileOut = new FileOutputStream(file);
ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(fileOut));
try {
out.writeObject(object);
out.flush();
// Force sync
fileOut.getFD().sync();
} finally {
IoUtils.safeClose(out);
}
} | java |
public static void setTime(Calendar calendar, int hourOfDay, int minute, int second, int millisecond) {
calendar.set(Calendar.HOUR_OF_DAY, hourOfDay);
calendar.set(Calendar.MINUTE, minute);
calendar.set(Calendar.SECOND, second);
calendar.set(Calendar.MILLISECOND, millisecond);
} | java |
public static int getDayAsReadableInt(long time) {
Calendar cal = calendarThreadLocal.get();
cal.setTimeInMillis(time);
return getDayAsReadableInt(cal);
} | java |
public static int getDayAsReadableInt(Calendar calendar) {
int day = calendar.get(Calendar.DAY_OF_MONTH);
int month = calendar.get(Calendar.MONTH) + 1;
int year = calendar.get(Calendar.YEAR);
return year * 10000 + month * 100 + day;
} | java |
public static String encodeUrlIso(String stringToEncode) {
try {
return URLEncoder.encode(stringToEncode, "ISO-8859-1");
} catch (UnsupportedEncodingException e1) {
throw new RuntimeException(e1);
}
} | java |
public static String decodeUrl(String stringToDecode) {
try {
return URLDecoder.decode(stringToDecode, "UTF-8");
} catch (UnsupportedEncodingException e1) {
throw new RuntimeException(e1);
}
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.