code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
protected URL[] getCompileClasspathElementURLs() throws DependencyResolutionRequiredException {
// build class loader to get classes to generate resources for
return project.getCompileClasspathElements().stream()
.map(path -> {
try {
return new File(path).toURI().toURL();
}
catch (MalformedURLException ex) {
throw new RuntimeException(ex);
}
})
.toArray(size -> new URL[size]);
} | java |
protected File getGeneratedResourcesDirectory() {
if (generatedResourcesFolder == null) {
String generatedResourcesFolderAbsolutePath = this.project.getBuild().getDirectory() + "/" + getGeneratedResourcesDirectoryPath();
generatedResourcesFolder = new File(generatedResourcesFolderAbsolutePath);
if (!generatedResourcesFolder.exists()) {
generatedResourcesFolder.mkdirs();
}
}
return generatedResourcesFolder;
} | java |
public static String getAPIVersion(final String resourceFileName, final String versionProperty) {
final Properties props = new Properties();
final URL url = ClassLoader.getSystemResource(resourceFileName);
if (url != null) {
InputStream is = null;
try {
is = url.openStream();
props.load(is);
} catch (IOException ex) {
LOG.debug("Unable to open resource file", ex);
} finally {
if (is != null) {
try {
is.close();
} catch (IOException e) {
}
}
}
}
String version = props.getProperty(versionProperty, "unknown");
return version;
} | java |
public String getExtendsInterface() {
if (this.getExtendsInterfaces().isEmpty()){
// return "Empty";
return this.getInstanceType();
} else {
String tName = this.getExtendsInterfaces().get(0).replaceAll("\\W+", "");
return tName;
}
} | java |
public static String escapeTitle(final String title) {
final String escapedTitle = title.replaceAll("^[^" + UNICODE_TITLE_START_CHAR + "]*", "").replaceAll("[^" + UNICODE_WORD + ". -]",
"");
if (isNullOrEmpty(escapedTitle)) {
return "";
} else {
// Remove whitespace
return escapedTitle.replaceAll("\\s+", "_").replaceAll("(^_+)|(_+$)", "").replaceAll("__", "_");
}
} | java |
public static String escapeForXML(final String content) {
if (content == null) return "";
/*
* Note: The following characters should be escaped: & < > " '
*
* However, all but ampersand pose issues when other elements are included in the title.
*
* eg <title>Product A > Product B<phrase condition="beta">-Beta</phrase></title>
*
* should become
*
* <title>Product A > Product B<phrase condition="beta">-Beta</phrase></title>
*/
String fixedContent = XMLUtilities.STANDALONE_AMPERSAND_PATTERN.matcher(content).replaceAll("&");
// Loop over and find all the XML Elements as they should remain untouched.
final LinkedList<String> elements = new LinkedList<String>();
if (fixedContent.indexOf('<') != -1) {
int index = -1;
while ((index = fixedContent.indexOf('<', index + 1)) != -1) {
int endIndex = fixedContent.indexOf('>', index);
int nextIndex = fixedContent.indexOf('<', index + 1);
/*
* If the next opening tag is less than the next ending tag, than the current opening tag isn't a match for the next
* ending tag, so continue to the next one
*/
if (endIndex == -1 || (nextIndex != -1 && nextIndex < endIndex)) {
continue;
} else if (index + 1 == endIndex) {
// This is a <> sequence, so it should be ignored as well.
continue;
} else {
elements.add(fixedContent.substring(index, endIndex + 1));
}
}
}
// Find all the elements and replace them with a marker
String escapedTitle = fixedContent;
for (int count = 0; count < elements.size(); count++) {
escapedTitle = escapedTitle.replace(elements.get(count), "###" + count + "###");
}
// Perform the replacements on what's left
escapedTitle = escapedTitle.replace("<", "<").replace(">", ">").replace("\"", """);
// Replace the markers
for (int count = 0; count < elements.size(); count++) {
escapedTitle = escapedTitle.replace("###" + count + "###", elements.get(count));
}
return escapedTitle;
} | java |
public static boolean validateTableRows(final Element table) {
assert table != null;
assert table.getNodeName().equals("table") || table.getNodeName().equals("informaltable");
final NodeList tgroups = table.getElementsByTagName("tgroup");
for (int i = 0; i < tgroups.getLength(); i++) {
final Element tgroup = (Element) tgroups.item(i);
if (!validateTableGroup(tgroup)) return false;
}
return true;
} | java |
public static boolean validateTableGroup(final Element tgroup) {
assert tgroup != null;
assert tgroup.getNodeName().equals("tgroup");
final Integer numColumns = Integer.parseInt(tgroup.getAttribute("cols"));
// Check that all the thead, tbody and tfoot elements have the correct number of entries.
final List<Node> nodes = XMLUtilities.getDirectChildNodes(tgroup, "thead", "tbody", "tfoot");
for (final Node ele : nodes) {
// Find all child nodes that are a row
final NodeList children = ele.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
final Node node = children.item(i);
if (node.getNodeName().equals("row") || node.getNodeName().equals("tr")) {
if (!validateTableRow(node, numColumns)) return false;
}
}
}
return true;
} | java |
public static boolean validateTableRow(final Node row, final int numColumns) {
assert row != null;
assert row.getNodeName().equals("row") || row.getNodeName().equals("tr");
if (row.getNodeName().equals("row")) {
final List<Node> entries = XMLUtilities.getDirectChildNodes(row, "entry");
final List<Node> entryTbls = XMLUtilities.getDirectChildNodes(row, "entrytbl");
if ((entries.size() + entryTbls.size()) <= numColumns) {
for (final Node entryTbl : entryTbls) {
if (!validateEntryTbl((Element) entryTbl)) return false;
}
return true;
} else {
return false;
}
} else {
final List<Node> nodes = XMLUtilities.getDirectChildNodes(row, "td", "th");
return nodes.size() <= numColumns;
}
} | java |
public static List<StringToNodeCollection> getTranslatableStringsV3(final Document xml, final boolean allowDuplicates) {
if (xml == null) return null;
return getTranslatableStringsV3(xml.getDocumentElement(), allowDuplicates);
} | java |
public static List<StringToNodeCollection> getTranslatableStringsV3(final Node node, final boolean allowDuplicates) {
if (node == null) return null;
final List<StringToNodeCollection> retValue = new LinkedList<StringToNodeCollection>();
final NodeList nodes = node.getChildNodes();
for (int i = 0; i < nodes.getLength(); ++i) {
final Node childNode = nodes.item(i);
getTranslatableStringsFromNodeV3(childNode, retValue, allowDuplicates, new XMLProperties());
}
return retValue;
} | java |
private static String cleanTranslationText(final String input, final boolean removeWhitespaceFromStart,
final boolean removeWhitespaceFromEnd) {
String retValue = XMLUtilities.cleanText(input);
retValue = retValue.trim();
/*
* When presenting the contents of a childless XML node to the translator, there is no need for white space padding.
* When building up a translatable string from a succession of text nodes, whitespace becomes important.
*/
if (!removeWhitespaceFromStart) {
if (PRECEEDING_WHITESPACE_SIMPLE_RE_PATTERN.matcher(input).matches()) {
retValue = " " + retValue;
}
}
if (!removeWhitespaceFromEnd) {
if (TRAILING_WHITESPACE_SIMPLE_RE_PATTERN.matcher(input).matches()) {
retValue += " ";
}
}
return retValue;
} | java |
public static Pair<String, String> wrapForValidation(final DocBookVersion docBookVersion, final String xml) {
final String rootEleName = XMLUtilities.findRootElementName(xml);
if (docBookVersion == DocBookVersion.DOCBOOK_50) {
if (rootEleName.equals("abstract") || rootEleName.equals("legalnotice") || rootEleName.equals("authorgroup")) {
final String preamble = XMLUtilities.findPreamble(xml);
final StringBuilder buffer = new StringBuilder("<book><info><title />");
if (preamble != null) {
buffer.append(xml.replace(preamble, ""));
} else {
buffer.append(xml);
}
buffer.append("</info></book>");
return new Pair<String, String>("book", DocBookUtilities.addDocBook50Namespace(buffer.toString()));
} else if (rootEleName.equals("info")) {
final String preamble = XMLUtilities.findPreamble(xml);
final StringBuilder buffer = new StringBuilder("<book>");
if (preamble != null) {
buffer.append(xml.replace(preamble, ""));
} else {
buffer.append(xml);
}
buffer.append("</book>");
return new Pair<String, String>("book", DocBookUtilities.addDocBook50Namespace(buffer.toString()));
}
}
return new Pair<String, String>(rootEleName, xml);
} | java |
public static void wrapForRendering(final Document xmlDoc) {
// Some topics need to be wrapped up to be rendered properly
final String documentElementNodeName = xmlDoc.getDocumentElement().getNodeName();
if (documentElementNodeName.equals("authorgroup") || documentElementNodeName.equals("legalnotice")) {
final Element currentChild = xmlDoc.createElement(documentElementNodeName);
xmlDoc.renameNode(xmlDoc.getDocumentElement(), xmlDoc.getNamespaceURI(), "book");
final Element bookInfo = xmlDoc.createElement("bookinfo");
xmlDoc.getDocumentElement().appendChild(bookInfo);
bookInfo.appendChild(currentChild);
final NodeList existingChildren = xmlDoc.getDocumentElement().getChildNodes();
for (int childIndex = 0; childIndex < existingChildren.getLength(); ++childIndex) {
final Node child = existingChildren.item(childIndex);
if (child != bookInfo) {
currentChild.appendChild(child);
}
}
}
} | java |
public static boolean validateTables(final Document doc) {
final NodeList tables = doc.getElementsByTagName("table");
for (int i = 0; i < tables.getLength(); i++) {
final Element table = (Element) tables.item(i);
if (!validateTableRows(table)) {
return false;
}
}
final NodeList informalTables = doc.getElementsByTagName("informaltable");
for (int i = 0; i < informalTables.getLength(); i++) {
final Element informalTable = (Element) informalTables.item(i);
if (!validateTableRows(informalTable)) {
return false;
}
}
return true;
} | java |
public static boolean checkForInvalidInfoElements(final Document doc) {
final List<Node> invalidElements = XMLUtilities.getDirectChildNodes(doc.getDocumentElement(), "title", "subtitle", "titleabbrev");
return invalidElements != null && !invalidElements.isEmpty();
} | java |
public static String validateRevisionHistory(final Document doc, final String[] dateFormats) {
final List<String> invalidRevNumbers = new ArrayList<String>();
// Find each <revnumber> element and make sure it matches the publican regex
final NodeList revisions = doc.getElementsByTagName("revision");
Date previousDate = null;
for (int i = 0; i < revisions.getLength(); i++) {
final Element revision = (Element) revisions.item(i);
final NodeList revnumbers = revision.getElementsByTagName("revnumber");
final Element revnumber = revnumbers.getLength() == 1 ? (Element) revnumbers.item(0) : null;
final NodeList dates = revision.getElementsByTagName("date");
final Element date = dates.getLength() == 1 ? (Element) dates.item(0) : null;
// Make sure the rev number is valid and the order is correct
if (revnumber != null && !revnumber.getTextContent().matches("^([0-9.]*)-([0-9.]*)$")) {
invalidRevNumbers.add(revnumber.getTextContent());
} else if (revnumber == null) {
return "Invalid revision, missing <revnumber> element.";
}
// Check the dates are in chronological order
if (date != null) {
try {
final Date revisionDate = DateUtils.parseDateStrictly(cleanDate(date.getTextContent()), Locale.ENGLISH, dateFormats);
if (previousDate != null && revisionDate.after(previousDate)) {
return "The revisions in the Revision History are not in descending chronological order, " +
"starting from \"" + date.getTextContent() + "\".";
}
previousDate = revisionDate;
} catch (Exception e) {
// Check that it is an invalid format or just an incorrect date (ie the day doesn't match)
try {
DateUtils.parseDate(cleanDate(date.getTextContent()), Locale.ENGLISH, dateFormats);
return "Invalid revision, the name of the day specified in \"" + date.getTextContent() + "\" doesn't match the " +
"date.";
} catch (Exception ex) {
return "Invalid revision, the date \"" + date.getTextContent() + "\" is not in a valid format.";
}
}
} else {
return "Invalid revision, missing <date> element.";
}
}
if (!invalidRevNumbers.isEmpty()) {
return "Revision History has invalid <revnumber> values: " + CollectionUtilities.toSeperatedString(invalidRevNumbers,
", ") + ". The revnumber must match \"^([0-9.]*)-([0-9.]*)$\" to be valid.";
} else {
return null;
}
} | java |
private static String cleanDate(final String dateString) {
if (dateString == null) {
return dateString;
}
String retValue = dateString;
retValue = THURSDAY_DATE_RE.matcher(retValue).replaceAll("Thu");
retValue = TUESDAY_DATE_RE.matcher(retValue).replaceAll("Tue");
return retValue;
} | java |
public static Object get(final Object bean, final String property) {
try {
if (property.indexOf(".") >= 0) {
final Object subBean = ClassMockUtils.get(bean, property.substring(0, property.indexOf(".")));
if (subBean == null) {
return null;
}
final String newProperty = property.substring(property.indexOf(".") + 1);
return ClassMockUtils.get(subBean, newProperty);
}
Method method = null;
try {
method = bean.getClass().getMethod(ClassMockUtils.propertyToGetter(property), new Class[] {});
} catch (final NoSuchMethodException e) {
method = bean.getClass().getMethod(ClassMockUtils.propertyToGetter(property, true), new Class[] {});
}
return method.invoke(bean, new Object[] {});
} catch (final Exception e) {
throw new RuntimeException("Can't get property " + property + " in the class " + bean.getClass().getName(), e);
}
} | java |
public static Object newInstance(final IClassWriter classMock) {
try {
final Class<?> clazz = classMock.build();
return clazz.newInstance();
} catch (final Exception e) {
throw new RuntimeException("Can't intanciate class", e);
}
} | java |
public LogWatchBuilder withDelayBetweenReads(final int length, final TimeUnit unit) {
this.delayBetweenReads = LogWatchBuilder.getDelay(length, unit);
return this;
} | java |
public LogWatchBuilder withDelayBetweenSweeps(final int length, final TimeUnit unit) {
this.delayBetweenSweeps = LogWatchBuilder.getDelay(length, unit);
return this;
} | java |
private Source register(Source source) {
/**
* As promised, the registrar simply abstracts away internal resolvers
* by iterating over them during the registration process.
*/
for (Resolver resolver : resolvers) {
resolver.register(source);
}
return source;
} | java |
private void checkForCycles(
Class<?> target,
Class<?> in,
Stack<Class<?>> trace) {
for (Field field : in.getDeclaredFields()) {
if (field.getAnnotation(Autowired.class) != null) {
Class<?> type = field.getType();
trace.push(type);
if (type.equals(target)) {
throw new DependencyCycleException(trace);
} else {
checkForCycles(target, type, trace);
}
trace.pop();
}
}
} | java |
public static SimpleModule getTupleMapperModule() {
SimpleModule module = new SimpleModule("1", Version.unknownVersion());
SimpleAbstractTypeResolver resolver = getTupleTypeResolver();
module.setAbstractTypes(resolver);
module.setKeyDeserializers(new SimpleKeyDeserializers());
return module;
} | java |
public void addSparseConstraint(int component, int index, double value) {
constraints.add(new Constraint(component, index, value));
} | java |
private static boolean isInheritIOBroken() {
if (!System.getProperty("os.name", "none").toLowerCase().contains("windows")) {
return false;
}
String runtime = System.getProperty("java.runtime.version");
if (!runtime.startsWith("1.7")) {
return false;
}
String[] tokens = runtime.split("_");
if (tokens.length < 2) {
return true; // No idea actually, shouldn't happen
}
try {
Integer build = Integer.valueOf(tokens[1].split("[^0-9]")[0]);
if (build < 60) {
return true;
}
} catch (Exception ex) {
return true;
}
return false;
} | java |
public synchronized static void setFormatter(Formatter formatter) {
java.util.logging.Logger root = java.util.logging.LogManager.getLogManager().getLogger(StringUtils.EMPTY);
for (Handler h : root.getHandlers()) {
h.setFormatter(formatter);
}
} | java |
public synchronized static void clearHandlers() {
java.util.logging.Logger root = java.util.logging.LogManager.getLogManager().getLogger(StringUtils.EMPTY);
Handler[] handlers = root.getHandlers();
for (Handler h : handlers) {
root.removeHandler(h);
}
} | java |
public synchronized static void addHandler(Handler handler) {
java.util.logging.Logger root = java.util.logging.LogManager.getLogManager().getLogger(StringUtils.EMPTY);
root.addHandler(handler);
} | java |
public Logger getLogger(Class<?> clazz) {
if (clazz == null) {
return getGlobalLogger();
}
return getLogger(clazz.getName());
} | java |
public Logger getGlobalLogger() {
return new Logger(java.util.logging.Logger
.getLogger(java.util.logging.Logger.GLOBAL_LOGGER_NAME));
} | java |
public List<String> getLoggerNames() {
return Collections.list(java.util.logging.LogManager.getLogManager().getLoggerNames());
} | java |
public void setLevel(String logger, Level level) {
Logger log = getLogger(logger);
log.setLevel(level);
for (String loggerName : getLoggerNames()) {
if (loggerName.startsWith(logger) && !loggerName.equals(logger)) {
getLogger(loggerName).setLevel(level);
}
}
} | java |
public String renderServiceHtml(io.wcm.caravan.hal.docs.impl.model.Service service) throws IOException {
Map<String, Object> model = ImmutableMap.<String, Object>builder()
.put("service", service)
.build();
return render(service, model, serviceTemplate);
} | java |
public String renderLinkRelationHtml(io.wcm.caravan.hal.docs.impl.model.Service service, LinkRelation linkRelation)
throws IOException {
Map<String, Object> model = ImmutableMap.<String, Object>builder()
.put("service", service)
.put("linkRelation", linkRelation)
.build();
return render(service, model, linkRelationTemplate);
} | java |
private String render(io.wcm.caravan.hal.docs.impl.model.Service service, Map<String, Object> model,
Template template) throws IOException {
Map<String, Object> mergedModel = ImmutableMap.<String, Object>builder()
.putAll(model)
.put("docsContext", ImmutableMap.<String, Object>builder()
.put("baseUrl", DocsPath.get(service.getServiceId()) + "/")
.put("resourcesPath", HalDocsBundleTracker.DOCS_RESOURCES_URI_PREFIX)
.build())
.build();
return template.apply(mergedModel);
} | java |
public boolean start() {
if (!this.isStarted.compareAndSet(false, true)) {
return false;
}
final long delay = this.delayBetweenSweeps;
this.timer.scheduleWithFixedDelay(this, delay, delay, TimeUnit.MILLISECONDS);
LogWatchStorageSweeper.LOGGER.info(
"Scheduled automated unreachable message sweep in {} to run every {} millisecond(s).",
this.messaging.getLogWatch(), delay);
return true;
} | java |
public boolean stop() {
if (!this.isStarted.get() || !this.isStopped.compareAndSet(false, true)) {
return false;
}
this.timer.shutdown();
LogWatchStorageSweeper.LOGGER.info("Cancelled automated unreachable message sweep in {}.",
this.messaging.getLogWatch());
return true;
} | java |
private Properties copyProperties(Properties source)
{
Properties copy = new Properties();
if (source != null)
{
copy.putAll(source);
}
return copy;
} | java |
public void save(File file, String comment, boolean saveDefaults) throws IOException
{
save(file, comment, saveDefaults, null);
} | java |
public void save(File file,
String comment,
boolean saveDefaults,
String propertyName) throws IOException
{
gatekeeper.lock();
try
{
File parent = file.getParentFile();
if (!parent.exists() && !parent.mkdirs())
{
throw new IOException("Directory at \""
+ parent.getAbsolutePath()
+ "\" does not exist and cannot be created");
}
FileOutputStream outputStream = new FileOutputStream(file);
try
{
Properties tmpProperties = getProperties(saveDefaults,
propertyName);
tmpProperties.store(outputStream, comment);
/*
* If we only saved a single property, only that property should
* be marked synced.
*/
if (propertyName != null)
{
properties.get(propertyName).synced();
}
else
{
for (ChangeStack<String> stack : properties.values())
{
stack.synced();
}
}
}
finally
{
outputStream.close();
}
}
finally
{
gatekeeper.unlock();
}
} | java |
public String getProperty(String propertyName)
{
ChangeStack<String> stack = properties.get(propertyName);
if (stack == null)
{
return null;
}
return stack.getCurrentValue();
} | java |
public boolean setProperty(String propertyName, String value) throws NullPointerException
{
return setValue(propertyName, value, false);
} | java |
private boolean setValue(String propertyName, String value, boolean sync) throws NullPointerException
{
gatekeeper.signIn();
try
{
ChangeStack<String> stack = properties.get(propertyName);
if (stack == null)
{
ChangeStack<String> newStack = new ChangeStack<String>(value,
sync);
stack = properties.putIfAbsent(propertyName, newStack);
if (stack == null)
{
return true;
}
}
return sync ? stack.sync(value) : stack.push(value);
}
finally
{
gatekeeper.signOut();
}
} | java |
public boolean resetToDefault(String propertyName)
{
gatekeeper.signIn();
try
{
/*
* If this property was added with no default value, all we can do
* is remove the property entirely.
*/
String defaultValue = getDefaultValue(propertyName);
if (defaultValue == null)
{
return properties.remove(propertyName) != null;
}
/*
* Every property with a default value is guaranteed to have a
* stack. Since we just confirmed the existence of a default value,
* we know the stack is available.
*/
return properties.get(propertyName).push(defaultValue);
}
finally
{
gatekeeper.signOut();
}
} | java |
public void resetToDefaults()
{
gatekeeper.signIn();
try
{
for (Iterator<Entry<String, ChangeStack<String>>> iter = properties.entrySet()
.iterator(); iter.hasNext();)
{
Entry<String, ChangeStack<String>> entry = iter.next();
String defaultValue = getDefaultValue(entry.getKey());
if (defaultValue == null)
{
iter.remove();
continue;
}
entry.getValue().push(defaultValue);
}
}
finally
{
gatekeeper.signOut();
}
} | java |
public boolean isModified(String propertyName)
{
gatekeeper.signIn();
try
{
ChangeStack<String> stack = properties.get(propertyName);
if (stack == null)
{
return false;
}
return stack.isModified();
}
finally
{
gatekeeper.signOut();
}
} | java |
public boolean isModified()
{
gatekeeper.signIn();
try
{
for (ChangeStack<String> stack : properties.values())
{
if (stack.isModified())
{
return true;
}
}
return false;
}
finally
{
gatekeeper.signOut();
}
} | java |
public static Resource from(String resource) {
if (StringUtils.isNullOrBlank(resource)) {
return new StringResource();
}
Matcher matcher = protocolPattern.matcher(resource);
if (matcher.find()) {
String schema = matcher.group("PROTOCOL");
String options = matcher.group("OPTIONS");
String path = matcher.group("PATH");
if (StringUtils.isNullOrBlank(options)) {
options = "";
} else {
options = options.replaceFirst("\\[", "").replaceFirst("\\]$", "");
}
ResourceProvider provider = resourceProviders.get(schema.toLowerCase());
if (provider == null) {
try {
return new URIResource(new URI(resource));
} catch (URISyntaxException e) {
throw new IllegalStateException(schema + " is an unknown protocol.");
}
}
if (provider.requiresProtocol()) {
path = schema + ":" + path;
}
return provider.createResource(path, Val.of(options).asMap(String.class, String.class));
}
return new FileResource(resource);
} | java |
public static Resource temporaryDirectory() {
File tempDir = new File(SystemInfo.JAVA_IO_TMPDIR);
String baseName = System.currentTimeMillis() + "-";
for (int i = 0; i < 1_000_000; i++) {
File tmp = new File(tempDir, baseName + i);
if (tmp.mkdir()) {
return new FileResource(tmp);
}
}
throw new RuntimeException("Unable to create temp directory");
} | java |
public static Resource temporaryFile(String name, String extension) throws IOException {
return new FileResource(File.createTempFile(name, extension));
} | java |
public synchronized Future<Message> setExpectation(final C condition, final MessageAction<P> action) {
if (this.isStopped()) {
throw new IllegalStateException("Already stopped.");
}
final AbstractExpectation<C, P> expectation = this.createExpectation(condition, action);
final Future<Message> future = AbstractExpectationManager.EXECUTOR.submit(expectation);
this.expectations.put(expectation, future);
AbstractExpectationManager.LOGGER.info("Registered expectation {} with action {}.", expectation, action);
return future;
} | java |
protected synchronized boolean unsetExpectation(final AbstractExpectation<C, P> expectation) {
if (this.expectations.containsKey(expectation)) {
this.expectations.remove(expectation);
AbstractExpectationManager.LOGGER.info("Unregistered expectation {}.", expectation);
return true;
}
return false;
} | java |
@Api
public <T> void setOption(GestureOption<T> option, T value) {
if (value == null) {
throw new IllegalArgumentException("Null value passed.");
}
if (value instanceof Boolean) {
setOption(this, (Boolean) value, option.getName());
} else if (value instanceof Integer) {
setOption(this, (Integer) value, option.getName());
} else if (value instanceof Double) {
setOption(this, (Double) value, option.getName());
} else if (value instanceof String) {
setOption(this, String.valueOf(value), option.getName());
}
} | java |
static String toChars(String p) {
if (p.length() >= 3 && p.charAt(0) == '[' && p.charAt(p.length() - 1) == ']') {
return p.substring(1, p.length() - 1);
}
return p;
} | java |
public Regex then(Regex regex) {
if (regex == null) {
return this;
}
return re(this.pattern + regex.pattern);
} | java |
public Regex group(String name) {
return re("(" + (StringUtils.isNotNullOrBlank(name) ? "?<" + name + ">" : StringUtils.EMPTY) + pattern + ")");
} | java |
public Regex not() {
if (this.pattern.length() > 0) {
if (this.pattern.charAt(0) == '[' && this.pattern.length() > 1) {
return re("[^" + this.pattern.substring(1));
}
return re("^" + this.pattern);
}
return this;
} | java |
public Regex range(int min, int max) {
return re(this.pattern + "{" + Integer.toString(min) + "," + Integer.toString(max) + "}");
} | java |
public static ListMultimap<String, Link> getAllLinks(HalResource hal, Predicate<Pair<String, Link>> predicate) {
return getAllLinks(hal, "self", predicate);
} | java |
public static List<Link> getAllLinksForRelation(HalResource hal, String relation) {
List<Link> links = Lists.newArrayList(hal.getLinks(relation));
List<Link> embeddedLinks = hal.getEmbedded().values().stream()
.flatMap(embedded -> getAllLinksForRelation(embedded, relation).stream())
.collect(Collectors.toList());
links.addAll(embeddedLinks);
return links;
} | java |
private void cleanup(boolean atStartup) {
boolean allTasksIdle = false;
while (!allTasksIdle) {
int activeCount = 0;
for (Task task: taskDao.listTasks()) {
if (!task.getState().equals(Task.IDLE)) {
activeCount++;
if (!task.getState().equals(Task.CANCELING)) {
logger.info("Auto-canceling task " + task.getId() + " (" + task.getName() + ")");
taskDao.setTaskState(task.getId(), Task.CANCELING);
task.setState(Task.CANCELING);
}
if (atStartup) {
// We're cleaning up after an unclean shutdown.
// Since the TaskRunner isn't actually running, we make
// the direct call here to clean up the state in the
// database, marking it as canceled.
taskCanceled(task);
} else {
// In the normal case, the TaskRunner is running in a
// separate thread and we just need to request that
// it cancel at the next available opportunity.
cancelTask(task);
}
}
}
if (activeCount == 0 || atStartup) {
allTasksIdle = true;
} else {
logger.info("Waiting for " + activeCount + " task(s) to go idle.");
sleepSeconds(1);
}
}
} | java |
public static Pattern createFilePattern(String filePattern) {
filePattern = StringUtils.isNullOrBlank(filePattern) ? "\\*" : filePattern;
filePattern = filePattern.replaceAll("\\.", "\\.");
filePattern = filePattern.replaceAll("\\*", ".*");
return Pattern.compile("^" + filePattern + "$");
} | java |
public static boolean isCompressed(PushbackInputStream pushbackInputStream) throws IOException {
if (pushbackInputStream == null) {
return false;
}
byte[] buffer = new byte[2];
int read = pushbackInputStream.read(buffer);
boolean isCompressed = false;
if (read == 2) {
isCompressed = ((buffer[0] == (byte) (GZIPInputStream.GZIP_MAGIC)) && (buffer[1] == (byte) (GZIPInputStream.GZIP_MAGIC >> 8)));
}
if (read != -1) {
pushbackInputStream.unread(buffer, 0, read);
}
return isCompressed;
} | java |
public static String toUnix(String spec) {
if (spec == null) {
return StringUtils.EMPTY;
}
return spec.replaceAll("\\\\+", "/");
} | java |
public static String toWindows(String spec) {
if (spec == null) {
return StringUtils.EMPTY;
}
return spec.replaceAll("/+", "\\\\");
} | java |
public static String addTrailingSlashIfNeeded(String directory) {
if (StringUtils.isNullOrBlank(directory)) {
return StringUtils.EMPTY;
}
int separator = indexOfLastSeparator(directory);
String slash = SystemInfo.isUnix() ? Character.toString(UNIX_SEPARATOR) : Character.toString(WINDOWS_SEPARATOR);
if (separator != -1) {
slash = Character.toString(directory.charAt(separator));
}
return directory.endsWith(slash) ? directory : directory + slash;
} | java |
public static String parent(String file) {
if (StringUtils.isNullOrBlank(file)) {
return StringUtils.EMPTY;
}
file = StringUtils.trim(file);
String path = path(file);
int index = indexOfLastSeparator(path);
if (index <= 0) {
return SystemInfo.isUnix() ? Character.toString(UNIX_SEPARATOR) : Character.toString(WINDOWS_SEPARATOR);
}
return path.substring(0, index);
} | java |
private static boolean openBrowserJava6(String url) throws Exception {
final Class<?> desktopClass;
try {
desktopClass = Class.forName("java.awt.Desktop");
} catch (ClassNotFoundException e) {
return false;
}
Boolean supported = (Boolean) desktopClass.getMethod("isDesktopSupported", new Class[0]).invoke(null);
if (supported) {
Object desktop = desktopClass.getMethod("getDesktop", new Class[0]).invoke(null);
desktopClass.getMethod("browse", new Class[]{URI.class}).invoke(desktop, new URI(url));
return true;
}
return false;
} | java |
private static String[] getOpenBrowserCommand(String url) throws IOException, InterruptedException {
if (IS_WINDOWS) {
return new String[]{"rundll32", "url.dll,FileProtocolHandler", url};
} else if (IS_MAC) {
return new String[]{"/usr/bin/open", url};
} else if (IS_LINUX) {
String[] browsers = {"google-chrome", "firefox", "opera", "konqueror", "epiphany", "mozilla", "netscape"};
for (String browser : browsers) {
if (Runtime.getRuntime().exec(new String[]{"which", browser}).waitFor() == 0) {
return new String[]{browser, url};
}
}
throw new UnsupportedOperationException("Cannot find a browser");
} else {
throw new UnsupportedOperationException("Opening browser is not implemented for your OS (" + OS_NAME + ")");
}
} | java |
public ParserToken lookAhead(int distance) {
while (distance >= buffer.size() && tokenIterator.hasNext()) {
buffer.addLast(tokenIterator.next());
}
return buffer.size() > distance ? buffer.getLast() : null;
} | java |
public ParserTokenType lookAheadType(int distance) {
ParserToken token = lookAhead(distance);
return token == null ? null : token.type;
} | java |
public boolean nonConsumingMatch(ParserTokenType rhs) {
ParserToken token = lookAhead(0);
return token != null && token.type.isInstance(rhs);
} | java |
public boolean match(ParserTokenType expected) {
ParserToken next = lookAhead(0);
if (next == null || !next.type.isInstance(expected)) {
return false;
}
consume();
return true;
} | java |
public static void main(String[] args)
{
JFrame frame;
App biorhythm = new App();
try {
frame = new JFrame("Biorhythm");
frame.addWindowListener(new AppCloser(frame, biorhythm));
} catch (java.lang.Throwable ivjExc) {
frame = null;
System.out.println(ivjExc.getMessage());
ivjExc.printStackTrace();
}
frame.getContentPane().add(BorderLayout.CENTER, biorhythm);
Dimension size = biorhythm.getSize();
if ((size == null) || ((size.getHeight() < 100) | (size.getWidth() < 100)))
size = new Dimension(640, 400);
frame.setSize(size);
biorhythm.init(); // Simulate the applet calls
frame.setTitle("Sample java application");
biorhythm.start();
frame.setVisible(true);
} | java |
public void init()
{
JPanel view = new JPanel();
view.setLayout(new BorderLayout());
label = new JLabel(INITIAL_TEXT);
Font font = new Font(Font.SANS_SERIF, Font.BOLD, 32);
label.setFont(font);
view.add(BorderLayout.CENTER, label);
this.getContentPane().add(BorderLayout.CENTER, view);
this.startRollingText();
} | java |
public String replicateTable(String tableName, boolean toCopyData) throws SQLException {
String tempTableName = MySqlCommunication.getTempTableName(tableName);
LOG.debug("Replicate table {} into {}", tableName, tempTableName);
if (this.tableExists(tempTableName)) {
this.truncateTempTable(tempTableName);
} else {
this.createTempTable(tableName);
}
if (toCopyData) {
final String sql = "INSERT INTO " + tempTableName + " SELECT * FROM " + tableName + ";";
this.executeUpdate(sql);
}
return tempTableName;
} | java |
public void restoreTable(String tableName, String tempTableName) throws SQLException {
LOG.debug("Restore table {} from {}", tableName, tempTableName);
try {
this.setForeignKeyCheckEnabled(false);
this.truncateTable(tableName);
final String sql = "INSERT INTO " + tableName + " SELECT * FROM " + tempTableName + ";";
this.executeUpdate(sql);
} finally {
this.setForeignKeyCheckEnabled(true);
}
} | java |
public void removeTempTable(String tempTableName) throws SQLException {
if (tempTableName == null) {
return;
}
if (!tempTableName.contains(TEMP_TABLE_NAME_SUFFIX)) {
throw new SQLException(tempTableName + " is not a valid temp table name");
}
try (Connection conn = this.getConn(); Statement stmt = conn.createStatement()) {
final String sql = "DROP TABLE " + tempTableName + ";";
LOG.debug("{} executing update: {}", this.dbInfo, sql);
int row = stmt.executeUpdate(sql);
}
} | java |
public final void addParser(@NotNull final ParserConfig parser) {
Contract.requireArgNotNull("parser", parser);
if (list == null) {
list = new ArrayList<>();
}
list.add(parser);
} | java |
private String setXmlPreambleAndDTD(final String xml, final String dtdFileName, final String entities, final String dtdRootEleName) {
// Check if the XML already has a DOCTYPE. If it does then replace the values and remove entities for processing
final Matcher matcher = DOCTYPE_PATTERN.matcher(xml);
if (matcher.find()) {
String preamble = matcher.group("Preamble");
String name = matcher.group("Name");
String systemId = matcher.group("SystemId");
String declaredEntities = matcher.group("Entities");
String doctype = matcher.group();
String newDoctype = doctype.replace(name, dtdRootEleName);
if (systemId != null) {
newDoctype = newDoctype.replace(systemId, dtdFileName);
}
if (declaredEntities != null) {
newDoctype = newDoctype.replace(declaredEntities, " [\n" + entities + "\n]");
} else {
newDoctype = newDoctype.substring(0, newDoctype.length() - 1) + " [\n" + entities + "\n]>";
}
if (preamble == null) {
final StringBuilder output = new StringBuilder();
output.append("<?xml version='1.0' encoding='UTF-8' ?>\n");
output.append(xml.replace(doctype, newDoctype));
return output.toString();
} else {
return xml.replace(doctype, newDoctype);
}
} else {
// The XML doesn't have any doctype so add it
final String preamble = XMLUtilities.findPreamble(xml);
if (preamble != null) {
final StringBuilder doctype = new StringBuilder();
doctype.append(preamble);
appendDoctype(doctype, dtdRootEleName, dtdFileName, entities);
return xml.replace(preamble, doctype.toString());
} else {
final StringBuilder output = new StringBuilder();
output.append("<?xml version='1.0' encoding='UTF-8' ?>\n");
appendDoctype(output, dtdRootEleName, dtdFileName, entities);
output.append(xml);
return output.toString();
}
}
} | java |
public int process() {
// Calculate the result of the left operation if any
if (leftOperation != null) {
leftOperand = leftOperation.process();
}
// Calculate the result of the right operation if any
if (rightOperation != null) {
rightOperand = rightOperation.process();
}
// Process the operation itself after the composition resolution
return calculate();
} | java |
public void executeAction(ShanksSimulation simulation, ShanksAgent agent,
List<NetworkElement> arguments) throws ShanksException {
for (NetworkElement ne : arguments) {
this.addAffectedElement(ne);
}
this.launchEvent();
} | java |
@Override
public synchronized boolean stopFollowing(final Follower follower) {
if (!this.isFollowedBy(follower)) {
return false;
}
this.stopConsuming(follower);
DefaultLogWatch.LOGGER.info("Unregistered {} for {}.", follower, this);
return true;
} | java |
public void progress() {
count++;
if (count % period == 0 && LOG.isInfoEnabled()) {
final double percent = 100 * (count / (double) totalIterations);
final long tock = System.currentTimeMillis();
final long timeInterval = tock - tick;
final long linesPerSec = (count - prevCount) * 1000 / timeInterval;
tick = tock;
prevCount = count;
final int etaSeconds = (int) ((totalIterations - count) / linesPerSec);
final long hours = SECONDS.toHours(etaSeconds);
final long minutes = SECONDS.toMinutes(etaSeconds - HOURS.toSeconds(hours));
final long seconds = SECONDS.toSeconds(etaSeconds - MINUTES.toSeconds(minutes));
LOG.info(String.format("[%3.0f%%] Completed %d iterations of %d total input. %d iters/s. ETA %02d:%02d:%02d",
percent, count, totalIterations, linesPerSec, hours, minutes, seconds));
}
} | java |
public void writeEntries(JarFile jarFile) throws IOException {
Enumeration<JarEntry> entries = jarFile.entries();
while (entries.hasMoreElements()) {
JarEntry entry = entries.nextElement();
ZipHeaderPeekInputStream inputStream = new ZipHeaderPeekInputStream(
jarFile.getInputStream(entry));
try {
if (inputStream.hasZipHeader() && entry.getMethod() != ZipEntry.STORED) {
new CrcAndSize(inputStream).setupStoredEntry(entry);
inputStream.close();
inputStream = new ZipHeaderPeekInputStream(
jarFile.getInputStream(entry));
}
EntryWriter entryWriter = new InputStreamEntryWriter(inputStream, true);
writeEntry(entry, entryWriter);
} finally {
inputStream.close();
}
}
} | java |
@Override
public void afterProjectsRead(final MavenSession session) throws MavenExecutionException {
boolean anyProject = false;
for (MavenProject project : session.getProjects()) {
if (project.getPlugin("ceylon") != null
|| project.getPlugin("ceylon-maven-plugin") != null
|| "ceylon".equals(project.getArtifact().getArtifactHandler().getPackaging())
|| "car".equals(project.getArtifact().getArtifactHandler().getPackaging())
|| "ceylon-jar".equals(project.getArtifact().getArtifactHandler().getPackaging())
|| usesCeylonRepo(project)) {
anyProject = true;
}
}
if (anyProject) {
logger.info("At least one project is using the Ceylon plugin. Preparing.");
findCeylonRepo(session);
}
logger.info("Adding Ceylon repositories to build");
session.getRequest().setWorkspaceReader(
new CeylonWorkspaceReader(
session.getRequest().getWorkspaceReader(),
logger));
} | java |
private boolean usesCeylonRepo(final MavenProject project) {
for (Repository repo : project.getRepositories()) {
if ("ceylon".equals(repo.getLayout())) {
return true;
}
}
for (Artifact ext : project.getPluginArtifacts()) {
if (ext.getArtifactId().startsWith("ceylon")) {
return true;
}
}
return false;
} | java |
public void stream(InputStream inputStream, MediaType mediaType) {
try {
OutputStream outputStream = exchange.getOutputStream();
setResponseMediaType(mediaType);
byte[] buffer = new byte[10240];
int len;
while ((len = inputStream.read(buffer)) != -1) {
outputStream.write(buffer, 0, len);
}
} catch (Exception ex) {
throw new RuntimeException("Error transferring data", ex);
}
} | java |
public ServiceInformation get(String key) {
ServiceInformation info = null;
long hash = algorithm.hash(key);
//Find the first server with a hash key after this one
final SortedMap<Long, ServiceInformation> tailMap = ring.tailMap(hash);
//Wrap around to the beginning of the ring, if we went past the last one
hash = tailMap.isEmpty() ? ring.firstKey() : tailMap.firstKey();
info = ring.get(hash);
return info;
} | java |
public void addScenario(Class<? extends Scenario> scenarioClass,
String scenarioID, String initialState, Properties properties,
String gatewayDeviceID, String externalLinkID)
throws ShanksException {
// throws NonGatewayDeviceException, TooManyConnectionException,
// DuplicatedIDException, AlreadyConnectedScenarioException,
// SecurityException, NoSuchMethodException, IllegalArgumentException,
// InstantiationException, IllegalAccessException,
// InvocationTargetException {
Constructor<? extends Scenario> c;
Scenario scenario;
try {
c = scenarioClass.getConstructor(new Class[] { String.class,
String.class, Properties.class, Logger.class });
scenario = c.newInstance(scenarioID, initialState, properties, this.getLogger());
} catch (SecurityException e) {
throw new ShanksException(e);
} catch (NoSuchMethodException e) {
throw new ShanksException(e);
} catch (IllegalArgumentException e) {
throw new ShanksException(e);
} catch (InstantiationException e) {
throw new ShanksException(e);
} catch (IllegalAccessException e) {
throw new ShanksException(e);
} catch (InvocationTargetException e) {
throw new ShanksException(e);
}
Device gateway = (Device) scenario.getNetworkElement(gatewayDeviceID);
Link externalLink = (Link) this.getNetworkElement(externalLinkID);
if (!scenario.getCurrentElements().containsKey(gatewayDeviceID)) {
throw new NonGatewayDeviceException(scenario, gateway, externalLink);
} else {
gateway.connectToLink(externalLink);
if (!this.getCurrentElements().containsKey(externalLink.getID())) {
this.addNetworkElement(externalLink);
}
if (!this.scenarios.containsKey(scenario)) {
this.scenarios.put(scenario, new ArrayList<Link>());
} else {
List<Link> externalLinks = this.scenarios.get(scenario);
if (!externalLinks.contains(externalLink)) {
externalLinks.add(externalLink);
} else if (externalLink.getLinkedDevices().contains(gateway)) {
throw new AlreadyConnectedScenarioException(scenario,
gateway, externalLink);
}
}
}
} | java |
public void addPossiblesFailuresComplex() {
Set<Scenario> scenarios = this.getScenarios();
for (Scenario s : scenarios) {
for (Class<? extends Failure> c : s.getPossibleFailures().keySet()) {
if (!this.getPossibleFailures().containsKey(c)) {
this.addPossibleFailure(c, s.getPossibleFailures().get(c));
} else {
List<Set<NetworkElement>> elements = this
.getPossibleFailures().get(c);
// elements.addAll(s.getPossibleFailures().get(c));
for (Set<NetworkElement> sne : s.getPossibleFailures().get(
c)) {
if (!elements.contains(sne))
elements.add(sne);
}
this.addPossibleFailure(c, elements);
}
}
}
} | java |
public void addPossiblesEventsComplex() {
Set<Scenario> scenarios = this.getScenarios();
for (Scenario s : scenarios) {
for (Class<? extends Event> c : s.getPossibleEventsOfNE().keySet()) {
if (!this.getPossibleEventsOfNE().containsKey(c)) {
this.addPossibleEventsOfNE(c, s.getPossibleEventsOfNE()
.get(c));
} else {
List<Set<NetworkElement>> elements = this
.getPossibleEventsOfNE().get(c);
// elements.addAll(s.getPossibleEventsOfNE().get(c));
for (Set<NetworkElement> sne : s.getPossibleEventsOfNE()
.get(c)) {
if (!elements.contains(sne))
elements.add(sne);
}
this.addPossibleEventsOfNE(c, elements);
}
}
for (Class<? extends Event> c : s.getPossibleEventsOfScenario()
.keySet()) {
if (!this.getPossibleEventsOfScenario().containsKey(c)) {
this.addPossibleEventsOfScenario(c, s
.getPossibleEventsOfScenario().get(c));
} else {
List<Set<Scenario>> elements = this
.getPossibleEventsOfScenario().get(c);
// elements.addAll(s.getPossibleEventsOfScenario().get(c));
for (Set<Scenario> sne : s.getPossibleEventsOfScenario()
.get(c)) {
if (!elements.contains(sne))
elements.add(sne);
}
this.addPossibleEventsOfScenario(c, elements);
}
}
}
} | java |
@Api
public <T> void setOption(GestureOption<T> option, T value) {
hammertime.setOption(option, value);
} | java |
@Api
public void unregisterHandler(EventType eventType) {
if (!jsHandlersMap.containsKey(eventType)) {
return;
}
HammerGwt.off(hammertime, eventType, (NativeHammmerHandler) jsHandlersMap.remove(eventType));
} | java |
private List<String> getChildrenList() {
if (childrenList != null) return childrenList;
SharedPreferences prefs = loadSharedPreferences("children");
String list = prefs.getString(getId(), null);
childrenList = (list == null) ? new ArrayList<String>() : new ArrayList<>(Arrays.asList(list.split(",")));
return childrenList;
} | java |
public void addChild(C child) {
SharedPreferences prefs = loadSharedPreferences("children");
List<String> objects = getChildrenList();
Model toPut = (Model) child;
if (objects.indexOf(toPut.getId()) != ArrayUtils.INDEX_NOT_FOUND) {
return;
}
objects.add(toPut.getId());
toPut.save();
prefs.edit().putString(String.valueOf(getId()), StringUtils.join(objects, ",")).commit();
} | java |
public boolean removeChild(String id) {
SharedPreferences prefs = loadSharedPreferences("children");
List<String> objects = getChildrenList();
if (objects.indexOf(id) == ArrayUtils.INDEX_NOT_FOUND) {
return false;
}
objects.remove(id);
prefs.edit().putString(String.valueOf(getId()), StringUtils.join(objects, ",")).commit();
return true;
} | java |
public C findChild(String id) {
int index = getChildrenList().indexOf(id);
if (index == ArrayUtils.INDEX_NOT_FOUND) {
return null;
}
C child = null;
try {
Model dummy = (Model) childClazz.newInstance();
dummy.setContext(context);
child = (C) dummy.find(id);
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return child;
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.