code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
@NotNull
public static Document parseDocument(@NotNull final DocumentBuilder builder,
@NotNull final InputStream inputStream) {
Contract.requireArgNotNull("builder", builder);
Contract.requireArgNotNull("inputStream", inputStream);
try {
return builder.parse(inputStream);
} catch (final SAXException | IOException ex) {
throw new RuntimeException("Failed to parse XML", ex);
}
} | java |
@NotNull
public static XPath createXPath(@Nullable final String... values) {
final NamespaceContext context = new NamespaceContextMap(values);
final XPath xPath = XPathFactory.newInstance().newXPath();
xPath.setNamespaceContext(context);
return xPath;
} | java |
@NotNull
public static DocumentBuilder createDocumentBuilder() {
try {
final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setNamespaceAware(true);
return factory.newDocumentBuilder();
} catch (final ParserConfigurationException ex) {
throw new RuntimeException("Couldn't create document builder", ex);
}
} | java |
private void reduceResults(final List<AnalysisResultFuture> results,
final Map<ComponentJob, AnalyzerResult> resultMap,
final List<AnalysisResultReductionException> reductionErrors) {
if (_hasRun.get()) {
// already reduced
return;
}
_hasRun.set(true);
for (AnalysisResultFuture result : results) {
if (result.isErrornous()) {
logger.error("Encountered errorneous slave result. Result reduction will stop. Result={}", result);
final List<Throwable> errors = result.getErrors();
if (!errors.isEmpty()) {
final Throwable firstError = errors.get(0);
logger.error(
"Encountered error before reducing results (showing stack trace of invoking the reducer): "
+ firstError.getMessage(), new Throwable());
_analysisListener.errorUknown(_masterJob, firstError);
}
// error occurred!
return;
}
}
final Collection<AnalyzerJob> analyzerJobs = _masterJob.getAnalyzerJobs();
for (AnalyzerJob masterAnalyzerJob : analyzerJobs) {
final Collection<AnalyzerResult> slaveResults = new ArrayList<AnalyzerResult>();
logger.info("Reducing {} slave results for component: {}", results.size(), masterAnalyzerJob);
for (AnalysisResultFuture result : results) {
final Map<ComponentJob, AnalyzerResult> slaveResultMap = result.getResultMap();
final List<AnalyzerJob> slaveAnalyzerJobs = CollectionUtils2.filterOnClass(slaveResultMap.keySet(),
AnalyzerJob.class);
final AnalyzerJobHelper analyzerJobHelper = new AnalyzerJobHelper(slaveAnalyzerJobs);
final AnalyzerJob slaveAnalyzerJob = analyzerJobHelper.getAnalyzerJob(masterAnalyzerJob);
if (slaveAnalyzerJob == null) {
throw new IllegalStateException("Could not resolve slave component matching [" + masterAnalyzerJob
+ "] in slave result: " + result);
}
final AnalyzerResult analyzerResult = result.getResult(slaveAnalyzerJob);
slaveResults.add(analyzerResult);
}
reduce(masterAnalyzerJob, slaveResults, resultMap, reductionErrors);
}
} | java |
@SuppressWarnings("unchecked")
private void reduce(AnalyzerJob analyzerJob, Collection<AnalyzerResult> slaveResults,
Map<ComponentJob, AnalyzerResult> resultMap, List<AnalysisResultReductionException> reductionErrors) {
if (slaveResults.size() == 1) {
// special case where these was only 1 slave job
final AnalyzerResult firstResult = slaveResults.iterator().next();
resultMap.put(analyzerJob, firstResult);
_analysisListener.analyzerSuccess(_masterJob, analyzerJob, firstResult);
return;
}
final Class<? extends AnalyzerResultReducer<?>> reducerClass = analyzerJob.getDescriptor()
.getResultReducerClass();
final ComponentDescriptor<? extends AnalyzerResultReducer<?>> reducerDescriptor = Descriptors
.ofComponent(reducerClass);
AnalyzerResultReducer<AnalyzerResult> reducer = null;
boolean success = false;
try {
reducer = (AnalyzerResultReducer<AnalyzerResult>) reducerDescriptor.newInstance();
_lifeCycleHelper.assignProvidedProperties(reducerDescriptor, reducer);
_lifeCycleHelper.initialize(reducerDescriptor, reducer);
final AnalyzerResult reducedResult = reducer.reduce(slaveResults);
resultMap.put(analyzerJob, reducedResult);
success = true;
_analysisListener.analyzerSuccess(_masterJob, analyzerJob, reducedResult);
} catch (Exception e) {
AnalysisResultReductionException reductionError = new AnalysisResultReductionException(analyzerJob,
slaveResults, e);
reductionErrors.add(reductionError);
_analysisListener.errorInComponent(_masterJob, analyzerJob, null, e);
} finally {
if (reducer != null) {
_lifeCycleHelper.close(reducerDescriptor, reducer, success);
}
}
} | java |
public Configuration unmarshall(InputStream inputStream) {
try {
final Unmarshaller unmarshaller = _jaxbContext.createUnmarshaller();
unmarshaller.setEventHandler(new JaxbValidationEventHandler());
final Configuration configuration = (Configuration) unmarshaller.unmarshal(inputStream);
return configuration;
} catch (JAXBException e) {
throw new IllegalStateException(e);
}
} | java |
public void marshall(Configuration configuration, OutputStream outputStream) {
try {
final Marshaller marshaller = _jaxbContext.createMarshaller();
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
marshaller.setEventHandler(new JaxbValidationEventHandler());
marshaller.marshal(configuration, outputStream);
} catch (JAXBException e) {
throw new IllegalStateException(e);
}
} | java |
public static synchronized void createSource(Java._ClassBody clazz)
throws IOException {
if (baseDir == null) {
throw new IOException("Base directory for output not set, use 'setBaseDirectory'");
}
String pkg = clazz.getPackage();
if (pkg == null) {
pkg = "";
// throw new IOException("Class package cannot be null");
}
pkg = pkg.replace('.', '/');
File path = new File(baseDir, pkg);
path.mkdirs();
try (PrintWriter fp = new PrintWriter(new FileWriter(new File(path, clazz.getName() + ".java")))) {
clazz.emit(0, fp);
}
} | java |
private static void emitCommentIndentN(PrintWriter fp, String text, int indent, boolean type) {
synchronized (lock) {
String cc = type ? "/**" : "/*";
fp.println(cc);
String comment = emitCommentIndentNOnly(fp, text, indent);
fp.println(comment + "/");
}
} | java |
private static void emitFinishCommentIndentN(PrintWriter fp, int indent) {
final String spaces = " ";
synchronized (lock) {
String comment = spaces.substring(0, indent) + " */";
fp.println(comment);
}
} | java |
private static String emitCommentIndentNOnly(PrintWriter fp, String text, int indent) {
synchronized (lock) {
return (emitCommentIndentNOnly(fp, text, indent, true));
}
} | java |
public void create(String outputdir, Program program) {
types.stream().forEach((type) -> type.createOutput(outputdir, program));
} | java |
protected boolean setConfiguredPropertyIfChanged(final ConfiguredPropertyDescriptor configuredProperty,
final Object value) {
if (configuredProperty == null) {
throw new IllegalArgumentException("configuredProperty cannot be null");
}
final Object currentValue = configuredProperty.getValue(_configurableBean);
if (EqualsBuilder.equals(currentValue, value)) {
// no change
return false;
}
if (value != null) {
boolean correctType = true;
if (configuredProperty.isArray()) {
if (value.getClass().isArray()) {
int length = Array.getLength(value);
for (int i = 0; i < length; i++) {
Object valuePart = Array.get(value, i);
if (valuePart == null) {
logger.warn("Element no. {} in array (size {}) is null! Value passed to {}", new Object[] {
i, length, configuredProperty });
} else {
if (!ReflectionUtils.is(valuePart.getClass(), configuredProperty.getBaseType())) {
correctType = false;
}
}
}
} else {
if (!ReflectionUtils.is(value.getClass(), configuredProperty.getBaseType())) {
correctType = false;
}
}
} else {
if (!ReflectionUtils.is(value.getClass(), configuredProperty.getBaseType())) {
correctType = false;
}
}
if (!correctType) {
throw new IllegalArgumentException("Invalid value type: " + value.getClass().getName() + ", expected: "
+ configuredProperty.getBaseType().getName());
}
}
configuredProperty.setValue(_configurableBean, value);
return true;
} | java |
@NotNull
public static <T> T deserialize(@NotNull final DeserializerRegistry registry, @NotNull final SerializedData data) {
Contract.requireArgNotNull("registry", registry);
Contract.requireArgNotNull("data", data);
final Deserializer deserializer = registry.getDeserializer(data.getType(), data.getMimeType());
return deserializer.unmarshal(data.getRaw(), data.getType(), data.getMimeType());
} | java |
public static EnhancedMimeType mimeType(@NotNull final SerializerRegistry registry, @NotNull final List<CommonEvent> commonEvents) {
Contract.requireArgNotNull("registry", registry);
Contract.requireArgNotNull("commonEvents", commonEvents);
EnhancedMimeType mimeType = null;
for (final CommonEvent commonEvent : commonEvents) {
final Serializer serializer = registry.getSerializer(new SerializedDataType(commonEvent.getDataType().asBaseType()));
if (mimeType == null) {
mimeType = serializer.getMimeType();
} else {
if (!mimeType.equals(serializer.getMimeType())) {
return null;
}
}
}
return mimeType;
} | java |
public static boolean eventsEqual(@Nullable final List<CommonEvent> eventsA, @Nullable final List<CommonEvent> eventsB) {
if ((eventsA == null) && (eventsB == null)) {
return true;
}
if ((eventsA == null) && (eventsB != null)) {
return false;
}
if ((eventsA != null) && (eventsB == null)) {
return false;
}
if (eventsA.size() != eventsB.size()) {
return false;
}
int currentIdx = eventsA.size() - 1;
int appendIdx = eventsB.size() - 1;
while (appendIdx >= 0) {
final CommonEvent current = eventsA.get(currentIdx);
final CommonEvent append = eventsB.get(appendIdx);
if (!current.equals(append)) {
return false;
}
currentIdx--;
appendIdx--;
}
return true;
} | java |
public static String nodeToString(final Node node) {
try {
final Transformer t = TransformerFactory.newInstance().newTransformer();
t.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
final StringWriter sw = new StringWriter();
t.transform(new DOMSource(node), new StreamResult(sw));
return sw.toString();
} catch (final TransformerException ex) {
throw new RuntimeException("Failed to render node", ex);
}
} | java |
public static JsonbDeserializer<?>[] joinJsonbDeserializerArrays(final JsonbDeserializer<?>[]... deserializerArrays) {
final List<JsonbDeserializer<?>> all = joinArrays(deserializerArrays);
return all.toArray(new JsonbDeserializer<?>[all.size()]);
} | java |
@Override
public final CommonEvent convert(final RecordedEvent eventData) {
final EnhancedMimeType escMetaMimeType = metaMimeType(eventData.isJson);
final SerializedDataType escSerMetaType = new SerializedDataType(EscMeta.TYPE.asBaseType());
final Deserializer escMetaDeserializer = deserRegistry.getDeserializer(escSerMetaType,
escMetaMimeType);
final EscMeta escMeta = escMetaDeserializer.unmarshal(eventData.metadata, escSerMetaType, escMetaMimeType);
final EnhancedMimeType metaMimeType = escMeta.getMetaContentType();
final String metaTransferEncoding;
if (escMeta.getMetaType() == null) {
metaTransferEncoding = null;
} else {
metaTransferEncoding = escMeta.getMetaContentType().getParameter("transfer-encoding");
}
final EnhancedMimeType dataMimeType = escMeta.getDataContentType();
final SerializedDataType serDataType = new SerializedDataType(escMeta.getDataType());
final Deserializer dataDeserializer = deserRegistry.getDeserializer(serDataType, dataMimeType);
final String dataTransferEncoding = escMeta.getDataContentType().getParameter("transfer-encoding");
final Object data = unmarshal(dataTransferEncoding, serDataType, dataDeserializer, dataMimeType, eventData.data,
metaMimeType, escMetaMimeType);
final EventId eventId = new EventId(eventData.eventId);
final TypeName dataType = new TypeName(eventData.eventType);
if (escMeta.getMetaType() == null) {
return new SimpleCommonEvent(eventId, dataType, data);
}
final TypeName metaType = new TypeName(escMeta.getMetaType());
final SerializedDataType serMetaType = new SerializedDataType(escMeta.getMetaType());
final Deserializer metaDeserializer = deserRegistry.getDeserializer(serMetaType, metaMimeType);
final Object meta = unmarshal(metaTransferEncoding, serMetaType, metaDeserializer, metaMimeType, escMeta.getMeta(),
metaMimeType, escMetaMimeType);
return new SimpleCommonEvent(eventId, dataType, data, metaType, meta);
} | java |
public SortedSet<TimeInterval> getOverlappingIntervals(boolean includeSingleTimeInstanceIntervals) {
SortedSet<TimeInterval> result = new TreeSet<TimeInterval>();
for (TimeInterval interval1 : intervals) {
for (TimeInterval interval2 : intervals) {
if (interval1 != interval2) {
TimeInterval overlap = interval1.getOverlap(interval2);
if (overlap != null) {
result.add(overlap);
}
}
}
}
result = getFlattenedIntervals(result);
if (!includeSingleTimeInstanceIntervals) {
for (Iterator<TimeInterval> it = result.iterator(); it.hasNext();) {
TimeInterval timeInterval = it.next();
if (timeInterval.isSingleTimeInstance()) {
it.remove();
}
}
}
return result;
} | java |
public SortedSet<TimeInterval> getTimeGapIntervals() {
SortedSet<TimeInterval> flattenedIntervals = getFlattenedIntervals();
SortedSet<TimeInterval> gaps = new TreeSet<TimeInterval>();
TimeInterval previous = null;
for (TimeInterval timeInterval : flattenedIntervals) {
if (previous != null) {
long from = previous.getTo();
long to = timeInterval.getFrom();
TimeInterval gap = new TimeInterval(from, to);
gaps.add(gap);
}
previous = timeInterval;
}
return gaps;
} | java |
public static byte[] decode(char[] in, int iOff, int iLen) {
if (iLen % 4 != 0) {
throw new IllegalArgumentException("Length of Base64 encoded input string is not a multiple of 4.");
}
while (iLen > 0 && in[iOff + iLen - 1] == '=') {
iLen--;
}
int oLen = (iLen * 3) / 4;
byte[] out = new byte[oLen];
int ip = iOff;
int iEnd = iOff + iLen;
int op = 0;
while (ip < iEnd) {
int i0 = in[ip++];
int i1 = in[ip++];
int i2 = ip < iEnd ? in[ip++] : 'A';
int i3 = ip < iEnd ? in[ip++] : 'A';
if (i0 > 127 || i1 > 127 || i2 > 127 || i3 > 127) {
throw new IllegalArgumentException("Illegal character in Base64 encoded data.");
}
int b0 = map2[i0];
int b1 = map2[i1];
int b2 = map2[i2];
int b3 = map2[i3];
if (b0 < 0 || b1 < 0 || b2 < 0 || b3 < 0) {
throw new IllegalArgumentException("Illegal character in Base64 encoded data.");
}
int o0 = (b0 << 2) | (b1 >>> 4);
int o1 = ((b1 & 0xf) << 4) | (b2 >>> 2);
int o2 = ((b2 & 3) << 6) | b3;
out[op++] = (byte) o0;
if (op < oLen) {
out[op++] = (byte) o1;
}
if (op < oLen) {
out[op++] = (byte) o2;
}
}
return out;
} | java |
private String getPropertyKey() {
if (StringUtils.isNullOrEmpty(captureStateIdentifier)) {
if (lastModifiedColumn.isPhysicalColumn()) {
Table table = lastModifiedColumn.getPhysicalColumn().getTable();
if (table != null && !StringUtils.isNullOrEmpty(table.getName())) {
return table.getName() + "." + lastModifiedColumn.getName() + ".GreatestLastModifiedTimestamp";
}
}
return lastModifiedColumn.getName() + ".GreatestLastModifiedTimestamp";
}
return captureStateIdentifier.trim() + ".GreatestLastModifiedTimestamp";
} | java |
public static void addToScope(Scriptable scope, Object object, String... names) {
Object jsObject = Context.javaToJS(object, scope);
for (String name : names) {
name = name.replaceAll(" ", "_");
ScriptableObject.putProperty(scope, name, jsObject);
}
} | java |
public static void addToScope(Scriptable scope, InputRow inputRow, InputColumn<?>[] columns, String arrayName) {
NativeArray values = new NativeArray(columns.length * 2);
for (int i = 0; i < columns.length; i++) {
InputColumn<?> column = columns[i];
Object value = inputRow.getValue(column);
if (value != null) {
Class<?> dataType = column.getDataType();
if (ReflectionUtils.isNumber(dataType)) {
value = Context.toNumber(value);
} else if (ReflectionUtils.isBoolean(dataType)) {
value = Context.toBoolean(value);
}
}
values.put(i, values, value);
values.put(column.getName(), values, value);
addToScope(scope, value, column.getName(), column.getName().toLowerCase(), column.getName().toUpperCase());
}
addToScope(scope, values, arrayName);
} | java |
@Nullable
public final Charset getEncoding() {
final String parameter = getParameter(ENCODING);
if (parameter == null) {
return null;
}
return Charset.forName(parameter);
} | java |
public final boolean matchEncoding(final EnhancedMimeType other) {
return match(other) && Objects.equals(getEncoding(), other.getEncoding());
} | java |
@Nullable
public static EnhancedMimeType create(@Nullable final String str) {
if (str == null) {
return null;
}
try {
return new EnhancedMimeType(str);
} catch (final MimeTypeParseException ex) {
throw new RuntimeException("Failed to create versioned mime type: " + str, ex);
}
} | java |
@NotNull
public static EnhancedMimeType create(@NotNull final String primary, @NotNull final String sub,
final Charset encoding, final String version) {
return create(primary, sub, encoding, version, new HashMap<String, String>());
} | java |
@NotNull
public static EnhancedMimeType create(@NotNull final String primary, @NotNull final String sub,
final Charset encoding, final String version, final Map<String, String> parameters) {
try {
return new EnhancedMimeType(primary, sub, encoding, version, parameters);
} catch (final MimeTypeParseException ex) {
throw new RuntimeException("Failed to create versioned mime type: " + primary + "/" + sub, ex);
}
} | java |
public void init(final SerializedDataTypeRegistry typeRegistry, final DeserializerRegistry deserRegistry,
final SerializerRegistry serRegistry) {
if (initialized) {
throw new IllegalStateException("Instance already initialized - Don't call the init methods more than once");
}
this.typeRegistry = typeRegistry;
for (final JsonbDeserializer<?> deserializer : deserializers) {
if (deserializer instanceof DeserializerRegistryRequired) {
if (deserRegistry == null) {
throw new IllegalStateException(
"There is at least one deserializer that requires a 'DeserializerRegistry', but you didn't provide one (deserializer="
+ deserializer.getClass().getName() + ")");
}
final DeserializerRegistryRequired des = (DeserializerRegistryRequired) deserializer;
des.setRegistry(deserRegistry);
}
if (deserializer instanceof SerializedDataTypeRegistryRequired) {
if (typeRegistry == null) {
throw new IllegalStateException(
"There is at least one deserializer that requires a 'SerializedDataTypeRegistry', but you didn't provide one (deserializer="
+ deserializer.getClass().getName() + ")");
}
final SerializedDataTypeRegistryRequired des = (SerializedDataTypeRegistryRequired) deserializer;
des.setRegistry(typeRegistry);
}
}
for (final JsonbSerializer<?> serializer : serializers) {
if (serializer instanceof SerializerRegistryRequired) {
if (serRegistry == null) {
throw new IllegalStateException(
"There is at least one serializer that requires a 'SerializerRegistry', but you didn't provide one (serializer="
+ serializer.getClass().getName() + ")");
}
final SerializerRegistryRequired ser = (SerializerRegistryRequired) serializer;
ser.setRegistry(serRegistry);
}
if (serializer instanceof SerializedDataTypeRegistryRequired) {
if (typeRegistry == null) {
throw new IllegalStateException(
"There is at least one serializer that requires a 'SerializedDataTypeRegistry', but you didn't provide one (serializer="
+ serializer.getClass().getName() + ")");
}
final SerializedDataTypeRegistryRequired ser = (SerializedDataTypeRegistryRequired) serializer;
ser.setRegistry(typeRegistry);
}
}
initialized = true;
} | java |
public void initializeAll(InjectionManager injectionManager) {
if (injectionManager != null) {
for (Converter<?> converter : _converters) {
Field[] fields = ReflectionUtils.getFields(converter.getClass(), Inject.class);
for (Field field : fields) {
final Object value;
if (field.getType() == Converter.class) {
// Injected converters are used as callbacks. They
// should be assigned to the outer converter, which is
// this.
value = this;
} else {
InjectionPoint<Object> injectionPoint = new MemberInjectionPoint<Object>(field, converter);
value = injectionManager.getInstance(injectionPoint);
}
field.setAccessible(true);
try {
field.set(converter, value);
} catch (Exception e) {
throw new IllegalStateException("Could not initialize converter: " + converter, e);
}
}
}
}
} | java |
public static Method[] getMethods(Class<?> clazz) {
final boolean legacyApproach = isGetMethodsLegacyApproach();
final List<Method> allMethods = new ArrayList<>();
addMethods(allMethods, clazz, legacyApproach);
return allMethods.toArray(new Method[allMethods.size()]);
} | java |
public static <T> String joinAnd(final String delimiter, final String lastDelimiter, final Collection<T> objs) {
if (objs == null || objs.isEmpty()) {
return "";
}
final Iterator<T> iter = objs.iterator();
final StringBuffer buffer = new StringBuffer(Strings.toString(iter.next()));
int i = 1;
while (iter.hasNext()) {
final T obj = iter.next();
if (notEmpty(obj)) {
buffer.append(++i == objs.size() ? lastDelimiter : delimiter).append(Strings.toString(obj));
}
}
return buffer.toString();
} | java |
public final ProjectionJavaScriptBuilder type(final String eventType) {
if (count > 0) {
sb.append(",");
}
sb.append("'" + eventType + "': function(state, ev) { linkTo('" + projection + "', ev); }");
count++;
return this;
} | java |
public List<CommonEvent> asCommonEvents(final JAXBContext ctx) {
final List<CommonEvent> list = new ArrayList<CommonEvent>();
for (final Event event : events) {
list.add(event.asCommonEvent(ctx));
}
return list;
} | java |
public static boolean isValid(String name) {
char[] nameChars = name.toCharArray();
for (int i = 0; i < nameChars.length; i++) {
boolean valid = i == 0 ? Character.isJavaIdentifierStart(nameChars[i]) : Character.isJavaIdentifierPart(nameChars[i]);
if (!valid) {
return valid;
}
}
return true;
} | java |
List<Integer> getParaSents(Integer para) {
List<Integer> sentList = new ArrayList<Integer>(this.paraSentIndex.get(para));
Collections.sort(sentList);
return sentList;
} | java |
List<List<Annotation>> getSentences(AnnotationType type, String groupID) {
List<List<Annotation>> sentences = new ArrayList<List<Annotation>>();
for (int sent : Helper.getIndexKeys(type, groupID, this.sentIndex)) {
sentences.add(this.getSentAnnotations(sent, type));
}
return sentences;
} | java |
List<List<Annotation>> getParagraphs(AnnotationType type, String groupID) {
List<List<Annotation>> paragraphs = new ArrayList<List<Annotation>>();
for (int para : Helper.getIndexKeys(type, groupID, this.paraIndex)) {
paragraphs.add(this.getParaAnnotations(para, type));
}
return paragraphs;
} | java |
public static String streamEntityName(final StreamId streamId) {
// User defined ID
if (streamId instanceof JpaStreamId) {
final JpaStreamId jpaId = (JpaStreamId) streamId;
return jpaId.getEntityName();
}
// Default ID
if (streamId.isProjection()) {
return streamId.getName();
}
if (streamId.getParameters().size() == 0) {
return NoParamsStream.class.getSimpleName();
}
return streamId.getName() + "Stream";
} | java |
public static String nativeEventsTableName(final StreamId streamId) {
// User defined ID
if (streamId instanceof JpaStreamId) {
final JpaStreamId jpaId = (JpaStreamId) streamId;
return jpaId.getNativeTableName();
}
// Default ID
if (streamId.isProjection()) {
return camel2Underscore(streamId.getName());
}
if (streamId.getParameters().size() == 0) {
return NoParamsEvent.NO_PARAMS_EVENTS_TABLE;
}
return camel2Underscore(streamId.getName()) + "_events";
} | java |
public static String camel2Underscore(@Nullable final String name) {
if (name == null) {
return null;
}
return name.replaceAll("(.)(\\p{Upper})", "$1_$2").toLowerCase();
} | java |
public final CommonEvent asCommonEvent(final JAXBContext ctx) {
final Object m;
if (getMeta() == null) {
m = null;
} else {
m = getMeta().unmarshalContent(ctx);
}
final Object d = getData().unmarshalContent(ctx);
if (getMeta() == null) {
return new SimpleCommonEvent(getId(),
new TypeName(getData().getType()), d);
}
return new SimpleCommonEvent(getId(), new TypeName(getData().getType()),
d, new TypeName(getMeta().getType()), m);
} | java |
public static Event valueOf(final CommonEvent selEvent) {
final Data data = Data.valueOf(selEvent.getDataType().asBaseType(),
selEvent.getData());
if (selEvent.getMeta() == null) {
return new Event(selEvent.getId(), data);
}
final Data meta = Data.valueOf("meta", selEvent.getMeta());
return new Event(selEvent.getId(), data, meta);
} | java |
public boolean isConfigured(final boolean throwException) throws IllegalStateException,
UnconfiguredConfiguredPropertyException {
if (_datastoreConnection == null) {
if (throwException) {
throw new IllegalStateException("No Datastore or DatastoreConnection set");
}
return false;
}
if (_sourceColumns.isEmpty()) {
if (throwException) {
throw new IllegalStateException("No source columns in job");
}
return false;
}
if (_analyzerJobBuilders.isEmpty()) {
if (throwException) {
throw new IllegalStateException("No Analyzers in job");
}
return false;
}
for (FilterJobBuilder<?, ?> fjb : _filterJobBuilders) {
if (!fjb.isConfigured(throwException)) {
return false;
}
}
for (TransformerJobBuilder<?> tjb : _transformerJobBuilders) {
if (!tjb.isConfigured(throwException)) {
return false;
}
}
for (AnalyzerJobBuilder<?> ajb : _analyzerJobBuilders) {
if (!ajb.isConfigured(throwException)) {
return false;
}
}
return true;
} | java |
private void delete(File file) {
if (file.isDirectory()) {
File[] children = file.listFiles();
for (File child : children) {
delete(child);
}
}
if (!file.delete()) {
if (!file.isDirectory()) {
logger.warn("Unable to clean/delete file: {}", file);
} else {
logger.debug("Unable to clean/delete directory: {}", file);
}
}
} | java |
public static <E> List<E> refineCandidates(final List<E> candidates, final Predicate<? super E> predicate) {
if (candidates.size() == 1) {
return candidates;
}
List<E> newCandidates = CollectionUtils.filter(candidates, predicate);
if (newCandidates.isEmpty()) {
return candidates;
}
return newCandidates;
} | java |
public static <K, V> Cache<K, V> createCache(int maximumSize, long expiryDurationSeconds) {
Cache<K, V> cache = CacheBuilder.newBuilder().maximumSize(maximumSize)
.expireAfterAccess(expiryDurationSeconds, TimeUnit.SECONDS).build();
return cache;
} | java |
@Deprecated
public void close(ComponentDescriptor<?> descriptor, Object component) {
close(descriptor, component, true);
} | java |
public void closeReferenceData() {
if (_referenceDataActivationManager == null) {
return;
}
final Collection<Object> referenceData = _referenceDataActivationManager.getAllReferenceData();
for (Object object : referenceData) {
ComponentDescriptor<? extends Object> descriptor = Descriptors.ofComponent(object.getClass());
close(descriptor, object, true);
}
} | java |
public void initializeReferenceData() {
if (_referenceDataActivationManager == null) {
return;
}
final Collection<Object> referenceDataCollection = _referenceDataActivationManager.getAllReferenceData();
for (Object referenceData : referenceDataCollection) {
ComponentDescriptor<? extends Object> descriptor = Descriptors.ofComponent(referenceData.getClass());
assignProvidedProperties(descriptor, referenceData);
initialize(descriptor, referenceData);
}
} | java |
@NotNull
public final String toDebugString() {
return new ToStringBuilder(this)
.append("fromEventNumber", fromEventNumber)
.append("nextEventNumber", nextEventNumber)
.append("endOfStream", endOfStream)
.append("events", events).toString();
} | java |
public static String getString(String key, String valueIfNull) {
String value = System.getProperty(key);
if (Strings.isNullOrEmpty(value)) {
return valueIfNull;
}
return value;
} | java |
public static long getLong(String key, long valueIfNullOrNotParseable) {
String value = System.getProperty(key);
if (Strings.isNullOrEmpty(value)) {
return valueIfNullOrNotParseable;
}
try {
return Long.parseLong(value);
} catch (NumberFormatException e) {
return valueIfNullOrNotParseable;
}
} | java |
public static long getInt(String key, int valueIfNullOrNotParseable) {
String value = System.getProperty(key);
if (Strings.isNullOrEmpty(value)) {
return valueIfNullOrNotParseable;
}
try {
return Integer.parseInt(value);
} catch (NumberFormatException e) {
return valueIfNullOrNotParseable;
}
} | java |
public static boolean getBoolean(String key, boolean valueIfNull) {
String value = System.getProperty(key);
if (Strings.isNullOrEmpty(value)) {
return valueIfNull;
}
value = value.trim().toLowerCase();
if ("true".equals(value)) {
return true;
} else if ("false".equals(value)) {
return false;
}
return valueIfNull;
} | java |
private void restoreData() {
Map<String, ?> map = preferenceUtils.getAll();
Set<String> strings = map.keySet();
for (String string : strings) {
if (string.startsWith(SharedPreferenceUtils.keyTestMode)) {
preferenceUtils.restoreKey(string);
}
}
refreshKeyValues();
} | java |
private ArrayList<Pair<String, ?>> getKeyValues() {
ArrayList<Pair<String, ?>> keyValPair = new ArrayList<>();
Map<String, ?> map = preferenceUtils.getAll();
Set<String> strings = map.keySet();
Object value;
for (String key : strings) {
if (!key.contains(SharedPreferenceUtils.keyTestMode)) {
value = map.get(key);
keyValPair.add(new Pair<String, Object>(key, value));
}
}
return keyValPair;
} | java |
private void storeOriginal(Pair<String, Object> keyValue) {
String key = SharedPreferenceUtils.keyTestMode + keyValue.first;
if (!preferenceUtils.isValueExistForKey(key)) {
preferenceUtils.put(key, keyValue.second);
}
} | java |
@NotNull
public final EnhancedMimeType getDataContentType() {
if (dataContentType == null) {
dataContentType = EnhancedMimeType.create(dataContentTypeStr);
}
return dataContentType;
} | java |
@Nullable
public final EnhancedMimeType getMetaContentType() {
if ((metaContentType == null) && (metaContentTypeStr != null)) {
metaContentType = EnhancedMimeType.create(metaContentTypeStr);
}
return metaContentType;
} | java |
public JsonObject toJson() {
final JsonObjectBuilder builder = Json.createObjectBuilder();
builder.add(EL_DATA_TYPE, dataType);
builder.add(EL_DATA_CONTENT_TYPE, dataContentTypeStr);
if (meta == null) {
return builder.build();
}
builder.add(EL_META_TYPE, metaType);
builder.add(EL_META_CONTENT_TYPE, metaContentTypeStr);
if (meta instanceof JsonObject) {
final JsonObject jo = (JsonObject) meta;
return builder.add(metaType, jo).build();
}
if (meta instanceof ToJsonCapable) {
final ToJsonCapable tjc = (ToJsonCapable) meta;
return builder.add(metaType, tjc.toJson()).build();
}
if (meta instanceof Base64Data) {
final Base64Data base64data = (Base64Data) meta;
return builder.add(metaType, base64data.getEncoded()).build();
}
throw new IllegalStateException("Unknown meta object type: " + meta.getClass());
} | java |
public JsonElement callRC(LsApiBody body) throws LimesurveyRCException {
try (CloseableHttpClient client = HttpClientBuilder.create().build()) {
HttpPost post = new HttpPost(url);
post.setHeader("Content-type", "application/json");
String jsonBody = gson.toJson(body);
LOGGER.debug("API CALL JSON => " + jsonBody);
post.setEntity(new StringEntity(jsonBody));
HttpResponse response = client.execute(post);
if (response.getStatusLine().getStatusCode() == 200) {
String jsonResult = EntityUtils.toString(response.getEntity());
LOGGER.debug("API RESPONSE JSON => " + jsonResult);
JsonElement result = new JsonParser().parse(jsonResult).getAsJsonObject().get("result");
if (result.isJsonObject() && result.getAsJsonObject().has("status")) {
throw new LimesurveyRCException("Error from API : " + result.getAsJsonObject().get("status").getAsString());
}
return result;
} else {
throw new LimesurveyRCException("Expecting status code 200, got " + response.getStatusLine().getStatusCode() + " instead");
}
} catch (IOException e) {
throw new LimesurveyRCException("Exception while calling API : " + e.getMessage(), e);
}
} | java |
public int createIncompleteResponse(int surveyId, String token) throws LimesurveyRCException {
LsApiBody.LsApiParams params = getParamsWithKey(surveyId);
HashMap<String, String> responseData = new HashMap<>();
responseData.put("submitdate", "");
String date = ZonedDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE) + " " + ZonedDateTime.now().format(DateTimeFormatter.ISO_LOCAL_TIME);
responseData.put("startdate", date);
responseData.put("datestamp", date);
if (StringUtils.isNotEmpty(token)) {
responseData.put("token", token);
}
params.setResponseData(responseData);
return callRC(new LsApiBody("add_response", params)).getAsInt();
} | java |
public boolean completeResponse(int surveyId, int responseId, LocalDateTime date) throws LimesurveyRCException {
Map<String, String> responseData = new HashMap<>();
responseData.put("submitdate", date.format(DateTimeFormatter.ISO_LOCAL_DATE) + " " + date.format(DateTimeFormatter.ISO_LOCAL_TIME));
JsonElement result = updateResponse(surveyId, responseId, responseData);
if (!result.getAsBoolean()) {
throw new LimesurveyRCException(result.getAsString());
}
return true;
} | java |
public JsonElement updateResponse(int surveyId, int responseId, Map<String, String> responseData) throws LimesurveyRCException {
LsApiBody.LsApiParams params = getParamsWithKey(surveyId);
responseData.put("id", String.valueOf(responseId));
params.setResponseData(responseData);
return callRC(new LsApiBody("update_response", params));
} | java |
public Stream<LsQuestion> getQuestions(int surveyId) throws LimesurveyRCException {
return getGroups(surveyId).flatMap(group -> {
try {
return getQuestionsFromGroup(surveyId, group.getId());
} catch (LimesurveyRCException e) {
LOGGER.error("Unable to get questions from group " + group.getId(), e);
}
return Stream.empty();
});
} | java |
public LsQuestion getQuestion(int surveyId, int questionId) throws LimesurveyRCException {
return getQuestions(surveyId).filter(question -> question.getId() == questionId)
.findFirst().orElseThrow(() -> new LimesurveyRCException("No question found for id " + questionId + " in survey " + surveyId));
} | java |
public Map<String, LsQuestionAnswer> getQuestionAnswers(int questionId) throws LimesurveyRCException {
LsApiBody.LsApiParams params = getParamsWithKey();
params.setQuestionId(questionId);
List<String> questionSettings = new ArrayList<>();
questionSettings.add("answeroptions");
params.setQuestionSettings(questionSettings);
JsonElement result = callRC(new LsApiBody("get_question_properties", params)).getAsJsonObject().get("answeroptions");
return gson.fromJson(result, new TypeToken<Map<String, LsQuestionAnswer>>() {
}.getType());
} | java |
public Stream<LsQuestionGroup> getGroups(int surveyId) throws LimesurveyRCException {
JsonElement result = callRC(new LsApiBody("list_groups", getParamsWithKey(surveyId)));
List<LsQuestionGroup> questionGroups = gson.fromJson(result, new TypeToken<List<LsQuestionGroup>>() {
}.getType());
return questionGroups.stream().sorted(Comparator.comparing(LsQuestionGroup::getOrder));
} | java |
public Stream<LsQuestion> getQuestionsFromGroup(int surveyId, int groupId) throws LimesurveyRCException {
LsApiBody.LsApiParams params = getParamsWithKey(surveyId);
params.setGroupId(groupId);
JsonElement result = callRC(new LsApiBody("list_questions", params));
List<LsQuestion> questions = gson.fromJson(result, new TypeToken<List<LsQuestion>>() {
}.getType());
return questions.stream().sorted(Comparator.comparing(LsQuestion::getOrder));
} | java |
public boolean isSurveyActive(int surveyId) throws LimesurveyRCException {
LsApiBody.LsApiParams params = getParamsWithKey(surveyId);
List<String> surveySettings = new ArrayList<>();
surveySettings.add("active");
params.setSurveySettings(surveySettings);
return "Y".equals(callRC(new LsApiBody("get_survey_properties", params)).getAsJsonObject().get("active").getAsString());
} | java |
public Stream<LsSurvey> getSurveys() throws LimesurveyRCException {
JsonElement result = callRC(new LsApiBody("list_surveys", getParamsWithKey()));
List<LsSurvey> surveys = gson.fromJson(result, new TypeToken<List<LsSurvey>>() {
}.getType());
return surveys.stream();
} | java |
public LsSurveyLanguage getSurveyLanguageProperties(int surveyId) throws LimesurveyRCException {
LsApiBody.LsApiParams params = getParamsWithKey(surveyId);
List<String> localeSettings = new ArrayList<>();
localeSettings.add("surveyls_welcometext");
localeSettings.add("surveyls_endtext");
params.setSurveyLocaleSettings(localeSettings);
LsSurveyLanguage surveyLanguage = gson.fromJson(callRC(new LsApiBody("get_language_properties", params)), LsSurveyLanguage.class);
surveyLanguage.setId(surveyId);
return surveyLanguage;
} | java |
public String getSessionKey() throws LimesurveyRCException {
// Use the saved key if isn't expired
if (!key.isEmpty() && ZonedDateTime.now().isBefore(keyExpiration)) {
return key;
}
// Get session key and save it with an expiration set to 1 minute before the expiration date
LsApiBody.LsApiParams params = new LsApiBody.LsApiParams();
params.setUsername(user);
params.setPassword(password);
JsonElement result = callRC(new LsApiBody("get_session_key", params));
key = result.getAsString();
keyExpiration = ZonedDateTime.now().plusSeconds(keyTimeout - 60);
return key;
} | java |
public Map<String, String> getParticipantProperties(int surveyId, String token, List<String> tokenProperties) throws LimesurveyRCException {
LsApiBody.LsApiParams params = getParamsWithKey(surveyId);
Map<String, String> queryProperties = new HashMap<>();
queryProperties.put("token", token);
params.setTokenQueryProperties(queryProperties);
params.setTokenProperties(tokenProperties);
return gson.fromJson(callRC(new LsApiBody("get_participant_properties", params)), new TypeToken<Map<String, String>>() {
}.getType());
} | java |
public Stream<LsParticipant> getAllParticipants(int surveyId) throws LimesurveyRCException {
LsApiBody.LsApiParams params = getParamsWithKey(surveyId);
params.setStart(0);
params.setLimit(-1);
List<LsParticipant> participants = gson.fromJson(callRC(new LsApiBody("list_participants", params)), new TypeToken<List<LsParticipant>>() {
}.getType());
return participants.stream();
} | java |
public static SharedPreferenceUtils initWith(SharedPreferences sharedPreferences) {
if (sharedPreferenceUtils == null) {
sharedPreferenceUtils = new SharedPreferenceUtils();
}
sharedPreferenceUtils.sharedPreferences = sharedPreferences;
return sharedPreferenceUtils;
} | java |
public static SharedPreferenceUtils initWith(Context context, String name) {
if (sharedPreferenceUtils == null) {
sharedPreferenceUtils = new SharedPreferenceUtils();
}
if (isEmptyString(name)) {
sharedPreferenceUtils.sharedPreferences = PreferenceManager.getDefaultSharedPreferences(context);
} else {
sharedPreferenceUtils.sharedPreferences = context.getSharedPreferences(name, Context.MODE_PRIVATE);
}
return sharedPreferenceUtils;
} | java |
public static int getNumber(CharSequence string) {
int number = 0;
if (!isEmptyString(string)) {
if (TextUtils.isDigitsOnly(string)) {
number = Integer.parseInt(string.toString());
}
}
return number;
} | java |
public static float getNumberFloat(CharSequence string) {
float number = 0.0f;
try {
if (!isEmptyString(string)) {
number = Float.parseFloat(string.toString());
}
} catch (NumberFormatException e) {
e.printStackTrace();
}
return number;
} | java |
public static long getNumberLong(CharSequence string) {
long number = 0l;
try {
if (!isEmptyString(string)) {
if (TextUtils.isDigitsOnly(string)) {
number = Long.parseLong(string.toString());
}
}
} catch (NumberFormatException e) {
e.printStackTrace();
}
return number;
} | java |
public void inflateDebugMenu(MenuInflater inflater, Menu menu) {
inflater.inflate(R.menu.debug, menu);
} | java |
public boolean isDebugHandled(Context context, MenuItem item) {
int id = item.getItemId();
if (id == R.id.action_debug) {
startActivity(context);
return true;
}
return false;
} | java |
public boolean isValueExistForKey(String key) {
boolean isValueExists;
try {
String string = getString(key, "");
isValueExists = !string.equalsIgnoreCase("");
} catch (ClassCastException e) {
try {
int anInt = getInt(key, 0);
isValueExists = anInt != 0;
} catch (ClassCastException e1) {
try {
long aLong = getLong(key, 0);
isValueExists = aLong != 0;
} catch (ClassCastException e2) {
try {
float aFloat = getFloat(key, 0f);
isValueExists = aFloat != 0;
} catch (ClassCastException e3) {
try {
boolean aBoolean = getBoolean(key, false);
isValueExists = !aBoolean;
} catch (Exception e4) {
isValueExists = false;
e.printStackTrace();
}
}
}
}
} catch (Exception e) {
isValueExists = false;
}
return isValueExists;
} | java |
public String getString(String key, String defaultValue) throws ClassCastException {
return sharedPreferences.getString(key, (defaultValue == null) ? "" : defaultValue);
} | java |
public void restoreKey(String key) {
if (!key.equalsIgnoreCase("test_mode_opened")) {
String originalKey = key.substring(keyTestMode.length());
Object value = get(key);
put(originalKey, value);
clear(key);
}
} | java |
public Object get(String key) {
try {
return getString(key, null);
} catch (ClassCastException e) {
try {
return getInt(key, 0);
} catch (ClassCastException e1) {
try {
return getLong(key, 0);
} catch (ClassCastException e2) {
try {
return getFloat(key, 0f);
} catch (ClassCastException e3) {
try {
return getBoolean(key, false);
} catch (Exception e4) {
e.printStackTrace();
}
}
}
}
}
return null;
} | java |
public void put(String key, Object value) {
if (value.getClass().equals(String.class)) {
putString(key, value.toString());
} else if (value.getClass().equals(Integer.class)) {
putInt(key, (Integer) value);
} else if (value.getClass().equals(Float.class)) {
putFloat(key, (Float) value);
} else if (value.getClass().equals(Long.class)) {
putLong(key, (Long) value);
} else if (value.getClass().equals(Boolean.class)) {
putBoolean(key, (Boolean) value);
} else {
putString(key, value.toString());
}
} | java |
public void putString(String key, String value) {
sharedPreferences.edit().putString(key, value).commit();
} | java |
public void putFloat(String key, float value) {
sharedPreferences.edit().putFloat(key, value).commit();
} | java |
@Override
public final EventData convert(final CommonEvent commonEvent) {
// User's data
final String dataType = commonEvent.getDataType().asBaseType();
final SerializedDataType serUserDataType = new SerializedDataType(dataType);
final Serializer userDataSerializer = serRegistry.getSerializer(serUserDataType);
final byte[] serUserData = userDataSerializer.marshal(commonEvent.getData(), serUserDataType);
final byte[] serData;
if (userDataSerializer.getMimeType().matchEncoding(targetContentType)) {
serData = serUserData;
} else {
final Base64Data base64data = new Base64Data(serUserData);
final Serializer base64Serializer = serRegistry.getSerializer(Base64Data.SER_TYPE);
serData = base64Serializer.marshal(base64data, Base64Data.SER_TYPE);
}
// EscMeta
final EscMeta escMeta = EscSpiUtils.createEscMeta(serRegistry, targetContentType, commonEvent);
final SerializedDataType escMetaType = new SerializedDataType(EscMeta.TYPE.asBaseType());
final Serializer escMetaSerializer = getSerializer(escMetaType);
final byte[] escSerMeta = escMetaSerializer.marshal(escMeta, escMetaType);
// Create event data
final EventData.Builder builder = EventData.newBuilder().eventId(commonEvent.getId().asBaseType())
.type(dataType);
if (targetContentType.isJson()) {
builder.jsonData(serData);
builder.jsonMetadata(escSerMeta);
} else {
builder.data(serData);
builder.metadata(escSerMeta);
}
return builder.build();
} | java |
public FunctionCall bindParameter(Number number) {
int pos = bindings.size();
String parameterName = function.getNthParameter(pos);
bindings.put(parameterName, number);
return this;
} | java |
public Number getParameter(String name) {
Number number = bindings.get(name);
if (number == null) {
throw new FuzzerException(function.getName() + ": undefined parameter '" + name + "'");
}
return number;
} | java |
@Initialize(distributed = false)
public void truncateIfNecesary() {
if (truncateTable) {
final UpdateableDatastoreConnection con = datastore.openConnection();
try {
final SchemaNavigator schemaNavigator = con.getSchemaNavigator();
final Table table = schemaNavigator.convertToTable(schemaName, tableName);
final UpdateableDataContext dc = con.getUpdateableDataContext();
dc.executeUpdate(new UpdateScript() {
@Override
public void run(UpdateCallback callback) {
final RowDeletionBuilder delete = callback.deleteFrom(table);
if (logger.isInfoEnabled()) {
logger.info("Executing truncating DELETE operation: {}", delete.toSql());
}
delete.execute();
}
});
} finally {
con.close();
}
}
} | java |
public RestClientResponse execute(AsyncHttpClient.BoundRequestBuilder requestBuilder) throws RestClientException {
Response response;
try {
ListenableFuture<Response> futureResponse = requestBuilder.execute();
response = futureResponse.get();
if (log.isDebugEnabled()) {
// the if is here so that we don't call the getResponseBody() when we're not going to print it
log.debug("Got response body: {}", response.getResponseBody());
}
} catch (InterruptedException e) {
throw new RestClientException("Interrupted while waiting for server response", e);
} catch (ExecutionException e) {
throw new RestClientException("Tried to retrieve result from aborted action.", e);
} catch (IOException e) {
throw new RestClientException("Encountered IOException while executing REST request.", e);
}
return new NingRestClientResponse(response);
} | java |
public void addParameter(String... paras) {
for (String parameter : paras) {
for (String knownDef : parameters) {
if (parameter.equals(knownDef)) {
throw new FuzzerException(name + ": parameter '" + parameter + "' already defined");
}
}
parameters.add(parameter);
}
} | java |
protected void appendToString(StringBuilder sb, ValueCountingAnalyzerResult groupResult, int maxEntries) {
if (maxEntries != 0) {
Collection<ValueFrequency> valueCounts = groupResult.getValueCounts();
for (ValueFrequency valueCount : valueCounts) {
sb.append("\n - ");
sb.append(valueCount.getName());
sb.append(": ");
sb.append(valueCount.getCount());
maxEntries--;
if (maxEntries == 0) {
sb.append("\n ...");
break;
}
}
}
} | java |
public static CliArguments parse(String[] args) {
CliArguments arguments = new CliArguments();
if (args != null) {
CmdLineParser parser = new CmdLineParser(arguments);
try {
parser.parseArgument(args);
} catch (CmdLineException e) {
// ignore
}
arguments.usageMode = false;
for (String arg : args) {
for (int i = 0; i < USAGE_TOKENS.length; i++) {
String usageToken = USAGE_TOKENS[i];
if (usageToken.equalsIgnoreCase(arg)) {
arguments.usageMode = true;
break;
}
}
}
}
return arguments;
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.