code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
public static void printUsage(PrintWriter out) {
CliArguments arguments = new CliArguments();
CmdLineParser parser = new CmdLineParser(arguments);
parser.setUsageWidth(120);
parser.printUsage(out, null);
} | java |
public boolean isSet() {
if (isUsageMode()) {
return true;
}
if (getJobFile() != null) {
return true;
}
if (getListType() != null) {
return true;
}
return false;
} | java |
private void writeObject(ObjectOutputStream out) throws IOException {
logger.info("Serialization requested, awaiting reference to load.");
get();
out.defaultWriteObject();
logger.info("Serialization finished!");
} | java |
public static EscEvents create(final JsonArray jsonArray) {
final List<EscEvent> events = new ArrayList<>();
for (final JsonValue jsonValue : jsonArray) {
if (jsonValue.getValueType() != JsonValue.ValueType.OBJECT) {
throw new IllegalArgumentException(
"All elements in the JSON array must be an JsonObject, but was: " + jsonValue.getValueType());
}
events.add(EscEvent.create((JsonObject) jsonValue));
}
return new EscEvents(events);
} | java |
static KAFDocument load(File file) throws IOException, JDOMException, KAFNotValidException {
SAXBuilder builder = new SAXBuilder();
Document document = (Document) builder.build(file);
Element rootElem = document.getRootElement();
return DOMToKAF(document);
} | java |
static KAFDocument load(Reader stream) throws IOException, JDOMException, KAFNotValidException {
SAXBuilder builder = new SAXBuilder();
Document document = (Document) builder.build(stream);
Element rootElem = document.getRootElement();
return DOMToKAF(document);
} | java |
static void save(KAFDocument kaf, String filename) {
try {
File file = new File(filename);
Writer out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), "UTF8"));
out.write(kafToStr(kaf));
out.flush();
} catch (Exception e) {
System.out.println("Error writing to file");
}
} | java |
static void print(KAFDocument kaf) {
try {
Writer out = new BufferedWriter(new OutputStreamWriter(System.out, "UTF8"));
out.write(kafToStr(kaf));
out.flush();
} catch (Exception e) {
System.out.println(e);
}
} | java |
static String kafToStr(KAFDocument kaf) {
XMLOutputter out = new XMLOutputter(Format.getPrettyFormat().setLineSeparator(LineSeparator.UNIX).setTextMode(Format.TextMode.TRIM_FULL_WHITE));
Document jdom = KAFToDOM(kaf);
return out.outputString(jdom);
} | java |
public Query getOptimizedQuery() {
// if (isOptimizable()) {
// return _baseQuery;
// }
// create a copy/clone of the original query
Query q = _baseQuery.clone();
Set<Entry<FilterConsumer, FilterOutcome>> entries = _optimizedFilters.entrySet();
for (Entry<FilterConsumer, FilterOutcome> entry : entries) {
FilterConsumer consumer = entry.getKey();
FilterOutcome outcome = entry.getValue();
Filter<?> filter = consumer.getComponent();
@SuppressWarnings("rawtypes")
QueryOptimizedFilter queryOptimizedFilter = (QueryOptimizedFilter) filter;
@SuppressWarnings("unchecked")
Query newQuery = queryOptimizedFilter.optimizeQuery(q, outcome.getCategory());
q = newQuery;
}
return q;
} | java |
@Override
public List<Token> tokenize(String s) {
List<Token> result = new ArrayList<Token>();
result.add(new UndefinedToken(s));
for (PredefinedTokenDefinition predefinedTokenDefinition : _predefinedTokenDefitions) {
Set<Pattern> patterns = predefinedTokenDefinition.getTokenRegexPatterns();
for (Pattern pattern : patterns) {
for (ListIterator<Token> it = result.listIterator(); it.hasNext();) {
Token token = it.next();
if (token instanceof UndefinedToken) {
List<Token> replacementTokens = tokenizeInternal(token.getString(), predefinedTokenDefinition,
pattern);
if (replacementTokens.size() > 1) {
it.remove();
for (Token newToken : replacementTokens) {
it.add(newToken);
}
}
}
}
}
}
return result;
} | java |
public void doLog(String clientID, String name, long time, Level level,
Object message, Throwable t) {
if (logOpen && formatter != null) {
sendMessage(syslogMessage.createMessageData(formatter.format(clientID, name, time, level, message, t)));
}
} | java |
public String format(String clientID, String name, long time, Level level, Object message,
Throwable t){
if (!patternParsed && pattern != null) {
parsePattern(pattern);
}
StringBuffer formattedStringBuffer = new StringBuffer(64);
if (commandArray != null) {
int length = commandArray.length;
for (int index = 0; index < length; index++) {
FormatCommandInterface currentConverter = commandArray[index];
if (currentConverter != null) {
formattedStringBuffer.append(currentConverter.execute(clientID, name, time,
level, message, t));
}
}
}
return formattedStringBuffer.toString();
} | java |
public void setPattern(String pattern) throws IllegalArgumentException{
if (pattern == null) {
throw new IllegalArgumentException("The pattern must not be null.");
}
this.pattern = pattern;
parsePattern(this.pattern);
} | java |
private void parsePattern(String pattern){
int currentIndex = 0;
int patternLength = pattern.length();
Vector<FormatCommandInterface> converterVector = new Vector<FormatCommandInterface>(20);
while (currentIndex < patternLength) {
char currentChar = pattern.charAt(currentIndex);
if (currentChar == '%') {
currentIndex++;
currentChar = pattern.charAt(currentIndex);
switch (currentChar) {
case CLIENT_ID_CONVERSION_CHAR:
converterVector.addElement(new ClientIdFormatCommand());
break;
case CATEGORY_CONVERSION_CHAR:
CategoryFormatCommand categoryFormatCommand = new CategoryFormatCommand();
String specifier = extraxtSpecifier(pattern, currentIndex);
int specifierLength = specifier.length();
if (specifierLength > 0) {
categoryFormatCommand.init(specifier);
currentIndex = currentIndex + specifierLength + 2;
}
converterVector.addElement(categoryFormatCommand);
break;
case DATE_CONVERSION_CHAR:
DateFormatCommand formatCommand = new DateFormatCommand();
specifier = extraxtSpecifier(pattern, currentIndex);
specifierLength = specifier.length();
if (specifierLength > 0) {
formatCommand.init(specifier);
currentIndex = currentIndex + specifierLength + 2;
}
converterVector.addElement(formatCommand);
break;
case MESSAGE_CONVERSION_CHAR:
converterVector.addElement(new MessageFormatCommand());
break;
case PRIORITY_CONVERSION_CHAR:
converterVector.addElement(new PriorityFormatCommand());
break;
case RELATIVE_TIME_CONVERSION_CHAR:
converterVector.addElement(new TimeFormatCommand());
break;
case THREAD_CONVERSION_CHAR:
converterVector.addElement(new ThreadFormatCommand());
break;
case THROWABLE_CONVERSION_CHAR:
converterVector.addElement(new ThrowableFormatCommand());
break;
case PERCENT_CONVERSION_CHAR:
NoFormatCommand noFormatCommand = new NoFormatCommand();
noFormatCommand.init("%");
converterVector.addElement(noFormatCommand);
break;
default:
Log.e(TAG, "Unrecognized conversion character " + currentChar);
break;
}
currentIndex++;
} else {
int percentIndex = pattern.indexOf("%", currentIndex);
String noFormatString = "";
if (percentIndex != -1) {
noFormatString = pattern.substring(currentIndex, percentIndex);
} else {
noFormatString = pattern.substring(currentIndex, patternLength);
}
NoFormatCommand noFormatCommand = new NoFormatCommand();
noFormatCommand.init(noFormatString);
converterVector.addElement(noFormatCommand);
currentIndex = currentIndex + noFormatString.length();
}
}
commandArray = new FormatCommandInterface[converterVector.size()];
converterVector.copyInto(commandArray);
patternParsed = true;
} | java |
@Beta
public static <K, V> Map<K, V> zip(List<K> keys, List<V> values) {
checkArgument(keys != null, "Expected non-null keys");
checkArgument(values != null, "Expected non-null values");
checkArgument(keys.size() == values.size(), "Expected equal size of lists, got %s and %s", keys.size(), values.size());
ImmutableMap.Builder<K, V> builder = ImmutableMap.builder();
for (int i = 0; i < keys.size(); i++) {
builder.put(keys.get(i), values.get(i));
}
return builder.build();
} | java |
@Beta
public static <K, V> Map.Entry<K, V> getOnlyEntry(Map<K, V> map) {
checkArgument(map != null, "Expected non-null map");
return getOnlyElement(map.entrySet());
} | java |
@Beta
public static <K, V> Map<K, V> mergeMaps(Map<K, V> first, Map<K, V> second, V defaultValue) {
checkArgument(first != null, "Expected non-null first map");
checkArgument(second != null, "Expected non-null second map");
checkArgument(defaultValue != null, "Expected non-null default value");
Map<K, V> map = new HashMap<K, V>();
//noinspection ConstantConditions
for (Map.Entry<K, V> entry : first.entrySet()) {
if (entry.getKey() == null) {
continue;
}
map.put(entry.getKey(), entry.getValue() == null ? defaultValue : entry.getValue());
}
//noinspection ConstantConditions
for (Map.Entry<K, V> entry : second.entrySet()) {
if (entry.getKey() == null) {
continue;
}
map.put(entry.getKey(), entry.getValue() == null ? defaultValue : entry.getValue());
}
return map;
} | java |
public static <M extends PMessage<M,F>, F extends PField, B extends PMessageBuilder<M,F>>
List<M> buildAll(Collection<B> builders) {
if (builders == null) {
return null;
}
return builders.stream()
.map(PMessageBuilder::build)
.collect(Collectors.toList());
} | java |
@SuppressWarnings("unchecked")
public static <M extends PMessage<M,F>, F extends PField, B extends PMessageBuilder<M,F>>
List<B> mutateAll(Collection<M> messages) {
if (messages == null) {
return null;
}
return (List<B>) messages.stream()
.map(PMessage::mutate)
.collect(Collectors.toList());
} | java |
public static <M extends PMessage<M,F>, F extends PField, B extends PMessageBuilder<M,F>>
M buildIfNotNull(B builder) {
if (builder == null) {
return null;
}
return builder.build();
} | java |
@SuppressWarnings("unchecked")
public static <M extends PMessage<M,F>, F extends PField, B extends PMessageBuilder<M,F>>
B mutateIfNotNull(M message) {
if (message == null) {
return null;
}
return (B) message.mutate();
} | java |
static boolean isSupported(int index) {
if ((index <= 0) || (index >= NAMED_CURVE_OID_TABLE.length)) {
return false;
}
if (fips == false) {
// in non-FIPS mode, we support all valid indices
return true;
}
return DEFAULT.contains(index);
} | java |
public static <M extends PMessage<M,F>, F extends PField>
MessageFieldArgument<M,F> toField(M message, F field) {
return new MessageFieldArgument<>(message, field);
} | java |
public static <F extends PField> MappedField<F> withColumn(F field) {
return new MappedField<>(field.getName(), field);
} | java |
public static <F extends PField> MappedField<F> withColumn(String name, F field) {
return new MappedField<>(name, field);
} | java |
@Override
public AuthenticationInfo beforeAllAttempts(Collection<? extends Realm> realms, AuthenticationToken token) throws AuthenticationException {
final SimpleAuthenticationInfo authenticationInfo = (SimpleAuthenticationInfo) super.beforeAllAttempts(realms, token);
authenticationInfo.setPrincipals(new PrincipalCollectionWithSinglePrincipalForApplicationUserInAnyRealm());
return authenticationInfo;
} | java |
protected final void set(M config) {
ArrayList<WeakReference<ConfigListener<M,F>>> iterateOver;
synchronized (this) {
M old = instance.get();
if (old == config || (old != null && old.equals(config))) {
return;
}
instance.set(config);
lastUpdateTimestamp.set(clock.millis());
listeners.removeIf(ref -> ref.get() == null);
iterateOver = new ArrayList<>(listeners);
}
iterateOver.forEach(ref -> {
ConfigListener<M,F> listener = ref.get();
if (listener != null) {
try {
listener.onConfigChange(config);
} catch (Exception ignore) {
// Ignored... TODO: At least log?
}
}
});
} | java |
private List<AgigaTypedDependency> parseDependencies(VTDNav vn, DependencyForm form) throws NavException,
PilotException {
require (vn.matchElement(AgigaConstants.SENTENCE));
// Move to the <basic-deps> tag
require (vn.toElement(VTDNav.FC, form.getXmlTag()));
List<AgigaTypedDependency> agigaDeps = new ArrayList<AgigaTypedDependency>();
// Loop through the dep tags
AutoPilot basicDepRelAp = new AutoPilot(vn);
basicDepRelAp.selectElement(AgigaConstants.DEP);
while (basicDepRelAp.iterate()) {
// Read the type, governor, and dependent
String type = vn.toString(vn.getAttrVal(AgigaConstants.DEP_TYPE));
require (vn.toElement(VTDNav.FC, AgigaConstants.GOVERNOR));
int governorId = vn.parseInt(vn.getText());
require (vn.toElement(VTDNav.NS, AgigaConstants.DEPENDENT));
int dependentId = vn.parseInt(vn.getText());
log.finer(String.format("\tdep type=%s\t%d-->%d", type, governorId, dependentId));
// Subtract one, since the tokens are one-indexed in the XML but
// zero-indexed in this API
AgigaTypedDependency agigaDep = new AgigaTypedDependency(type, governorId - 1, dependentId - 1);
agigaDeps.add(agigaDep);
}
return agigaDeps;
} | java |
public void configure(String filename, boolean isExternalFile) {
try {
Properties properties;
InputStream inputStream;
if (!isExternalFile) {
Resources resources = context.getResources();
AssetManager assetManager = resources.getAssets();
inputStream = assetManager.open(filename);
} else {
inputStream = new FileInputStream(filename);
}
properties = loadProperties(inputStream);
inputStream.close();
startConfiguration(properties);
} catch (IOException e) {
Log.e(TAG, "Failed to open file. " + filename + " " + e);
}
} | java |
public void configure(int resId) {
Resources resources = context.getResources();
try {
InputStream rawResource = resources.openRawResource(resId);
Properties properties = loadProperties(rawResource);
startConfiguration(properties);
} catch (NotFoundException e) {
Log.e(TAG, "Did not find resource." + e);
} catch (IOException e) {
Log.e(TAG, "Failed to read the resource." + e);
}
} | java |
private void startConfiguration(Properties properties) {
if (properties.containsKey(Configurator.ROOT_LOGGER_KEY)) {
Log.i(TAG, "Modern configuration not yet supported");
} else {
Log.i(TAG, "Configure using the simple style (aka classic style)");
configureSimpleStyle(properties);
}
} | java |
void setVersion(ProtocolVersion protocolVersion) {
this.protocolVersion = protocolVersion;
setVersionSE(protocolVersion);
output.r.setVersion(protocolVersion);
} | java |
void activate(ProtocolVersion helloVersion) throws IOException {
if (activeProtocols == null) {
activeProtocols = getActiveProtocols();
}
if (activeProtocols.collection().isEmpty() ||
activeProtocols.max.v == ProtocolVersion.NONE.v) {
throw new SSLHandshakeException(
"No appropriate protocol (protocol is disabled or " +
"cipher suites are inappropriate)");
}
if (activeCipherSuites == null) {
activeCipherSuites = getActiveCipherSuites();
}
if (activeCipherSuites.collection().isEmpty()) {
throw new SSLHandshakeException("No appropriate cipher suite");
}
// temporary protocol version until the actual protocol version
// is negotiated in the Hello exchange. This affects the record
// version we sent with the ClientHello.
if (!isInitialHandshake) {
protocolVersion = activeProtocolVersion;
} else {
protocolVersion = activeProtocols.max;
}
if (helloVersion == null || helloVersion.v == ProtocolVersion.NONE.v) {
helloVersion = activeProtocols.helloVersion;
}
// We accumulate digests of the handshake messages so that
// we can read/write CertificateVerify and Finished messages,
// getting assurance against some particular active attacks.
Set<String> localSupportedHashAlgorithms =
SignatureAndHashAlgorithm.getHashAlgorithmNames(
getLocalSupportedSignAlgs());
handshakeHash = new HandshakeHash(!isClient, needCertVerify,
localSupportedHashAlgorithms);
// Generate handshake input/output stream.
input = new HandshakeInStream(handshakeHash);
if (conn != null) {
output = new HandshakeOutStream(protocolVersion, helloVersion,
handshakeHash, conn);
conn.getAppInputStream().r.setHandshakeHash(handshakeHash);
conn.getAppInputStream().r.setHelloVersion(helloVersion);
conn.getAppOutputStream().r.setHelloVersion(helloVersion);
} else {
output = new HandshakeOutStream(protocolVersion, helloVersion,
handshakeHash, engine);
engine.inputRecord.setHandshakeHash(handshakeHash);
engine.inputRecord.setHelloVersion(helloVersion);
engine.outputRecord.setHelloVersion(helloVersion);
}
// move state to activated
state = -1;
} | java |
boolean isNegotiable(CipherSuite s) {
if (activeCipherSuites == null) {
activeCipherSuites = getActiveCipherSuites();
}
return activeCipherSuites.contains(s) && s.isNegotiable();
} | java |
boolean isNegotiable(ProtocolVersion protocolVersion) {
if (activeProtocols == null) {
activeProtocols = getActiveProtocols();
}
return activeProtocols.contains(protocolVersion);
} | java |
ProtocolVersion selectProtocolVersion(ProtocolVersion protocolVersion) {
if (activeProtocols == null) {
activeProtocols = getActiveProtocols();
}
return activeProtocols.selectProtocolVersion(protocolVersion);
} | java |
CipherSuiteList getActiveCipherSuites() {
if (activeCipherSuites == null) {
if (activeProtocols == null) {
activeProtocols = getActiveProtocols();
}
ArrayList<CipherSuite> suites = new ArrayList<>();
if (!(activeProtocols.collection().isEmpty()) &&
activeProtocols.min.v != ProtocolVersion.NONE.v) {
for (CipherSuite suite : enabledCipherSuites.collection()) {
if (suite.obsoleted > activeProtocols.min.v &&
suite.supported <= activeProtocols.max.v) {
if (algorithmConstraints.permits(
EnumSet.of(CryptoPrimitive.KEY_AGREEMENT),
suite.name, null)) {
suites.add(suite);
}
} else if (debug != null && Debug.isOn("verbose")) {
if (suite.obsoleted <= activeProtocols.min.v) {
System.out.println(
"Ignoring obsoleted cipher suite: " + suite);
} else {
System.out.println(
"Ignoring unsupported cipher suite: " + suite);
}
}
}
}
activeCipherSuites = new CipherSuiteList(suites);
}
return activeCipherSuites;
} | java |
CipherBox newReadCipher() throws NoSuchAlgorithmException {
BulkCipher cipher = cipherSuite.cipher;
CipherBox box;
if (isClient) {
box = cipher.newCipher(protocolVersion, svrWriteKey, svrWriteIV,
sslContext.getSecureRandom(), false);
svrWriteKey = null;
svrWriteIV = null;
} else {
box = cipher.newCipher(protocolVersion, clntWriteKey, clntWriteIV,
sslContext.getSecureRandom(), false);
clntWriteKey = null;
clntWriteIV = null;
}
return box;
} | java |
MAC newReadMAC() throws NoSuchAlgorithmException, InvalidKeyException {
MacAlg macAlg = cipherSuite.macAlg;
MAC mac;
if (isClient) {
mac = macAlg.newMac(protocolVersion, svrMacSecret);
svrMacSecret = null;
} else {
mac = macAlg.newMac(protocolVersion, clntMacSecret);
clntMacSecret = null;
}
return mac;
} | java |
static void throwSSLException(String msg, Throwable cause)
throws SSLException {
SSLException e = new SSLException(msg);
e.initCause(cause);
throw e;
} | java |
static Object getInMessage(PMessage message, String key) throws ProvidenceConfigException {
return getInMessage(message, key, null);
} | java |
static Object getInMessage(PMessage message, final String key, Object defValue)
throws ProvidenceConfigException {
String sub = key;
String name;
PMessageDescriptor descriptor = message.descriptor();
while (sub.contains(".")) {
int idx = sub.indexOf(".");
name = sub.substring(0, idx);
sub = sub.substring(idx + 1);
PField field = descriptor.findFieldByName(name);
if (field == null) {
throw new ProvidenceConfigException("Message " + descriptor.getQualifiedName() + " has no field named " + name);
}
PDescriptor fieldDesc = field.getDescriptor();
if (fieldDesc.getType() != PType.MESSAGE) {
throw new ProvidenceConfigException("Field '" + name + "' is not of message type in " + descriptor.getQualifiedName());
}
descriptor = (PMessageDescriptor) fieldDesc;
if (message != null) {
message = (PMessage) message.get(field.getId());
}
}
PField field = descriptor.findFieldByName(sub);
if (field == null) {
throw new ProvidenceConfigException("Message " + descriptor.getQualifiedName() + " has no field named " + sub);
}
if (message == null || !message.has(field.getId())) {
return asType(field.getDescriptor(), defValue);
}
return message.get(field.getId());
} | java |
static double asDouble(Object value) throws ProvidenceConfigException {
if (value instanceof Number) {
return ((Number) value).doubleValue();
} else if (value instanceof Numeric) {
return ((Numeric) value).asInteger();
}
throw new ProvidenceConfigException(
"Unable to convert " + value.getClass().getSimpleName() + " to a double");
} | java |
static String asString(Object value) throws ProvidenceConfigException {
if (value instanceof Collection || value instanceof Map) {
throw new ProvidenceConfigException(
"Unable to convert " + value.getClass().getSimpleName() + " to a string");
} else if (value instanceof Stringable) {
return ((Stringable) value).asString();
} else if (value instanceof Date) {
Instant instant = ((Date) value).toInstant();
return DateTimeFormatter.ISO_INSTANT.format(instant);
}
return Objects.toString(value);
} | java |
static Path resolveFile(Path reference, String path) throws IOException {
if (reference == null) {
Path file = canonicalFileLocation(Paths.get(path));
if (Files.exists(file)) {
if (Files.isRegularFile(file)) {
return file;
}
throw new FileNotFoundException(path + " is a directory, expected file");
}
throw new FileNotFoundException("File " + path + " not found");
} else if (path.startsWith("/")) {
throw new FileNotFoundException("Absolute path includes not allowed: " + path);
} else {
// Referenced files are referenced from the real file,
// not from symlink location, in case of sym-linked files.
// this way include references are always consistent, but
// files can be referenced via symlinks if needed.
reference = readCanonicalPath(reference);
if (!Files.isDirectory(reference)) {
reference = reference.getParent();
}
Path file = canonicalFileLocation(reference.resolve(path));
if (Files.exists(file)) {
if (Files.isRegularFile(file)) {
return file;
}
throw new FileNotFoundException(path + " is a directory, expected file");
}
throw new FileNotFoundException("Included file " + path + " not found");
}
} | java |
public static int getNextAvailablePort(int fromPort, int toPort) {
if (fromPort < MIN_PORT_NUMBER || toPort > MAX_PORT_NUMBER || fromPort > toPort) {
throw new IllegalArgumentException(format("Invalid port range: %d ~ %d", fromPort, toPort));
}
int nextPort = fromPort;
//noinspection StatementWithEmptyBody
while (!isPortAvailable(nextPort++)) { /* Empty */ }
return nextPort;
} | java |
public static boolean isPortAvailable(int port) {
StringBuilder builder = new StringBuilder();
builder.append("Testing port ").append(port).append("\n");
try (Socket s = new Socket("localhost", port)) {
// If the code makes it this far without an exception it means
// something is using the port and has responded.
builder.append("Port ").append(port).append(" is not available").append("\n");
return false;
} catch (IOException e) {
builder.append("Port ").append(port).append(" is available").append("\n");
return true;
} finally {
log.fine(builder.toString());
}
} | java |
@Nonnull
public Collection<F> presentFields() {
return Arrays.stream(descriptor().getFields())
.filter(this::isSet)
.collect(Collectors.toList());
} | java |
@Nonnull
public Collection<F> modifiedFields() {
return Arrays.stream(descriptor().getFields())
.filter(this::isModified)
.collect(Collectors.toList());
} | java |
public static <T extends Enum<T> & RichEnum<T>> RichEnumConstants<T> richConstants(Class<T> theClass) {
return new RichEnumConstants<>(theClass);
} | java |
@JsonAnySetter
public void putConfigurationValue(String key, Object value) {
this.configuration.put(key, value);
} | java |
@javax.annotation.Nonnull
public java.util.Optional<String> optionalFilePath() {
return java.util.Optional.ofNullable(mFilePath);
} | java |
@javax.annotation.Nonnull
public java.util.Optional<java.util.List<String>> optionalFileLines() {
return java.util.Optional.ofNullable(mFileLines);
} | java |
@javax.annotation.Nonnull
public java.util.Optional<net.morimekta.providence.model.ProgramType> optionalProgram() {
return java.util.Optional.ofNullable(mProgram);
} | java |
@Nonnull
public ProgramTypeRegistry registryForPath(String path) {
return registryMap.computeIfAbsent(path, p -> new ProgramTypeRegistry(programNameFromPath(path)));
} | java |
public boolean containsProgramPath(String path) {
return registryMap.containsKey(path) && registryMap.get(path).getProgram() != null;
} | java |
public void completeFrame() throws IOException {
int frameSize = buffer.position();
if (frameSize > 0) {
frameSizeBuffer.rewind();
try (ByteBufferOutputStream bos = new ByteBufferOutputStream(frameSizeBuffer);
BinaryWriter writer = new BigEndianBinaryWriter(bos)) {
writer.writeInt(frameSize);
bos.flush();
}
frameSizeBuffer.flip();
buffer.flip();
synchronized (out) {
out.write(frameSizeBuffer);
while (buffer.hasRemaining()) {
out.write(buffer);
}
}
buffer.rewind();
buffer.limit(buffer.capacity());
}
} | java |
public synchronized void put(ApnsConnection connection) {
if (connection == null) {
throw new IllegalArgumentException("connection must not be null");
}
if (mPool.size() < mCapacity) {
mPool.add(connection);
}
} | java |
public static HashCode newHash(String input, HashFunction function) {
return function.hashString(input, Charsets.UTF_8);
} | java |
private static boolean equalsQualifiedName(PDescriptor a, PDescriptor b) {
return (a != null) && (b != null) && (a.getQualifiedName()
.equals(b.getQualifiedName()));
} | java |
private boolean setupPrivateKeyAndChain(String algorithm) {
X509ExtendedKeyManager km = sslContext.getX509KeyManager();
String alias;
if (conn != null) {
alias = km.chooseServerAlias(algorithm, null, conn);
} else {
alias = km.chooseEngineServerAlias(algorithm, null, engine);
}
if (alias == null) {
return false;
}
PrivateKey tempPrivateKey = km.getPrivateKey(alias);
if (tempPrivateKey == null) {
return false;
}
X509Certificate[] tempCerts = km.getCertificateChain(alias);
if ((tempCerts == null) || (tempCerts.length == 0)) {
return false;
}
String keyAlgorithm = algorithm.split("_")[0];
PublicKey publicKey = tempCerts[0].getPublicKey();
if ((tempPrivateKey.getAlgorithm().equals(keyAlgorithm) == false)
|| (publicKey.getAlgorithm().equals(keyAlgorithm) == false)) {
return false;
}
// For ECC certs, check whether we support the EC domain parameters.
// If the client sent a SupportedEllipticCurves ClientHello extension,
// check against that too.
if (keyAlgorithm.equals("EC")) {
if (publicKey instanceof ECPublicKey == false) {
return false;
}
ECParameterSpec params = ((ECPublicKey)publicKey).getParams();
int index = SupportedEllipticCurvesExtension.getCurveIndex(params);
if (SupportedEllipticCurvesExtension.isSupported(index) == false) {
return false;
}
if ((supportedCurves != null) && !supportedCurves.contains(index)) {
return false;
}
}
this.privateKey = tempPrivateKey;
this.certs = tempCerts;
return true;
} | java |
private boolean setupKerberosKeys() {
if (kerberosKeys != null) {
return true;
}
try {
final AccessControlContext acc = getAccSE();
kerberosKeys = AccessController.doPrivileged(
// Eliminate dependency on KerberosKey
new PrivilegedExceptionAction<SecretKey[]>() {
public SecretKey[] run() throws Exception {
// get kerberos key for the default principal
return Krb5Helper.getServerKeys(acc);
}});
// check permission to access and use the secret key of the
// Kerberized "host" service
if (kerberosKeys != null && kerberosKeys.length > 0) {
if (debug != null && Debug.isOn("handshake")) {
for (SecretKey k: kerberosKeys) {
System.out.println("Using Kerberos key: " +
k);
}
}
String serverPrincipal =
Krb5Helper.getServerPrincipalName(kerberosKeys[0]);
SecurityManager sm = System.getSecurityManager();
try {
if (sm != null) {
// Eliminate dependency on ServicePermission
sm.checkPermission(Krb5Helper.getServicePermission(
serverPrincipal, "accept"), acc);
}
} catch (SecurityException se) {
kerberosKeys = null;
// %%% destroy keys? or will that affect Subject?
if (debug != null && Debug.isOn("handshake"))
System.out.println("Permission to access Kerberos"
+ " secret key denied");
return false;
}
}
return (kerberosKeys != null && kerberosKeys.length > 0);
} catch (PrivilegedActionException e) {
// Likely exception here is LoginExceptin
if (debug != null && Debug.isOn("handshake")) {
System.out.println("Attempt to obtain Kerberos key failed: "
+ e.toString());
}
return false;
}
} | java |
@Programmatic
public boolean implies(final ApplicationFeatureId featureId, final ApplicationPermissionMode mode) {
if(getRule() != ApplicationPermissionRule.ALLOW) {
// only allow rules can imply
return false;
}
if(getMode() == ApplicationPermissionMode.VIEWING && mode == ApplicationPermissionMode.CHANGING) {
// an "allow viewing" permission does not imply ability to change
return false;
}
// determine if this permission is on the path (ie the feature or one of its parents)
return onPathOf(featureId);
} | java |
public static PPrimitive findByName(String name) {
switch (name) {
case "void":
return VOID;
case "bool":
return BOOL;
case "byte":
case "i8":
return BYTE;
case "i16":
return I16;
case "i32":
return I32;
case "i64":
return I64;
case "double":
return DOUBLE;
case "string":
return STRING;
case "binary":
return BINARY;
}
return null;
} | java |
public String execute(String clientID, String name, long time, Level level,
Object message, Throwable throwable){
StringBuilder sb = new StringBuilder();
if (throwable != null) {
sb.append(throwable.toString());
String newline = System.getProperty("line.separator");
StackTraceElement[] stackTrace = throwable.getStackTrace();
for (int i = 0; i < stackTrace.length; i++) {
StackTraceElement element = stackTrace[i];
sb.append(newline);
sb.append("\tat ");
sb.append(element.toString());
}
}
return sb.toString();
} | java |
public String createMessageData(String message) {
messageStringBuffer.delete(0, messageStringBuffer.length());
// Create the PRI part
messageStringBuffer.append('<');
int priority = facility * 8 + severity;
messageStringBuffer.append(priority);
messageStringBuffer.append('>');
// Create the HEADER part.
if (header) {
// Add the TIMESTAMP field of the HEADER
// Time format is "Mmm dd hh:mm:ss". For more info see rfc3164.
long currentTime = System.currentTimeMillis();
calendar.setTime(new Date(currentTime));
messageStringBuffer.append(SyslogMessage.MONTHS[calendar
.get(Calendar.MONTH)]);
messageStringBuffer.append(' ');
int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH);
if (dayOfMonth < SyslogMessage.TEN) {
messageStringBuffer.append('0');
}
messageStringBuffer.append(dayOfMonth);
messageStringBuffer.append(' ');
int hour = calendar.get(Calendar.HOUR_OF_DAY);
if (hour < SyslogMessage.TEN) {
messageStringBuffer.append('0');
}
messageStringBuffer.append(hour);
messageStringBuffer.append(':');
int minute = calendar.get(Calendar.MINUTE);
if (minute < SyslogMessage.TEN) {
messageStringBuffer.append('0');
}
messageStringBuffer.append(minute);
messageStringBuffer.append(':');
int second = calendar.get(Calendar.SECOND);
if (second < SyslogMessage.TEN) {
messageStringBuffer.append('0');
}
messageStringBuffer.append(second);
messageStringBuffer.append(' ');
// Add the HOSTNAME part of the message
messageStringBuffer.append(hostname);
}
// Create the MSG part.
messageStringBuffer.append(' ');
messageStringBuffer.append(tag);
messageStringBuffer.append(": ");
messageStringBuffer.append(message);
return messageStringBuffer.toString();
} | java |
public void setFacility(byte facility) {
if (facility < SyslogMessage.FACILITY_KERNAL_MESSAGE
|| facility > SyslogMessage.FACILITY_LOCAL_USE_7) {
throw new IllegalArgumentException("Not a valid facility.");
}
this.facility = facility;
} | java |
public void setSeverity(byte severity) throws IllegalArgumentException {
if (severity < SyslogMessage.SEVERITY_EMERGENCY
|| severity > SyslogMessage.SEVERITY_DEBUG) {
throw new IllegalArgumentException("Not a valid severity.");
}
this.severity = severity;
} | java |
public void setTag(String tag) throws IllegalArgumentException {
if (tag == null
|| (tag != null && (tag.length() < 1 || tag.length() > 32))) {
throw new IllegalArgumentException(
"The tag must not be null, the length between 1..32");
}
this.tag = tag;
} | java |
public static Properties getFileAsProperties(String path) {
File file = new File(nullToEmpty(path));
return getFileAsProperties(file);
} | java |
@javax.annotation.Nonnull
public java.util.Optional<net.morimekta.util.Binary> optionalData() {
return java.util.Optional.ofNullable(mData);
} | java |
private void reload() {
try {
if (!configFile.exists()) {
LOGGER.warn("Config file deleted " + configFile + ", keeping old config.");
return;
}
LOGGER.trace("Config reload triggered for " + configFile);
if (parentSupplier != null) {
set(loadConfig(parentSupplier.get()));
} else {
set(loadConfig(null));
}
} catch (ProvidenceConfigException e) {
LOGGER.error("Exception when reloading " + configFile, e);
}
} | java |
public static <Message extends PMessage<Message, Field>, Field extends PField>
Message readMessage(BigEndianBinaryReader input,
PMessageDescriptor<Message, Field> descriptor,
boolean strict) throws IOException {
PMessageBuilder<Message, Field> builder = descriptor.builder();
if (builder instanceof BinaryReader) {
((BinaryReader) builder).readBinary(input, strict);
} else {
FieldInfo fieldInfo = readFieldInfo(input);
while (fieldInfo != null) {
PField field = descriptor.findFieldById(fieldInfo.getId());
if (field != null) {
Object value = readFieldValue(input, fieldInfo, field.getDescriptor(), strict);
builder.set(field.getId(), value);
} else {
readFieldValue(input, fieldInfo, null, false);
}
fieldInfo = readFieldInfo(input);
}
if (strict) {
try {
builder.validate();
} catch (IllegalStateException e) {
throw new SerializerException(e, e.getMessage());
}
}
}
return builder.build();
} | java |
public static void consumeMessage(BigEndianBinaryReader in) throws IOException {
FieldInfo fieldInfo;
while ((fieldInfo = readFieldInfo(in)) != null) {
readFieldValue(in, fieldInfo, null, false);
}
} | java |
public static <Message extends PMessage<Message, Field>, Field extends PField>
int writeMessage(BigEndianBinaryWriter writer, Message message)
throws IOException {
if (message instanceof BinaryWriter) {
return ((BinaryWriter) message).writeBinary(writer);
}
int len = 0;
if (message instanceof PUnion) {
if (((PUnion) message).unionFieldIsSet()) {
PField field = ((PUnion) message).unionField();
len += writeFieldSpec(writer, forType(field.getDescriptor().getType()), field.getId());
len += writeFieldValue(writer,
message.get(field.getId()),
field.getDescriptor());
}
} else {
for (PField field : message.descriptor().getFields()) {
if (message.has(field.getId())) {
len += writeFieldSpec(writer, forType(field.getDescriptor().getType()), field.getId());
len += writeFieldValue(writer,
message.get(field.getId()),
field.getDescriptor());
}
}
}
len += writer.writeUInt8(BinaryType.STOP);
return len;
} | java |
protected void register(Serializer serializer, String... mediaTypes) {
for (String mediaType : mediaTypes) {
this.serializerMap.put(mediaType, serializer);
}
} | java |
public String getContentLocation() {
String[] values = getMimeHeader("Content-Location");
if (values != null && values.length > 0)
return values[0];
return null;
} | java |
public String readBinary(char end) throws IOException {
int startOffset = bufferOffset;
int startLinePos = linePos;
CharArrayWriter baos = new CharArrayWriter();
while (readNextChar()) {
if (lastChar == end) {
lastChar = 0;
return baos.toString();
} else if (lastChar == ' ' || lastChar == '\t' || lastChar == '\r' || lastChar == '\n') {
throw failure(getLineNo(), startLinePos, startOffset, "Illegal char '%s' in binary", Strings.escape((char) lastChar));
}
baos.write(lastChar);
}
throw eof("Unexpected end of file in binary");
} | java |
public static ApplicationFeatureViewModel newViewModel(
final ApplicationFeatureId featureId,
final ApplicationFeatureRepositoryDefault applicationFeatureRepository,
final DomainObjectContainer container) {
final Class<? extends ApplicationFeatureViewModel> cls = viewModelClassFor(featureId, applicationFeatureRepository);
if(cls == null) {
// TODO: not sure why, yet...
return null;
}
return container.newViewModelInstance(cls, featureId.asEncodedString());
} | java |
@Property(
domainEvent = MemberNameDomainEvent.class
)
@PropertyLayout(typicalLength=ApplicationFeature.TYPICAL_LENGTH_MEMBER_NAME)
@MemberOrder(name="Id", sequence = "2.4")
public String getMemberName() {
return getFeatureId().getMemberName();
} | java |
@Programmatic
public ApplicationFeatureViewModel getParentPackage() {
return Functions.asViewModelForId(applicationFeatureRepository, container).apply(getFeatureId().getParentPackageId());
} | java |
@Programmatic
public ApplicationUser findByUsernameCached(final String username) {
return queryResultsCache.execute(new Callable<ApplicationUser>() {
@Override public ApplicationUser call() throws Exception {
return findByUsername(username);
}
}, ApplicationUserRepository.class, "findByUsernameCached", username);
} | java |
@Programmatic
public List<ApplicationUser> findByAtPath(final String atPath) {
return container.allMatches(new QueryDefault<>(
ApplicationUser.class,
"findByAtPath", "atPath", atPath));
} | java |
@SuppressWarnings("unchecked")
private static <V> V resolve(ProvidenceConfigContext context,
Token token,
Tokenizer tokenizer,
PDescriptor descriptor) throws TokenizerException {
Object value = resolveAny(context, token, tokenizer);
if (value == null) {
return null;
}
return (V) asType(descriptor, value);
} | java |
public static ClassLoader getContextClassLoader(Class<?> contextClass) {
return Objects.firstNonNull(
Thread.currentThread().getContextClassLoader(),
contextClass.getClassLoader()
);
} | java |
public static String buildPath(String first, String... parts) {
StringBuilder result = new StringBuilder(first);
for (String part : parts) {
if (result.length() == 0) {
if (part.startsWith("/")) {
result.append(part.substring(1));
} else {
result.append(part);
}
} else {
if (result.toString().endsWith("/") && part.startsWith("/")) {
result.append(part.substring(1));
} else if (!result.toString().endsWith("/") && !part.startsWith("/") && !part.isEmpty()) {
result.append("/").append(part);
} else {
result.append(part);
}
}
}
return result.toString();
} | java |
private TokenType lexUtf8Char(Bytes jsonText, int curChar) {
if (curChar <= 0x7f) {
/* single byte */
return STRING;
} else if ((curChar >> 5) == 0x6) {
/* two byte */
if (jsonText.readRemaining() == 0) return EOF;
curChar = readChar(jsonText);
if ((curChar >> 6) == 0x2) return STRING;
} else if ((curChar >> 4) == 0x0e) {
/* three byte */
if (jsonText.readRemaining() == 0) return EOF;
curChar = readChar(jsonText);
if ((curChar >> 6) == 0x2) {
if (jsonText.readRemaining() == 0) return EOF;
curChar = readChar(jsonText);
if ((curChar >> 6) == 0x2) return STRING;
}
} else if ((curChar >> 3) == 0x1e) {
/* four byte */
if (jsonText.readRemaining() == 0) return EOF;
curChar = readChar(jsonText);
if ((curChar >> 6) == 0x2) {
if (jsonText.readRemaining() == 0) return EOF;
curChar = readChar(jsonText);
if ((curChar >> 6) == 0x2) {
if (jsonText.readRemaining() == 0) return EOF;
curChar = readChar(jsonText);
if ((curChar >> 6) == 0x2) return STRING;
}
}
}
return ERROR;
} | java |
private TokenType lexString(Bytes jsonText) {
TokenType tok = ERROR;
boolean hasEscapes = false;
finish_string_lex:
for (;;) {
int curChar;
/* now jump into a faster scanning routine to skip as much
* of the buffers as possible */
{
if (bufInUse && buf.readRemaining() > 0) {
stringScan(buf);
} else if (jsonText.readRemaining() > 0) {
stringScan(jsonText);
}
}
if (jsonText.readRemaining() == 0) {
tok = EOF;
break;
}
curChar = readChar(jsonText);
/* quote terminates */
if (curChar == '"') {
tok = STRING;
break;
}
/* backslash escapes a set of control chars, */
else if (curChar == '\\') {
hasEscapes = true;
if (jsonText.readRemaining() == 0) {
tok = EOF;
break;
}
/* special case \\u */
curChar = readChar(jsonText);
if (curChar == 'u') {
for (int i = 0; i < 4; i++) {
if (jsonText.readRemaining() == 0) {
tok = EOF;
break finish_string_lex;
}
curChar = readChar(jsonText);
if ((CHAR_LOOKUP_TABLE[curChar] & VHC) == 0) {
/* back up to offending char */
unreadChar(jsonText);
error = STRING_INVALID_HEX_CHAR;
break finish_string_lex;
}
}
} else if ((CHAR_LOOKUP_TABLE[curChar] & VEC) == 0) {
/* back up to offending char */
unreadChar(jsonText);
error = STRING_INVALID_ESCAPED_CHAR;
break;
}
}
/* when not validating UTF8 it's a simple table lookup to determine
* if the present character is invalid */
else if((CHAR_LOOKUP_TABLE[curChar] & IJC) != 0) {
/* back up to offending char */
unreadChar(jsonText);
error = STRING_INVALID_JSON_CHAR;
break;
}
/* when in validate UTF8 mode we need to do some extra work */
else if (validateUTF8) {
TokenType t = lexUtf8Char(jsonText, curChar);
if (t == EOF) {
tok = EOF;
break;
} else if (t == ERROR) {
error = STRING_INVALID_UTF8;
break;
}
}
/* accept it, and move on */
}
/* tell our buddy, the parser, whether he needs to process this string again */
if (hasEscapes && tok == STRING) {
tok = STRING_WITH_ESCAPES;
}
return tok;
} | java |
@Beta
public static <T> Predicate<T> nor(Predicate<? super T> first, Predicate<? super T> second) {
return com.google.common.base.Predicates.not(com.google.common.base.Predicates.or(first, second));
} | java |
public JsonParserBuilder options(JsonParserOption first, JsonParserOption... rest) {
this.options = EnumSet.of(first, rest);
return this;
} | java |
public JsonParserBuilder applyAdapter(JsonHandlerBase a) {
boolean applied = false;
if (a instanceof ObjectStartHandler) {
objectStartHandler((ObjectStartHandler) a);
applied = true;
}
if (a instanceof ObjectEndHandler) {
objectEndHandler((ObjectEndHandler) a);
applied = true;
}
if (a instanceof ArrayStartHandler) {
arrayStartHandler((ArrayStartHandler) a);
applied = true;
}
if (a instanceof ArrayEndHandler) {
arrayEndHandler((ArrayEndHandler) a);
applied = true;
}
if (a instanceof BooleanHandler) {
booleanHandler((BooleanHandler) a);
applied = true;
}
if (a instanceof NullHandler) {
nullHandler((NullHandler) a);
applied = true;
}
if (a instanceof StringValueHandler) {
stringValueHandler((StringValueHandler) a);
applied = true;
}
if (a instanceof ObjectKeyHandler) {
objectKeyHandler((ObjectKeyHandler) a);
applied = true;
}
if (a instanceof NumberHandler) {
numberHandler((NumberHandler) a);
applied = true;
}
if (a instanceof IntegerHandler) {
integerHandler((IntegerHandler) a);
applied = true;
}
if (a instanceof FloatingHandler) {
floatingHandler((FloatingHandler) a);
applied = true;
}
if (a instanceof ResetHook) {
resetHook((ResetHook) a);
applied = true;
}
if (!applied)
throw new IllegalArgumentException(a + " isn't an instance of any handler interface");
return this;
} | java |
public static String camelCase(String prefix, String name) {
return Strings.camelCase(prefix, name);
} | java |
public static String macroCase(String name) {
return Strings.c_case(name).toUpperCase(Locale.US);
} | java |
public static void ensure(boolean condition, String message, Object... args) {
if (!condition) {
throw new EnsureViolation(format(message, args));
}
} | java |
public void reset() {
lexer.reset();
stateStack.clear();
stateStack.push(START);
parseError = null;
if (resetHook != null)
resetHook.onReset();
} | java |
public boolean finish() {
if (!parse(finishSpace())) return false;
switch(stateStack.current()) {
case PARSE_ERROR:
case LEXICAL_ERROR:
case HANDLER_CANCEL:
case HANDLER_EXCEPTION:
throw new AssertionError("exception should be thrown directly from parse()");
case GOT_VALUE:
case PARSE_COMPLETE:
return true;
default:
return flags.contains(ALLOW_PARTIAL_VALUES) || parseError("premature EOF");
}
} | java |
public static String asString(byte id) {
switch (id) {
case STOP:
return "stop(0)";
case VOID:
return "void(1)";
case BOOL:
return "bool(2)";
case BYTE:
return "byte(3)";
case DOUBLE:
return "double(4)";
// case 5:
case I16:
return "i16(6)";
// case 7:
case I32:
// ENUM is same as I32.
return "i32(8)";
// case 9:
case I64:
return "i64(10)";
case STRING:
// BINARY is same as STRING.
return "string(11)";
case STRUCT:
return "struct(12)";
case MAP:
return "map(13)";
case SET:
return "set(14)";
case LIST:
return "list(15)";
default:
return "unknown(" + id + ")";
}
} | java |
public MediaItem getMediaItem(String id) {
DailyMotionUrl url = new DailyMotionUrl(requestPrefix + id);
HttpRequest request;
try {
request = requestFactory.buildGetRequest(url);
DailyMotionVideo video = request.execute().parseAs(DailyMotionVideo.class);
if(video != null) {
MediaItem mediaItem = new DailyMotionMediaItem(video);
return mediaItem;
}
} catch (Exception e) {
}
return null;
} | java |
String toAbsoluteFormat(long time){
calendar.setTime(new Date(time));
long hours = calendar.get(Calendar.HOUR_OF_DAY);
StringBuffer buffer = new StringBuffer();
if (hours < 10) {
buffer.append('0');
}
buffer.append(hours);
buffer.append(':');
long minutes = calendar.get(Calendar.MINUTE);
if (minutes < 10) {
buffer.append('0');
}
buffer.append(minutes);
buffer.append(':');
long seconds = calendar.get(Calendar.SECOND);
if (seconds < 10) {
buffer.append('0');
}
buffer.append(seconds);
buffer.append(',');
long milliseconds = calendar.get(Calendar.MILLISECOND);
if (milliseconds < 10) {
buffer.append('0');
}
buffer.append(milliseconds);
return buffer.toString();
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.