code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
public static UserPermissionViewModel newViewModel(
final ApplicationFeatureId featureId, final ApplicationUser user, final ApplicationPermissionValueSet.Evaluation viewingEvaluation, final ApplicationPermissionValueSet.Evaluation changingEvaluation, final DomainObjectContainer container) {
return container.newViewModelInstance(UserPermissionViewModel.class, asEncodedString(featureId, user.getUsername(), viewingEvaluation, changingEvaluation));
} | java |
private List<AgigaCoref> parseCorefs(VTDNav vn) throws PilotException, NavException {
require (vn.matchElement(AgigaConstants.DOC));
List<AgigaCoref> agigaCorefs = new ArrayList<AgigaCoref>();
if (!vn.toElement(VTDNav.FIRST_CHILD, AgigaConstants.COREFERENCES)) {
// If there is no coref annotation return the empty list
log.finer("No corefs found");
return agigaCorefs;
}
// Loop through each token
AutoPilot corefAp = new AutoPilot(vn);
corefAp.selectElement(AgigaConstants.COREFERENCE);
while (corefAp.iterate()) {
AgigaCoref coref = parseCoref(vn.cloneNav());
agigaCorefs.add(coref);
}
return agigaCorefs;
} | java |
private String parseHeadline(VTDNav vn) throws NavException {
require (vn.matchElement(AgigaConstants.DOC));
if (!vn.toElement(VTDNav.FIRST_CHILD, AgigaConstants.HEADLINE) || vn.getText() == -1) {
// If there is no headline annotation return the empty list
log.finer("No headline found");
return null;
}
return vn.toString(vn.getText()).trim();
} | java |
public Level getEffectiveLevel() {
Level effectiveLevel = level;
if (effectiveLevel == null && !name.equals("")) {
if (commonLoggerRepository == null) {
throw new IllegalStateException("CommonLoggerRepository has not been set");
} else {
effectiveLevel = commonLoggerRepository.getEffectiveLevel(name);
}
}
return effectiveLevel;
} | java |
public void setClientID(String clientID) {
if (clientID == null || clientID.isEmpty()) {
this.clientID = DEFAULT_CLIENT_ID;
return;
}
this.clientID = clientID;
} | java |
synchronized public void addAppender(Appender appender) throws IllegalArgumentException {
if (appender == null) {
throw new IllegalArgumentException("Appender not allowed to be null");
}
for (Appender p : appenderList) {
if (p.getClass() == appender.getClass())
return;
}
appenderList.add(appender);
} | java |
public void removeAppender(Appender appender) throws IllegalArgumentException {
if (appender == null) {
throw new IllegalArgumentException("The appender must not be null.");
}
if (appender.isLogOpen()) {
try {
appender.close();
} catch (IOException e) {
Log.e(TAG, "Failed to close appender. " + e);
}
}
appenderList.remove(appender);
} | java |
public void removeAllAppenders() {
ListIterator<Appender> ite = appenderList.listIterator();
while (ite.hasNext()) {
Appender appender = ite.next();
if (appender != null && appender.isLogOpen()) {
try {
appender.close();
} catch (IOException e) {
Log.e(TAG, "Failed to close appender. " + e);
}
}
}
appenderList.clear();
} | java |
public Appender getAppender(int index) {
if (index < 0 || index >= appenderList.size())
return null;
return appenderList.get(index);
} | java |
public void log(Level level, Object message) throws IllegalArgumentException {
log(level, message, null);
} | java |
public void log(Level level, Object message, Throwable t) throws IllegalArgumentException {
if (level == null) {
throw new IllegalArgumentException("The level must not be null.");
}
if (getEffectiveLevel().toInt() <= level.toInt() && level.toInt() > Level.OFF_INT) {
if (firstLogEvent == true) {
addDefaultAppender();
try {
open();
} catch (IOException e) {
Log.e(TAG, "Failed to open the log. " + e);
}
stopWatch.start();
firstLogEvent = false;
}
ListIterator<Appender> ite = appenderList.listIterator();
while (ite.hasNext()) {
Appender appender = ite.next();
if (appender != null)
appender.doLog(clientID, name, stopWatch.getCurrentTime(), level, message, t);
}
}
} | java |
public synchronized void resetLogger() {
Logger.appenderList.clear();
Logger.stopWatch.stop();
Logger.stopWatch.reset();
Logger.firstLogEvent = true;
} | java |
void open() throws IOException {
ListIterator<Appender> ite = appenderList.listIterator();
while (ite.hasNext()) {
Appender p = ite.next();
if (p != null) p.open();
}
} | java |
public void close() throws IOException {
ListIterator<Appender> ite = appenderList.listIterator();
while (ite.hasNext()) {
Appender p = ite.next();
if (p != null)
p.close();
}
stopWatch.stop();
Logger.firstLogEvent = true;
} | java |
private void init(SSLContextImpl ctx) {
if (debug != null && Debug.isOn("ssl")) {
System.out.println("Using SSLEngineImpl.");
}
sslContext = ctx;
sess = SSLSessionImpl.nullSession;
handshakeSession = null;
/*
* State is cs_START until we initialize the handshaker.
*
* Apps using SSLEngine are probably going to be server.
* Somewhat arbitrary choice.
*/
roleIsServer = true;
connectionState = cs_START;
receivedCCS = false;
/*
* default read and write side cipher and MAC support
*
* Note: compression support would go here too
*/
readCipher = CipherBox.NULL;
readMAC = MAC.NULL;
writeCipher = CipherBox.NULL;
writeMAC = MAC.NULL;
// default security parameters for secure renegotiation
secureRenegotiation = false;
clientVerifyData = new byte[0];
serverVerifyData = new byte[0];
enabledCipherSuites =
sslContext.getDefaultCipherSuiteList(roleIsServer);
enabledProtocols =
sslContext.getDefaultProtocolList(roleIsServer);
wrapLock = new Object();
unwrapLock = new Object();
writeLock = new Object();
/*
* Save the Access Control Context. This will be used later
* for a couple of things, including providing a context to
* run tasks in, and for determining which credentials
* to use for Subject based (JAAS) decisions
*/
acc = AccessController.getContext();
/*
* All outbound application data goes through this OutputRecord,
* other data goes through their respective records created
* elsewhere. All inbound data goes through this one
* input record.
*/
outputRecord =
new EngineOutputRecord(Record.ct_application_data, this);
inputRecord = new EngineInputRecord(this);
inputRecord.enableFormatChecks();
writer = new EngineWriter();
} | java |
public SSLEngineResult unwrap(ByteBuffer netData, ByteBuffer [] appData,
int offset, int length) throws SSLException {
EngineArgs ea = new EngineArgs(netData, appData, offset, length);
try {
synchronized (unwrapLock) {
return readNetRecord(ea);
}
} catch (Exception e) {
/*
* Don't reset position so it looks like we didn't
* consume anything. We did consume something, and it
* got us into this situation, so report that much back.
* Our days of consuming are now over anyway.
*/
fatal(Alerts.alert_internal_error,
"problem unwrapping net record", e);
return null; // make compiler happy
} finally {
/*
* Just in case something failed to reset limits properly.
*/
ea.resetLim();
}
} | java |
public SSLEngineResult wrap(ByteBuffer [] appData,
int offset, int length, ByteBuffer netData) throws SSLException {
EngineArgs ea = new EngineArgs(appData, offset, length, netData);
/*
* We can be smarter about using smaller buffer sizes later.
* For now, force it to be large enough to handle any
* valid SSL/TLS record.
*/
if (netData.remaining() < outputRecord.maxRecordSize) {
return new SSLEngineResult(
Status.BUFFER_OVERFLOW, getHSStatus(null), 0, 0);
}
try {
synchronized (wrapLock) {
return writeAppRecord(ea);
}
} catch (Exception e) {
ea.resetPos();
fatal(Alerts.alert_internal_error,
"problem wrapping app data", e);
return null; // make compiler happy
} finally {
/*
* Just in case something didn't reset limits properly.
*/
ea.resetLim();
}
} | java |
private boolean checkSequenceNumber(MAC mac, byte type)
throws IOException {
/*
* Don't bother to check the sequence number for error or
* closed connections, or NULL MAC
*/
if (connectionState >= cs_ERROR || mac == MAC.NULL) {
return false;
}
/*
* Conservatively, close the connection immediately when the
* sequence number is close to overflow
*/
if (mac.seqNumOverflow()) {
/*
* TLS protocols do not define a error alert for sequence
* number overflow. We use handshake_failure error alert
* for handshaking and bad_record_mac for other records.
*/
if (debug != null && Debug.isOn("ssl")) {
System.out.println(threadName() +
", sequence number extremely close to overflow " +
"(2^64-1 packets). Closing connection.");
}
fatal(Alerts.alert_handshake_failure, "sequence number overflow");
return true; // make the compiler happy
}
/*
* Ask for renegotiation when need to renew sequence number.
*
* Don't bother to kickstart the renegotiation when the local is
* asking for it.
*/
if ((type != Record.ct_handshake) && mac.seqNumIsHuge()) {
if (debug != null && Debug.isOn("ssl")) {
System.out.println(threadName() + ", request renegotiation " +
"to avoid sequence number overflow");
}
beginHandshake();
return true;
}
return false;
} | java |
synchronized public void setEnableSessionCreation(boolean flag) {
enableSessionCreation = flag;
if ((handshaker != null) && !handshaker.activated()) {
handshaker.setEnableSessionCreation(enableSessionCreation);
}
} | java |
synchronized public void setUseClientMode(boolean flag) {
switch (connectionState) {
case cs_START:
/*
* If we need to change the engine mode and the enabled
* protocols haven't specifically been set by the user,
* change them to the corresponding default ones.
*/
if (roleIsServer != (!flag) &&
sslContext.isDefaultProtocolList(enabledProtocols)) {
enabledProtocols = sslContext.getDefaultProtocolList(!flag);
}
roleIsServer = !flag;
serverModeSet = true;
break;
case cs_HANDSHAKE:
/*
* If we have a handshaker, but haven't started
* SSL traffic, we can throw away our current
* handshaker, and start from scratch. Don't
* need to call doneConnect() again, we already
* have the streams.
*/
assert(handshaker != null);
if (!handshaker.activated()) {
/*
* If we need to change the engine mode and the enabled
* protocols haven't specifically been set by the user,
* change them to the corresponding default ones.
*/
if (roleIsServer != (!flag) &&
sslContext.isDefaultProtocolList(enabledProtocols)) {
enabledProtocols = sslContext.getDefaultProtocolList(!flag);
}
roleIsServer = !flag;
connectionState = cs_START;
initHandshaker();
break;
}
// If handshake has started, that's an error. Fall through...
default:
if (debug != null && Debug.isOn("ssl")) {
System.out.println(threadName() +
", setUseClientMode() invoked in state = " +
connectionState);
}
/*
* We can let them continue if they catch this correctly,
* we don't need to shut this down.
*/
throw new IllegalArgumentException(
"Cannot change mode after SSL traffic has started");
}
} | java |
synchronized public SSLParameters getSSLParameters() {
SSLParameters params = super.getSSLParameters();
// the super implementation does not handle the following parameters
params.setEndpointIdentificationAlgorithm(identificationProtocol);
params.setAlgorithmConstraints(algorithmConstraints);
return params;
} | java |
synchronized public void setSSLParameters(SSLParameters params) {
super.setSSLParameters(params);
// the super implementation does not handle the following parameters
identificationProtocol = params.getEndpointIdentificationAlgorithm();
algorithmConstraints = params.getAlgorithmConstraints();
if ((handshaker != null) && !handshaker.started()) {
handshaker.setIdentificationProtocol(identificationProtocol);
handshaker.setAlgorithmConstraints(algorithmConstraints);
}
} | java |
public Optional<JField> exceptionMessageField() {
String fieldName = getExceptionMessageFieldName();
return numericalOrderFields().stream()
.filter(f -> f.name().equals(fieldName) && f.type() == PType.STRING)
.findFirst();
} | java |
private String getAnnotationValue(String annotation) {
if (descriptor instanceof CAnnotatedDescriptor) {
if (((CAnnotatedDescriptor) descriptor).hasAnnotation(annotation)) {
return ((CAnnotatedDescriptor) descriptor).getAnnotationValue(annotation);
}
}
return null;
} | java |
public List<String> getRoleNames(final Optional<Subject> subjectOption)
{
final List<String> roleNames = new ArrayList<String>();
subjectOption.ifPresent(subject -> {
final List<? extends Role> roles = subject.getRoles();
if (roles != null)
{
for (Role role : roles)
{
if (role != null)
{
roleNames.add(role.getName());
}
}
}
});
return roleNames;
} | java |
@Override
public void onDestroyView() {
mHandler.removeCallbacks(mRequestFocus);
mList = null;
mListShown = false;
mEmptyView = mProgressContainer = mListContainer = null;
mStandardEmptyView = null;
super.onDestroyView();
} | java |
public void setListAdapter(ListAdapter adapter) {
boolean hadAdapter = mAdapter != null;
mAdapter = adapter;
if (mList != null) {
mList.setAdapter(adapter);
if (!mListShown && !hadAdapter) {
// The list was hidden, and previously didn't have an
// adapter. It is now time to show it.
setListShown(true, getView().getWindowToken() != null);
}
}
} | java |
public void setEmptyText(CharSequence text) {
ensureList();
if (mStandardEmptyView == null) {
throw new IllegalStateException("Can't be used with a custom content view");
}
mStandardEmptyView.setText(text);
if (mEmptyText == null) {
mList.setEmptyView(mStandardEmptyView);
}
mEmptyText = text;
} | java |
private void appendCreateMethod(List<CStructDescriptor> messages) {
writer.appendln("@Override")
.formatln("public %s create(int classId) {", Portable.class.getName())
.begin()
.appendln("switch(classId) {")
.begin();
for (CStructDescriptor message : messages) {
writer.formatln("case %s: {", getHazelcastClassId(message.getName()))
.begin()
.formatln("return new %s.%s();",
message.getName(),
HazelcastPortableMessageFormatter.WRAPPER_CLASS_NAME)
.end()
.appendln("}");
}
writer.appendln("default: {")
.begin()
.appendln("return null;")
.end()
.appendln("}")
.end();
writer.appendln("}")
.end()
.appendln("}")
.newline();
} | java |
private void appendPopulateMethod(List<CStructDescriptor> messages) {
writer.formatln("public static final %s populateConfig(%s %s, int %s) {",
Config.class.getName(),
Config.class.getName(),
CONFIG,
PORTABLE_VERSION)
.begin()
.formatln("%s %s = new %s();", FACTORY_IMPL, INSTANCE, FACTORY_IMPL)
.formatln("%s.getSerializationConfig().addPortableFactory(%s, %s);", CONFIG, FACTORY_ID, INSTANCE)
.formatln("%s.getSerializationConfig().setPortableVersion(%s);", CONFIG, PORTABLE_VERSION)
.appendln()
.formatln("%s.getSerializationConfig()", CONFIG)
.begin()
.begin();
for (CStructDescriptor struct : messages) {
writer.formatln(".addClassDefinition(%s.%s(%s))",
INSTANCE,
camelCase("get", struct.getName() + "Definition"),
PORTABLE_VERSION);
}
writer.append(";")
.end()
.end()
.formatln("return %s;", CONFIG)
.end()
.appendln("}")
.newline();
} | java |
private void appendCollectionTypeField(JField field, PDescriptor descriptor) {
switch (descriptor.getType()) {
case BYTE:
case BINARY:
writer.formatln(".addByteArrayField(\"%s\")", field.name());
break;
case BOOL:
writer.formatln(".addBooleanArrayField(\"%s\")", field.name());
break;
case DOUBLE:
writer.formatln(".addDoubleArrayField(\"%s\")", field.name());
break;
case I16:
writer.formatln(".addShortArrayField(\"%s\")", field.name());
break;
case I32:
case ENUM:
writer.formatln(".addIntArrayField(\"%s\")", field.name());
break;
case I64:
writer.formatln(".addLongArrayField(\"%s\")", field.name());
break;
case STRING:
writer.formatln(".addUTFArrayField(\"%s\")", field.name());
break;
case MESSAGE:
writer.formatln(".addPortableArrayField(\"%s\", %s(%s))",
field.name(),
camelCase("get", descriptor.getName() + "Definition"),
PORTABLE_VERSION);
break;
default:
throw new GeneratorException(
"Not implemented appendCollectionTypeField for list with type: " + descriptor.getType() + " in " +
this.getClass()
.getSimpleName());
}
} | java |
protected boolean objectVisibleToUser(String objectTenancyPath, String userTenancyPath) {
// if in "same hierarchy"
return objectTenancyPath.startsWith(userTenancyPath) ||
userTenancyPath.startsWith(objectTenancyPath);
} | java |
@Nonnull
protected Throwable getResponseException(Throwable e) {
// Unwrap execution exceptions.
if (ExecutionException.class.isAssignableFrom(e.getClass())) {
return getResponseException(e.getCause());
}
return e;
} | java |
public static Key JOIN_PROMPT(String value, Voice voice) {
Map<String, String> map = new HashMap<String, String>();
map.put("value", value);
if (voice != null) {
map.put("voice", voice.toString());
}
return createKey("joinPrompt", map);
} | java |
@Programmatic
public List<ApplicationTenancy> findByNameOrPathMatchingCached(final String search) {
return queryResultsCache.execute(new Callable<List<ApplicationTenancy>>() {
@Override public List<ApplicationTenancy> call() throws Exception {
return findByNameOrPathMatching(search);
}
}, ApplicationTenancyRepository.class, "findByNameOrPathMatchingCached", search);
} | java |
@Programmatic
public ApplicationTenancy findByPathCached(final String path) {
return queryResultsCache.execute(new Callable<ApplicationTenancy>() {
@Override
public ApplicationTenancy call() throws Exception {
return findByPath(path);
}
}, ApplicationTenancyRepository.class, "findByPathCached", path);
} | java |
@Programmatic
public ApplicationTenancy newTenancy(
final String name,
final String path,
final ApplicationTenancy parent) {
ApplicationTenancy tenancy = findByPath(path);
if (tenancy == null) {
tenancy = getApplicationTenancyFactory().newApplicationTenancy();
tenancy.setName(name);
tenancy.setPath(path);
tenancy.setParent(parent);
container.persist(tenancy);
}
return tenancy;
} | java |
@Programmatic
public List<ApplicationTenancy> allTenancies() {
return queryResultsCache.execute(new Callable<List<ApplicationTenancy>>() {
@Override
public List<ApplicationTenancy> call() throws Exception {
return allTenanciesNoCache();
}
}, ApplicationTenancyRepository.class, "allTenancies");
} | java |
public static <T extends Throwable> Matcher<T> isThrowable(Class<?> type) {
return IsThrowable.isThrowable(type);
} | java |
@Beta
public static <E extends Throwable> void check(boolean condition, E throwable) throws E {
checkArgument(throwable != null, "Expected non-null reference");
if (!condition) {
throw throwable;
}
} | java |
public RecursiveTypeRegistry getRegistryForProgramName(String programName) {
if (localProgramContext.equals(programName)) return this;
for (RecursiveTypeRegistry registry : includes.values()) {
if (registry.getLocalProgramContext().equals(programName)) {
return registry;
}
}
for (RecursiveTypeRegistry registry : includes.values()) {
RecursiveTypeRegistry tmp = registry.getRegistryForProgramName(programName);
if (tmp != null) {
return tmp;
}
}
return null;
} | java |
public void registerInclude(String programName, RecursiveTypeRegistry registry) {
if (registry == this) {
throw new IllegalArgumentException("Registering include back to itself: " + programName);
}
if (includes.containsKey(programName)) {
return;
}
includes.put(programName, registry);
} | java |
@WillCloseWhenClosed
public static void sleepFor(long timeout, TimeUnit unit) {
try {
unit.sleep(timeout);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
} | java |
@WillNotClose
public static Optional<InterruptedException> uninterruptibleSleepFor(long timeout, TimeUnit unit) {
try {
unit.sleep(timeout);
return Optional.absent();
} catch (InterruptedException e) {
return Optional.of(e);
}
} | java |
public String getContentId() {
String[] values = getMimeHeader("Content-ID");
if (values != null && values.length > 0)
return values[0];
return null;
} | java |
public String getContentType() {
String[] values = getMimeHeader("Content-Type");
if (values != null && values.length > 0)
return values[0];
return null;
} | java |
protected String finalTypename(String typeName, String programContext) {
String qualifiedName = qualifiedTypenameInternal(typeName, programContext);
if (typedefs.containsKey(qualifiedName)) {
String resolved = typedefs.get(qualifiedName);
return finalTypename(resolved, programContext);
}
return qualifiedName;
} | java |
protected static String qualifiedNameFromIdAndContext(String name, String context) {
if (!name.contains(".")) {
return context + "." + name;
}
return name;
} | java |
private void registerListType(PContainer containerType) {
PDescriptor itemType = containerType.itemDescriptor();
if (itemType.getType() == PType.MAP ||
itemType.getType() == PType.LIST ||
itemType.getType() == PType.SET) {
registerListType((PContainer) itemType);
} else if (itemType.getType() == PType.ENUM ||
itemType.getType() == PType.MESSAGE){
registerRecursively((PDeclaredDescriptor<?>) itemType);
}
if (containerType instanceof PMap) {
PDescriptor keyType = ((PMap) containerType).keyDescriptor();
if (keyType.getType() == PType.ENUM ||
keyType.getType() == PType.MESSAGE){
registerRecursively((PDeclaredDescriptor<?>) keyType);
}
}
// Else ignore.
} | java |
protected static <Message extends PMessage<Message, CField>>
String asString(Message message) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
PRETTY_SERIALIZER.serialize(baos, message);
return new String(baos.toByteArray(), UTF_8);
} | java |
@SuppressWarnings("unchecked")
private static <T extends Comparable<T>> int compare(T o1, T o2) {
if (o1 instanceof PMessage && o2 instanceof PMessage) {
return compareMessages((PMessage) o1, (PMessage) o2);
}
return o1.compareTo(o2);
} | java |
public static <T, E extends RuntimeException> ExceptionSupplier<T, E> throwA(E exception) {
return new ExceptionSupplier<>(exception);
} | java |
public static <T, E extends RuntimeException> ExceptionSupplier<T, E> throwA(
@SuppressWarnings("UnusedParameters") Class<T> type, E exception) {
return new ExceptionSupplier<>(exception);
} | java |
private <Message extends PMessage<Message, Field>, Field extends PField>
Message parseMessage(ThriftTokenizer tokenizer,
PMessageDescriptor<Message, Field> type) throws IOException {
PMessageBuilder<Message, Field> builder = type.builder();
if (tokenizer.peek("checking for empty").isSymbol(Token.kMessageEnd)) {
tokenizer.next();
return builder.build();
}
while (true) {
Token token = tokenizer.expect("message field name",
t -> t.isStringLiteral() ||
t.strEquals(ThriftTokenizer.kBlockCommentStart) ||
t.strEquals(ThriftTokenizer.kLineCommentStart));
if (token.strEquals(ThriftTokenizer.kLineCommentStart)) {
int c;
while ((c = tokenizer.read()) >= 0) {
if (c == '\n') break;
}
continue;
} else if (token.strEquals(ThriftTokenizer.kBlockCommentStart)) {
int c;
while ((c = tokenizer.read()) >= 0) {
if (c == '*') {
c = tokenizer.read();
if (c == '/') {
break;
}
}
}
continue;
}
Field field = type.findFieldByName(token.decodeLiteral(true));
if (field == null) {
throw tokenizer.failure(token, "No such field in " + type.getQualifiedName() + ": " + token.decodeLiteral(true));
}
tokenizer.expectSymbol("message key-value sep", Token.kKeyValueSep);
builder.set(field.getId(),
parseTypedValue(tokenizer.expect("parsing field value"), tokenizer, field.getDescriptor(), false));
token = tokenizer.peek("optional line sep or message end");
if (token.isSymbol(Token.kLineSep1) || token.isSymbol(Token.kLineSep2)) {
tokenizer.next();
token = tokenizer.peek("optional message end");
}
if (token.isSymbol(Token.kMessageEnd)) {
tokenizer.next();
break;
}
}
return builder.build();
} | java |
@Override
public List<FixtureResult> runFixtureScript(
final FixtureScript fixtureScript,
@Parameter(optionality = Optionality.OPTIONAL)
@ParameterLayout(
named = "Parameters",
describedAs = "Script-specific parameters (if any). The format depends on the script implementation (eg key=value, CSV, JSON, XML etc)",
multiLine = 10
)
final String parameters) {
return super.runFixtureScript(fixtureScript, parameters);
} | java |
@Action(
semantics = SemanticsOf.NON_IDEMPOTENT,
restrictTo = RestrictTo.PROTOTYPING
)
@MemberOrder(sequence="20")
public Object installFixturesAndReturnFirstRole() {
final List<FixtureResult> fixtureResultList = findFixtureScriptFor(SecurityModuleAppSetUp.class).run(null);
for (FixtureResult fixtureResult : fixtureResultList) {
final Object object = fixtureResult.getObject();
if(object instanceof ApplicationRole) {
return object;
}
}
getContainer().warnUser("No rules found in fixture; returning all results");
return fixtureResultList;
} | java |
public JServiceMethod[] methods() {
List<CServiceMethod> methods = new ArrayList<>(service.getMethodsIncludingExtended());
CServiceMethod[] ma = methods.toArray(new CServiceMethod[methods.size()]);
JServiceMethod[] ret = new JServiceMethod[ma.length];
for (int i = 0; i < methods.size(); ++i) {
ret[i] = new JServiceMethod(service, ma[i], helper);
}
return ret;
} | java |
@Nonnull
public static <Message extends PMessage<Message, Field>, Field extends PField>
Message parseDebugString(String string, PMessageDescriptor<Message, Field> descriptor) {
try {
ByteArrayInputStream bais = new ByteArrayInputStream(string.getBytes(UTF_8));
return DEBUG_STRING_SERIALIZER.deserialize(bais, descriptor);
} catch (IOException e) {
throw new UncheckedIOException(e.getMessage(), e);
}
} | java |
@SuppressWarnings("unchecked")
@Nonnull
public static <T> Optional<T> optionalInMessage(PMessage message, PField... fields) {
if (fields == null || fields.length == 0) {
throw new IllegalArgumentException("No fields arguments.");
}
PField field = fields[0];
if (!message.has(field.getId())) {
return Optional.empty();
}
if (fields.length > 1) {
if (field.getType() != PType.MESSAGE) {
throw new IllegalArgumentException("Field " + field.getName() + " is not a message.");
}
return optionalInMessage((PMessage) message.get(field), Arrays.copyOfRange(fields, 1, fields.length));
} else {
return Optional.of((T) message.get(field.getId()));
}
} | java |
@javax.annotation.Nonnull
public java.util.Optional<String> optionalMessage() {
return java.util.Optional.ofNullable(mMessage);
} | java |
@javax.annotation.Nonnull
public java.util.Optional<net.morimekta.providence.PApplicationExceptionType> optionalId() {
return java.util.Optional.ofNullable(mId);
} | java |
public Collection<CServiceMethod> getMethodsIncludingExtended() {
CService extended = getExtendsService();
if (extended == null) {
return getMethods();
}
List<CServiceMethod> out = new ArrayList<>();
out.addAll(extended.getMethodsIncludingExtended());
out.addAll(getMethods());
return ImmutableList.copyOf(out);
} | java |
public static TestRule ignoreIfNotUnix() {
return (base, description) -> new Statement() {
@Override
public void evaluate() throws Throwable {
assumeIsUnix();
base.evaluate();
}
};
} | java |
private void appendPrimitive(JsonWriter writer, Object primitive) throws SerializerException {
if (primitive instanceof PEnumValue) {
if (IdType.ID.equals(enumValueType)) {
writer.value(((PEnumValue<?>) primitive).asInteger());
} else {
writer.valueUnescaped(primitive.toString());
}
} else if (primitive instanceof Boolean) {
writer.value(((Boolean) primitive));
} else if (primitive instanceof Byte) {
writer.value(((Byte) primitive));
} else if (primitive instanceof Short) {
writer.value(((Short) primitive));
} else if (primitive instanceof Integer) {
writer.value(((Integer) primitive));
} else if (primitive instanceof Long) {
writer.value(((Long) primitive));
} else if (primitive instanceof Double) {
writer.value(((Double) primitive));
} else if (primitive instanceof CharSequence) {
writer.value((String) primitive);
} else if (primitive instanceof Binary) {
writer.value((Binary) primitive);
} else {
throw new SerializerException("illegal primitive type class " + primitive.getClass()
.getSimpleName());
}
} | java |
String getTimeFileName() {
SimpleDateFormat dateFormat = new SimpleDateFormat(wraper.formatter);
return dateFormat.format(Calendar.getInstance().getTime());
} | java |
@Nonnull
public static <Message extends PMessage<Message, Field>, Field extends PField>
Stream<Message> stream(InputStream in,
Serializer serializer,
PMessageDescriptor<Message, Field> descriptor) {
return StreamSupport.stream(new MessageSpliterator<>(in, serializer, descriptor), false);
} | java |
public static <T, R> Function<T, ListenableFuture<R>> futureWith(final ListeningExecutorService executor,
final Function<T, R> task,
final FutureCallback<R> callback) {
checkArgument(executor != null, "Expected non-null executor");
checkArgument(task != null, "Expected non-null task");
checkArgument(callback != null, "Expected non-null callback");
return input -> {
ListenableFuture<R> future = executor.submit(() -> task.apply(input));
addCallback(future, callback, executor);
return future;
};
} | java |
public <Message extends PMessage<Message, Field>, Field extends PField>
void formatTo(OutputStream out, Message message) {
IndentedPrintWriter builder = new IndentedPrintWriter(out, indent, newline);
if (message == null) {
builder.append(null);
} else {
builder.append(message.descriptor().getQualifiedName())
.append(space);
appendMessage(builder, message);
}
builder.flush();
} | java |
public <Message extends PMessage<Message, Field>, Field extends PField>
String format(Message message) {
ByteArrayOutputStream out = new ByteArrayOutputStream();
formatTo(out, message);
return new String(out.toByteArray(), StandardCharsets.UTF_8);
} | java |
public Key getKey(String alias, String password) {
try {
return keyStore.getKey(alias, password.toCharArray());
} catch (GeneralSecurityException e) {
throw new IllegalStateException(e);
}
} | java |
public PrivateKey getPrivateKey(String alias, String password) {
Key key = getKey(alias, password);
if (key instanceof PrivateKey) {
return (PrivateKey) key;
} else {
throw new IllegalStateException(format("Key with alias '%s' was not a private key, but was: %s",
alias, key.getClass().getSimpleName()));
}
} | java |
public SecretKey getSecretKey(String alias, String password) {
Key key = getKey(alias, password);
if (key instanceof PrivateKey) {
return (SecretKey) key;
} else {
throw new IllegalStateException(format("Key with alias '%s' was not a secret key, but was: %s",
alias, key.getClass().getSimpleName()));
}
} | java |
public static String colorHeader() {
return Color.BOLD +
HEADER_L1 + "\n" +
new Color(Color.YELLOW, Color.UNDERLINE) +
HEADER_L2 + " " +
Color.CLEAR;
} | java |
private void appendFactoryId(JMessage<?> message) {
writer.appendln("@Override")
.appendln("public int getFactoryId() {")
.begin()
//TODO: The factory should be file unqiue. ID is struct unique so for id we want to define several constants.
// so for content_cms we want the factory name ContentCmsFactory or ContentCmsPortableFactory.
// as well as some way to count this up for each struct that has a hazelcast_portable tag in it.
.formatln("return %s.%s;",
getHazelcastFactory(message.descriptor()),
HazelcastPortableProgramFormatter.FACTORY_ID)
.end()
.appendln("}")
.newline();
} | java |
private void appendClassId(JMessage<?> message) {
writer.appendln("@Override")
.appendln("public int getClassId() {")
.begin()
//TODO: Need to add method to create a constant for the description or struct here.
.formatln("return %s.%s;",
getHazelcastFactory(message.descriptor()),
getHazelcastClassId(message.descriptor()))
.end()
.appendln("}")
.newline();
} | java |
private void appendPortableWriter(JMessage<?> message) {
writer.appendln("@Override")
.formatln("public void writePortable(%s %s) throws %s {",
PortableWriter.class.getName(),
PORTABLE_WRITER,
IOException.class.getName())
.begin();
// TODO: This should be short[] instead, as field IDs are restricted to 16bit.
writer.appendln("int[] setFields = presentFields().stream()")
.appendln(" .mapToInt(_Field::getId)")
.appendln(" .toArray();")
.appendln("portableWriter.writeIntArray(\"__fields__\", setFields);");
for (JField field : message.declaredOrderFields()) {
if (!field.alwaysPresent()) {
writer.formatln("if( %s() ) {", field.isSet())
.begin();
}
writePortableField(field);
if (!field.alwaysPresent()) {
writer.end()
.appendln("} else {")
.begin();
writeDefaultPortableField(field);
writer.end()
.appendln("}");
}
}
writer.end()
.appendln("}")
.newline();
} | java |
private void appendPortableReader(JMessage<?> message) {
writer.appendln("@Override")
.formatln("public void readPortable(%s %s) throws %s {",
PortableReader.class.getName(),
PORTABLE_READER,
IOException.class.getName())
.begin();
// TODO: This should be short[] instead, as field IDs are restricted to 16bit.
writer.formatln("int[] field_ids = %s.readIntArray(\"__fields__\");", PORTABLE_READER)
.appendln()
.appendln("for (int id : field_ids) {")
.begin()
.appendln("switch (id) {")
.begin();
for (JField field : message.declaredOrderFields()) {
writer.formatln("case %d: {", field.id())
.begin();
readPortableField(field);
writer.appendln("break;")
.end()
.appendln("}");
}
writer.end()
.appendln("}") // switch
.end()
.appendln("}") // for loop
.end()
.appendln("}") // readPortable
.newline();
} | java |
@Programmatic
public ApplicationRole newRole(
final String name,
final String description) {
ApplicationRole role = findByName(name);
if (role == null){
role = getApplicationRoleFactory().newApplicationRole();
role.setName(name);
role.setDescription(description);
container.persist(role);
}
return role;
} | java |
private void hangOut( final RequestCallInfo req, GenericJSO hangOut )
{
final int hangOutId = hangOut.getIntByIdx( 0 );
JsArrayString tmp = hangOut.getGenericJSOByIdx( 1 ).cast();
String name = tmp.get( 0 );
String type = tmp.get( 1 );
String title = tmp.get( 2 );
String description = tmp.get( 3 );
JavaScriptObject hangOutCurrentData = hangOut.getGenericJSOByIdx( 2 );
callback.hangOut( title, description, name, type, hangOutCurrentData, new IAsyncCallback<JavaScriptObject>()
{
@Override
public void onSuccess( JavaScriptObject result )
{
JSONArray params = new JSONArray();
params.set( 0, new JSONNumber( hangOutId ) );
params.set( 1, new JSONObject( result ) );
req.request = new RequestDesc( req.request.service, req.request.interfaceChecksum, "_hang_out_reply_", params );
sendRequest( req.request, req.cookie, req.callback );
}
} );
} | java |
private RPCBatchRequestSender getBatchRequestSender()
{
RPCBatchRequestSender sender = null;
// test the last sender we have in the list
if( !batchRequestSenders.isEmpty() )
{
sender = batchRequestSenders.get( batchRequestSenders.size() - 1 );
if( sender.canAddRequest() )
return sender;
}
// otherwise, create a new one
sender = new RPCBatchRequestSender();
sender.init( baseUrl, batchSenderCallback );
batchRequestSenders.add( sender );
return sender;
} | java |
private Set<ConstraintViolation<Object>> addViolations(
Set<ConstraintViolation<Object>> source,
Set<ConstraintViolation<Object>> target) {
if (supportsConstraintComposition) {
target.addAll(source);
return target;
}
for (final Iterator<ConstraintViolation<Object>> iter = source
.iterator(); iter.hasNext(); ) {
final ConstraintViolation<Object> violation = iter.next();
final Iterator<Node> nodeIter = violation.getPropertyPath()
.iterator();
/*
* Only include violations that have no property path or just one
* node
*/
if (!nodeIter.hasNext()
|| (nodeIter.next() != null && !nodeIter.hasNext())) {
target.add(violation);
}
}
return target;
} | java |
private void passViolations(ConstraintValidatorContext context,
Set<ConstraintViolation<Object>> source) {
for (final ConstraintViolation<Object> violation : source) {
final Iterator<Node> nodeIter = violation.getPropertyPath()
.iterator();
final ConstraintViolationBuilder builder = context
.buildConstraintViolationWithTemplate(violation
.getMessageTemplate());
ConstraintValidatorContext nodeContext;
if (nodeIter.hasNext()) {
StringBuilder sb = new StringBuilder(nodeIter.next().getName());
if (supportsConstraintComposition) {
while (nodeIter.hasNext()) {
sb.append('.').append(nodeIter.next());
}
}
builder.addNode(sb.toString()).addConstraintViolation();
} else {
builder.addConstraintViolation();
}
}
} | java |
private void editCell( Cell cell )
{
if( cell == null || cell == editedCell )
return;
T record = getRecordForRow( cell.getParentRow() );
if( record == null )
return;
registerCurrentEdition( cell, record );
} | java |
public static String toHawkularFormat(BasicMessage msg) {
return String.format("%s=%s", msg.getClass().getSimpleName(), msg.toJSON());
} | java |
public static <T extends BasicMessage> T fromJSON(String json, Class<T> clazz) {
try {
Method buildObjectMapperForDeserializationMethod = findBuildObjectMapperForDeserializationMethod(clazz);
final ObjectMapper mapper = (ObjectMapper) buildObjectMapperForDeserializationMethod.invoke(null);
if (FailOnUnknownProperties.class.isAssignableFrom(clazz)) {
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true);
}
return mapper.readValue(json, clazz);
} catch (Exception e) {
throw new IllegalStateException("JSON message cannot be converted to object of type [" + clazz + "]", e);
}
} | java |
public static <T extends BasicMessage> BasicMessageWithExtraData<T> fromJSON(InputStream in, Class<T> clazz) {
final T obj;
final byte[] remainder;
try (JsonParser parser = new JsonFactory().configure(Feature.AUTO_CLOSE_SOURCE, false).createParser(in)) {
Method buildObjectMapperForDeserializationMethod = findBuildObjectMapperForDeserializationMethod(clazz);
final ObjectMapper mapper = (ObjectMapper) buildObjectMapperForDeserializationMethod.invoke(null);
if (FailOnUnknownProperties.class.isAssignableFrom(clazz)) {
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true);
}
obj = mapper.readValue(parser, clazz);
final ByteArrayOutputStream remainderStream = new ByteArrayOutputStream();
final int released = parser.releaseBuffered(remainderStream);
remainder = (released > 0) ? remainderStream.toByteArray() : new byte[0];
} catch (Exception e) {
throw new IllegalArgumentException("Stream cannot be converted to JSON object of type [" + clazz + "]", e);
}
return new BasicMessageWithExtraData<T>(obj, new BinaryData(remainder, in));
} | java |
protected static ObjectMapper buildObjectMapperForDeserialization() {
final ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
return mapper;
} | java |
@Override
public String toJSON() {
final ObjectMapper mapper = buildObjectMapperForSerialization();
try {
return mapper.writeValueAsString(this);
} catch (JsonProcessingException e) {
throw new IllegalStateException("Object cannot be parsed as JSON.", e);
}
} | java |
@Override
public void onResponse( Object cookie, ResponseJSO response, int msgLevel, String msg )
{
PendingRequestInfo info = (PendingRequestInfo) cookie;
// Store answer in cache
if( info.fStoreResultInCache )
cache.put( info.requestKey, response );
// give the result to all the subscribees
for( RequestCallInfo call : info.subscriptions )
call.setResult( msgLevel, msg, null, response );
// forget this request
pendingRequests.remove( info );
// calls back the clients
checkAnswersToGive();
} | java |
public static boolean dumpDatabaseSchemaToFile( DatabaseContext ctx, File file )
{
log.info( "Dumping database schema to file " + file.getAbsolutePath() );
DatabaseDescriptionInspector inspector = new DatabaseDescriptionInspector();
DatabaseDescription dbDesc = inspector.getDatabaseDescription( ctx.db, ctx.dbh );
Gson gson = new Gson();
String json = gson.toJson( dbDesc );
try
{
PrintWriter writer;
writer = new PrintWriter( file );
writer.print( json );
writer.close();
return true;
}
catch( FileNotFoundException e )
{
e.printStackTrace();
return false;
}
} | java |
String getStatistics()
{
String msg = "PropertyChanges stats :\r\n"
+ "# registered handlers : " + nbRegisteredHandlers + "\r\n"
+ "# notifications : " + nbNotifications + "\r\n"
+ "# dispatches : " + nbDispatches + "\r\n";
StringBuilder details = new StringBuilder();
for( Entry<String, Integer> e : counts.entrySet() )
{
details.append( e.getKey() + " => " + e.getValue() );
Integer oldCount = oldCounts.get( e.getKey() );
if( oldCount!=null )
details.append( " (diff: " + (e.getValue()-oldCount) + ")" );
details.append( "\n" );
}
oldCounts = new HashMap<>( counts );
return msg + details.toString();
} | java |
public <T> T manageTransaction( DatabaseContext ctx, TransactionManagedAction<T> action )
{
ctx.db.startTransaction();
try
{
T result = action.execute( ctx );
ctx.db.commit();
return result;
}
catch( Exception exception )
{
ctx.db.rollback();
throw new ManagedTransactionException( "Exception during managed transaction, see cause for details", exception );
}
} | java |
public synchronized DatabaseContextFactory dbFactory( String databaseUri )
{
DatabaseContextFactory factory = new DatabaseContextFactory();
if( ! factory.init( databaseUri ) )
{
log.error( "Cannot initialize database connection pool, it won't be available to the program !" );
return null;
}
return factory;
} | java |
public static Throwable getCause(Throwable e, Class<? extends Throwable>... causes) {
if ((e == null) || (causes == null) || (causes.length < 1)) {
return null;
} else if (isInstance(e, causes)) {
if (((e.getCause() == null) || (e.getCause()
.equals(e) || (!equals(e.getClass(), causes))))) {
return e;
} else {
return getCause(e.getCause(), causes);
}
} else if ((e.getCause() == null) && (e instanceof InvocationTargetException)) {
return getCause(((InvocationTargetException) e).getTargetException(), causes);
} else if (e.getCause() == null) {
return null;
} else {
return getCause(e.getCause(), causes);
}
} | java |
public static HttpMockServer start(ConfigReader configReader, NetworkType networkType) {
return HttpMockServer.startMockApiServer(configReader, networkType);
} | java |
@SuppressWarnings("unchecked")
public static <T> T getBean(String name) {
BeanManager bm = getBeanManager();
Bean<?> bean = bm.getBeans(name).iterator().next();
CreationalContext<?> ctx = bm.createCreationalContext(bean);
return (T) bm.getReference(bean, bean.getBeanClass(), ctx);
} | java |
public int toInt()
{
int day = ((year + 1900) * 12 + month) * 31 + (date - 1);
if( day < TIME_BEGIN )
day = TIME_BEGIN;
else if( day > TIME_END )
day = TIME_END;
return day;
} | java |
public int indexOf( Widget w )
{
for( int i = 0; i < size; ++i )
{
if( array[i] == w )
{
return i;
}
}
return -1;
} | java |
public void insert( Shape w, int beforeIndex )
{
if( (beforeIndex < 0) || (beforeIndex > size) )
{
throw new IndexOutOfBoundsException();
}
// Realloc array if necessary (doubling).
if( size == array.length )
{
Shape[] newArray = new Shape[array.length * 2];
for( int i = 0; i < array.length; ++i )
{
newArray[i] = array[i];
}
array = newArray;
}
++size;
// Move all widgets after 'beforeIndex' back a slot.
for( int i = size - 1; i > beforeIndex; --i )
{
array[i] = array[i - 1];
}
array[beforeIndex] = w;
} | java |
public void remove( int index )
{
if( (index < 0) || (index >= size) )
{
throw new IndexOutOfBoundsException();
}
--size;
for( int i = index; i < size; ++i )
{
array[i] = array[i + 1];
}
array[size] = null;
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.