code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
@Override public RackResponse call(RackEnvironment environment) {
RubyHash environmentHash = convertToRubyHash(environment.entrySet());
RubyArray response = callRackApplication(environmentHash);
return convertToJavaRackResponse(response);
} | java |
protected AttributeCertificate getACFromResponse(VOMSACRequest request,
VOMSResponse response) {
byte[] acBytes = response.getAC();
if (acBytes == null)
return null;
ASN1InputStream asn1InputStream = new ASN1InputStream(acBytes);
AttributeCertificate attributeCertificate = null;
try {
attributeCertificate = AttributeCertificate.getInstance(asn1InputStream
.readObject());
asn1InputStream.close();
return attributeCertificate;
} catch (Throwable e) {
requestListener.notifyVOMSRequestFailure(request, null, new VOMSError(
"Error unmarshalling VOMS AC. Cause: " + e.getMessage(), e));
return null;
}
} | java |
protected void handleErrorsInResponse(VOMSACRequest request,
VOMSServerInfo si, VOMSResponse response) {
if (response.hasErrors())
requestListener.notifyErrorsInVOMSReponse(request, si,
response.errorMessages());
} | java |
protected void handleWarningsInResponse(VOMSACRequest request,
VOMSServerInfo si, VOMSResponse response) {
if (response.hasWarnings())
requestListener.notifyWarningsInVOMSResponse(request, si,
response.warningMessages());
} | java |
protected void drawCheckerBoard(Graphics2D g2d) {
g2d.setColor(getBackground());
g2d.fillRect(0, 0, getWidth(), getHeight());
g2d.setColor(getForeground());
final int checkSize = this.checkerSize;
final int halfCheckSize = checkSize/2;
final Stroke checker = this.checkerStroke;
final Stroke backup = g2d.getStroke();
g2d.setStroke(checker);
final int width = this.getWidth()+checkSize;
final int height = this.getHeight()+checkSize;
for(int i = halfCheckSize; i < height; i+=checkSize*2){
g2d.drawLine(halfCheckSize, i, width, i);
g2d.drawLine(checkSize+halfCheckSize, i+checkSize, width, i+checkSize);
}
g2d.setStroke(backup);
} | java |
@POST
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_FORM_URLENCODED)
@Override
public String getMessageToClient(@FormParam(Constants.Message.MFC) String json) {
HttpSession httpSession = getHttpSession();
setContext(httpSession);
MessageFromClient message = MessageFromClient.createFromJson(json);
MessageToClient mtc = getMessageToClientService().createMessageToClient(message, httpSession);
return mtc.toJson();
} | java |
@JsCacheRemove(cls = OcelotServices.class, methodName = "getLocale", keys = {}, userScope = true)
public void setLocale(@JsonUnmarshaller(LocaleMarshaller.class) Locale locale) {
logger.debug("Receive setLocale call from client. {}", locale);
ocelotContext.setLocale(locale);
} | java |
@JsCacheResult(year = 1)
@JsonMarshaller(LocaleMarshaller.class)
public Locale getLocale() {
logger.debug("Receive getLocale call from client.");
return ocelotContext.getLocale();
} | java |
public Collection<String> getOutDatedCache(Map<String, Long> states) {
return updatedCacheManager.getOutDatedCache(states);
} | java |
@JsTopic
@WsDataService
public Integer subscribe(@JsTopicName(prefix = Constants.Topic.SUBSCRIBERS) String topic, Session session) throws IllegalAccessException {
return topicManager.registerTopicSession(topic, session);
} | java |
@JsTopic
@WsDataService
public Integer unsubscribe(@JsTopicName(prefix = Constants.Topic.SUBSCRIBERS) String topic, Session session) {
return topicManager.unregisterTopicSession(topic, session);
} | java |
public JsTopicMessageController getJsTopicMessageController(String topic) {
logger.debug("Looking for messageController for topic '{}'", topic);
JsTopicMessageController messageController = messageControllerCache.loadFromCache(topic);
if(null == messageController) { // not in cache
messageController = getJsTopicMessageControllerFromJsTopicControl(topic); // get from JsTopicControl
if(null == messageController) {
messageController = getJsTopicMessageControllerFromJsTopicControls(topic); // get from JsTopicControls
if(null == messageController) {
messageController = new DefaultJsTopicMessageController();
}
}
messageControllerCache.saveToCache(topic, messageController.getClass()); // save in cache
}
return messageController;
} | java |
JsTopicMessageController getJsTopicMessageControllerFromJsTopicControl(String topic) {
logger.debug("Looking for messageController for topic '{}' from JsTopicControl annotation", topic);
Instance<JsTopicMessageController<?>> select = topicMessageController.select(new JsTopicCtrlAnnotationLiteral(topic));
if(!select.isUnsatisfied()) {
logger.debug("Found messageController for topic '{}' from JsTopicControl annotation", topic);
return select.get();
}
return null;
} | java |
int sendMessageToTopicForSessions(Collection<Session> sessions, MessageToClient mtc, Object payload) {
int sended = 0;
JsTopicMessageController msgControl = messageControllerManager.getJsTopicMessageController(mtc.getId());
Collection<Session> sessionsClosed = new ArrayList<>();
for (Session session : sessions) {
try {
sended += checkAndSendMtcToSession(session, msgControl, mtc, payload);
} catch (SessionException se) {
sessionsClosed.add(se.getSession());
}
}
if (logger.isDebugEnabled()) {
logger.debug("Send message to '{}' topic {} client(s) : {}", new Object[]{mtc.getId(), sessions.size() - sessionsClosed.size(), mtc});
}
topicManager.removeSessionsToTopic(sessionsClosed);
return sended;
} | java |
int checkAndSendMtcToSession(Session session, JsTopicMessageController msgControl, MessageToClient mtc, Object payload) throws SessionException {
if (session != null) {
if (session.isOpen()) {
try {
if (null != msgControl) {
checkMessageTopic(userContextFactory.getUserContext(session.getId()), mtc.getId(), payload, msgControl);
}
mtc.setType(MessageType.MESSAGE);
session.getAsyncRemote().sendObject(mtc);
return 1;
} catch (NotRecipientException ex) {
logger.debug("{} is exclude to receive a message in {}", ex.getMessage(), mtc.getId());
}
} else {
throw new SessionException("CLOSED", null, session);
}
}
return 0;
} | java |
void checkMessageTopic(UserContext ctx, String topic, Object payload, JsTopicMessageController msgControl) throws NotRecipientException {
if (null != msgControl) {
msgControl.checkRight(ctx, topic, payload);
}
} | java |
public User getMe(AccessToken accessToken, String... attributes) {
return getUserService().getMe(accessToken, attributes);
} | java |
public AccessToken refreshAccessToken(AccessToken accessToken, Scope... scopes) {
return getAuthService().refreshAccessToken(accessToken, scopes);
} | java |
@Deprecated
public User updateUser(String id, UpdateUser updateUser, AccessToken accessToken) {
return getUserService().updateUser(id, updateUser, accessToken);
} | java |
@Deprecated
public Group updateGroup(String id, UpdateGroup updateGroup, AccessToken accessToken) {
return getGroupService().updateGroup(id, updateGroup, accessToken);
} | java |
public Client getClient(String clientId, AccessToken accessToken) {
return getAuthService().getClient(clientId, accessToken);
} | java |
public Client createClient(Client client, AccessToken accessToken) {
return getAuthService().createClient(client, accessToken);
} | java |
public Client updateClient(String clientId, Client client, AccessToken accessToken) {
return getAuthService().updateClient(clientId, client, accessToken);
} | java |
public void print(final PrintStream out, final ICodingAnnotationStudy study) {
if (study.getRaterCount() > 2)
throw new IllegalArgumentException("Contingency tables are only applicable for two rater studies.");
//TODO: measure length of cats. maybe cut them.
Map<Object, Integer> categories = new LinkedHashMap<Object, Integer>();
for (Object cat : study.getCategories())
categories.put(cat, categories.size());
int[][] frequencies = new int[study.getCategoryCount()][study.getCategoryCount()];
for (ICodingAnnotationItem item : study.getItems()) {
int cat1 = categories.get(item.getUnit(0).getCategory());
int cat2 = categories.get(item.getUnit(1).getCategory());
frequencies[cat1][cat2]++;
}
final String DIVIDER = "\t";
for (Object category : categories.keySet())
out.print(DIVIDER + category);
out.print(DIVIDER + "Σ");
out.println();
int i = 0;
int[] colSum = new int[study.getCategoryCount()];
for (Object category1 : categories.keySet()) {
out.print(category1);
int rowSum = 0;
for (int j = 0; j < categories.size(); j++) {
out.printf(DIVIDER + "%3d", frequencies[i][j]);
rowSum += frequencies[i][j];
colSum[j] += frequencies[i][j];
}
out.printf(DIVIDER + "%3d", rowSum);
out.println();
i++;
}
out.print("Σ");
int rowSum = 0;
for (int j = 0; j < categories.size(); j++) {
out.printf(DIVIDER + "%3d", colSum[j]);
rowSum += colSum[j];
}
out.printf(DIVIDER + "%3d", rowSum);
out.println();
} | java |
public static void checkSyntax(String fqan) {
if (fqan.length() > 255)
throw new VOMSError("fqan.length() > 255");
if (!fqanPattern.matcher(fqan).matches())
throw new VOMSError("Syntax error in fqan: " + fqan);
} | java |
public static void checkRole(String roleName) {
if (roleName.length() > 255)
throw new VOMSError("roleName.length()>255");
if (!rolePattern.matcher(roleName).matches())
throw new VOMSError("Syntax error in role name: " + roleName);
} | java |
public static String getRoleName(String containerName) {
if (!isRole(containerName) && !isQualifiedRole(containerName))
throw new VOMSError("No role specified in \"" + containerName
+ "\" voms syntax.");
Matcher m = fqanPattern.matcher(containerName);
if (m.matches()) {
String roleGroup = m.group(4);
return roleGroup
.substring(roleGroup.indexOf('=') + 1, roleGroup.length());
}
return null;
} | java |
public static String getGroupName(String containerName) {
checkSyntax(containerName);
// If it's a container and it's not a role or a qualified role, then
// it's a group!
if (!isRole(containerName) && !isQualifiedRole(containerName))
return containerName;
Matcher m = fqanPattern.matcher(containerName);
if (m.matches()) {
String groupName = m.group(2);
if (groupName.endsWith("/"))
return groupName.substring(0, groupName.length() - 1);
else
return groupName;
}
return null;
} | java |
@Override
public void send(byte[] b, int off, int len) {
handler.send(b, off, len);
} | java |
protected Artifact createArtifact(final ArtifactItem item) throws MojoExecutionException {
assert item != null;
if (item.getVersion() == null) {
fillMissingArtifactVersion(item);
if (item.getVersion() == null) {
throw new MojoExecutionException("Unable to find artifact version of " + item.getGroupId()
+ ":" + item.getArtifactId() + " in either dependency list or in project's dependency management.");
}
}
// Convert the string version to a range
VersionRange range;
try {
range = VersionRange.createFromVersionSpec(item.getVersion());
log.trace("Using version range: {}", range);
}
catch (InvalidVersionSpecificationException e) {
throw new MojoExecutionException("Could not create range for version: " + item.getVersion(), e);
}
return artifactFactory.createDependencyArtifact(
item.getGroupId(),
item.getArtifactId(),
range,
item.getType(),
item.getClassifier(),
Artifact.SCOPE_PROVIDED);
} | java |
private void fillMissingArtifactVersion(final ArtifactItem item) {
log.trace("Attempting to find missing version in {}:{}", item.getGroupId() , item.getArtifactId());
List list = project.getDependencies();
for (int i = 0; i < list.size(); ++i) {
Dependency dependency = (Dependency) list.get(i);
if (dependency.getGroupId().equals(item.getGroupId())
&& dependency.getArtifactId().equals(item.getArtifactId())
&& dependency.getType().equals(item.getType()))
{
log.trace("Found missing version: {} in dependency list", dependency.getVersion());
item.setVersion(dependency.getVersion());
return;
}
}
list = project.getDependencyManagement().getDependencies();
for (int i = 0; i < list.size(); i++) {
Dependency dependency = (Dependency) list.get(i);
if (dependency.getGroupId().equals(item.getGroupId())
&& dependency.getArtifactId().equals(item.getArtifactId())
&& dependency.getType().equals(item.getType()))
{
log.trace("Found missing version: {} in dependency management list", dependency.getVersion());
item.setVersion(dependency.getVersion());
}
}
} | java |
@Override
public void onRecv(byte[] b, int off, int len) {
connection.onRecv(b, off, len);
} | java |
public List<Integer> searchBigBytes(byte[] srcBytes, byte[] searchBytes) {
int numOfThreadsOptimized = (srcBytes.length / analyzeByteArrayUnitSize);
if (numOfThreadsOptimized == 0) {
numOfThreadsOptimized = 1;
}
return searchBigBytes(srcBytes, searchBytes, numOfThreadsOptimized);
} | java |
public String getFromEnvOrSystemProperty(String propName) {
String val = System.getenv(propName);
if (val == null)
val = System.getProperty(propName);
return val;
} | java |
public void print(final PrintStream out, final ICodingAnnotationStudy study) {
//TODO: measure length of cats. maybe cut them.
Map<Object, Integer> categories = new LinkedHashMap<Object, Integer>();
for (Object cat : study.getCategories())
categories.put(cat, categories.size());
final String DIVIDER = "\t";
for (int i = 0; i < study.getItemCount(); i++)
out.print(DIVIDER + (i + 1));
out.print(DIVIDER + "Σ");
out.println();
for (int r = 0; r < study.getRaterCount(); r++) {
out.print(r + 1);
for (ICodingAnnotationItem item : study.getItems())
out.print(DIVIDER + item.getUnit(r).getCategory());
out.println();
}
out.println();
for (Object category : study.getCategories()) {
out.print(category);
int catSum = 0;
for (ICodingAnnotationItem item : study.getItems()) {
int catCount = 0;
for (IAnnotationUnit unit : item.getUnits())
if (category.equals(unit.getCategory()))
catCount++;
out.print(DIVIDER + (catCount > 0 ? catCount : ""));
catSum += catCount;
}
out.println(DIVIDER + catSum);
}
/*
for (Object category : categories.keySet())
out.print(DIVIDER + category);
out.print(DIVIDER + "Σ");
out.println();
int i = 0;
int[] colSum = new int[study.getCategoryCount()];
for (Object category1 : categories.keySet()) {
out.print(category1);
int rowSum = 0;
for (int j = 0; j < categories.size(); j++) {
out.printf(DIVIDER + "%3d", frequencies[i][j]);
rowSum += frequencies[i][j];
colSum[j] += frequencies[i][j];
}
out.printf(DIVIDER + "%3d", rowSum);
out.println();
i++;
}
out.print("Σ");
int rowSum = 0;
for (int j = 0; j < categories.size(); j++) {
out.printf(DIVIDER + "%3d", colSum[j]);
rowSum += colSum[j];
}
out.printf(DIVIDER + "%3d", rowSum);
out.println();*/
} | java |
String getPackagePath(TypeElement te) {
return te.getQualifiedName().toString().replaceAll("." + te.getSimpleName(), "");
} | java |
String getFilename(TypeElement te, String fwk) {
return getFilename(te.getSimpleName().toString(), fwk);
} | java |
void writeCoreInClassesOutput() {
String resPath = ProcessorConstants.SEPARATORCHAR + "js";
fws.copyResourceToClassesOutput(resPath, "core.ng.min.js");
fws.copyResourceToClassesOutput(resPath, "core.ng.js");
fws.copyResourceToClassesOutput(resPath, "core.min.js");
fws.copyResourceToClassesOutput(resPath, "core.js");
} | java |
protected boolean fileExistsAndIsReadable(String filename) {
File f = new File(filename);
return f.exists() && f.isFile() && f.canRead();
} | java |
WSController getWSController() {
if (null == controller) {
controller = CDI.current().select(WSController.class).get();
// controller = getCdiBeanResolver().getBean(WSController.class);
}
return controller;
} | java |
@Override
public double calculateExpectedAgreement() {
Map<Object, int[]> annotationsPerCategory
= CodingAnnotationStudy.countAnnotationsPerCategory(study);
BigDecimal result = BigDecimal.ZERO;
for (Object category : study.getCategories()) {
int[] annotations = annotationsPerCategory.get(category);
if (annotations != null) {
BigDecimal prod = BigDecimal.ONE;
for (int rater = 0; rater < study.getRaterCount(); rater++)
prod = prod.multiply(new BigDecimal(annotations[rater]));
result = result.add(prod);
}
}
result = result.divide(new BigDecimal(study.getItemCount()).pow(2), MathContext.DECIMAL128);
return result.doubleValue();
} | java |
@Override
public double calculateCategoryAgreement(final Object category) {
// N = # subjects = #items -> index i
// n = # ratings/subject = #raters
// k = # categories -> index j
// n_ij = # raters that annotated item i as category j
//
// k_j = (P_j - p_j) / (1 - p_j)
// P_j = (sum( n_ij^2 ) - N n p_j) / (N n (n-1) p_j )
// p_j = 1/Nn sum n_ij
int N = study.getItemCount();
int n = study.getRaterCount();
int sum_nij = 0;
int sum_nij_2 = 0;
for (ICodingAnnotationItem item : study.getItems()) {
int nij = 0;
for (IAnnotationUnit unit : item.getUnits())
if (unit.getCategory().equals(category))
nij++;
sum_nij += nij;
sum_nij_2 += (nij * nij);
}
double pj = 1 / (double) (N * n) * sum_nij;
double Pj = (sum_nij_2 - N * n * pj) / (double) (N * n * (n - 1) * pj);
double kappaj = (Pj - pj) / (double) (1 - pj);
return kappaj;
} | java |
public IJsonMarshaller getIJsonMarshallerInstance(Class<? extends IJsonMarshaller> cls) throws JsonMarshallerException {
if(logger.isDebugEnabled()) {
logger.debug("Try to get {} by CDI.select Unsatisfied: {}", cls.getName(), CDI.current().select(cls).isUnsatisfied());
}
if(CDI.current().select(cls).isUnsatisfied()) {
throw new JsonMarshallerException(cls.getName()+" is Unsatisfied");
}
return CDI.current().select(cls).get();
} | java |
public static double getSignificance(double[] sample1, double[] sample2) throws IllegalArgumentException, MathException {
double alpha = TestUtils.pairedTTest(sample1, sample2);
boolean significance = TestUtils.pairedTTest(sample1, sample2, .30);
System.err.println("sig: " + significance);
return alpha;
} | java |
public static double getSignificance(double correlation1, double correlation2, int n1, int n2) throws MathException {
// transform to Fisher Z-values
double zv1 = FisherZTransformation.transform(correlation1);
double zv2 = FisherZTransformation.transform(correlation2);
// difference of the Z-values
double zDifference = (zv1 - zv2) / Math.sqrt(2d) / Math.sqrt( (double)1/(n1-3) + (double)1/(n2-3));
// get p value from the complementary error function
double p = Erf.erfc( Math.abs(zDifference));
return p;
} | java |
private AntBuilder getAnt() {
if (this.ant == null) {
AntBuilder ant = new AntBuilder();
BuildLogger logger = (BuildLogger) ant.getAntProject().getBuildListeners().get(0);
logger.setEmacsMode(true);
this.ant = ant;
}
return this.ant;
} | java |
public Method getMethodFromDataService(final Class dsClass, final MessageFromClient message, List<Object> arguments) throws NoSuchMethodException {
logger.debug("Try to find method {} on class {}", message.getOperation(), dsClass);
List<String> parameters = message.getParameters();
int nbparam = parameters.size() - getNumberOfNullEnderParameter(parameters); // determine how many parameter is null at the end
List<Method> candidates = getSortedCandidateMethods(message.getOperation(), dsClass.getMethods()); // take only method with the good name, and orderedby number of arguments
if (!candidates.isEmpty()) {
while (nbparam <= parameters.size()) {
for (Method method : candidates) {
if (method.getParameterTypes().length == nbparam) {
logger.debug("Process method {}", method.getName());
try {
checkMethod(method, arguments, parameters, nbparam);
logger.debug("Method {}.{} with good signature found.", dsClass, message.getOperation());
return method;
} catch (JsonMarshallerException | JsonUnmarshallingException | IllegalArgumentException iae) {
logger.debug("Method {}.{} not found. Some arguments didn't match. {}.", new Object[]{dsClass, message.getOperation(), iae.getMessage()});
}
arguments.clear();
}
}
nbparam++;
}
}
throw new NoSuchMethodException(dsClass.getName() + "." + message.getOperation());
} | java |
public Method getNonProxiedMethod(Class cls, String methodName, Class<?>... parameterTypes) throws NoSuchMethodException {
return cls.getMethod(methodName, parameterTypes);
} | java |
int getNumberOfNullEnderParameter(List<String> parameters) {
int nbnull = 0;
for (int i = parameters.size() - 1; i >= 0; i--) {
String parameter = parameters.get(i);
if (parameter.equals("null")) {
nbnull++;
} else {
break;
}
}
return nbnull;
} | java |
void checkMethod(Method method, List<Object> arguments, List<String> parameters, int nbparam) throws IllegalArgumentException, JsonUnmarshallingException, JsonMarshallerException {
Type[] paramTypes = method.getGenericParameterTypes();
Annotation[][] parametersAnnotations = method.getParameterAnnotations();
int idx = 0;
for (Type paramType : paramTypes) {
logger.debug("Try to convert argument ({}) {} : {}.", new Object[]{idx, paramType, parameters.get(idx)});
arguments.add(argumentConvertor.convertJsonToJava(parameters.get(idx), paramType, parametersAnnotations[idx]));
idx++;
if (idx > nbparam) {
throw new IllegalArgumentException();
}
}
} | java |
public void setARGB(int a, int r, int g, int b){
setValue(Pixel.argb(a, r, g, b));
} | java |
public void setRGB(int r, int g, int b){
setValue(Pixel.rgb(r, g, b));
} | java |
public void setRGB_preserveAlpha(int r, int g, int b){
setValue((getValue() & 0xff000000 ) | Pixel.argb(0, r, g, b));
} | java |
public static BufferedImage get(Image img, int imgType){
Function<Integer, ImageObserver> obs = flags->{
return (image, infoflags, x, y, width, height)->(infoflags & flags)!=flags;
};
BufferedImage bimg = new BufferedImage(
img.getWidth(obs.apply(ImageObserver.WIDTH)),
img.getHeight(obs.apply(ImageObserver.HEIGHT)),
imgType);
Graphics2D gr2D = bimg.createGraphics();
gr2D.drawImage(img, 0, 0, obs.apply(ImageObserver.ALLBITS));
gr2D.dispose();
return bimg;
} | java |
@Override
public int registerTopicSession(String topic, Session session) throws IllegalAccessException {
if (isInconsistenceContext(topic, session)) {
return 0;
}
Collection<Session> sessions;
if (map.containsKey(topic)) {
sessions = map.get(topic);
} else {
sessions = Collections.synchronizedCollection(new ArrayList<Session>());
map.put(topic, sessions);
}
topicAccessManager.checkAccessTopic(userContextFactory.getUserContext(session.getId()), topic);
logger.debug("'{}' subscribe to '{}'", session.getId(), topic);
if (session.isOpen()) {
sessions.add(session);
}
return getNumberSubscribers(topic);
} | java |
@Override
public int unregisterTopicSession(String topic, Session session) {
if (isInconsistenceContext(topic, session)) {
return 0;
}
logger.debug("'{}' unsubscribe to '{}'", session.getId(), topic);
if (Constants.Topic.ALL.equals(topic)) {
for (Map.Entry<String, Collection<Session>> entry : map.entrySet()) {
Collection<Session> sessions = entry.getValue();
removeSessionToSessions(session, sessions);
if (sessions.isEmpty()) {
map.remove(entry.getKey());
}
}
} else {
Collection<Session> sessions = map.get(topic);
removeSessionToSessions(session, sessions);
if (sessions==null || sessions.isEmpty()) {
map.remove(topic);
}
}
return getNumberSubscribers(topic);
} | java |
int removeSessionToSessions(Session session, Collection<Session> sessions) {
if (sessions != null) {
if (sessions.remove(session)) {
return 1;
}
}
return 0;
} | java |
boolean unregisterTopicSessions(String topic, Collection<Session> sessions) {
boolean unregister = false;
if (sessions != null && !sessions.isEmpty()) {
Collection<Session> all = map.get(topic);
if(all != null) {
unregister = all.removeAll(sessions);
if (all.isEmpty()) {
map.remove(topic);
}
}
}
return unregister;
} | java |
@Override
public Collection<String> removeSessionsToTopic(Collection<Session> sessions) {
if (sessions != null && !sessions.isEmpty()) {
Collection<String> topicUpdated = new ArrayList<>();
for (String topic : map.keySet()) {
if(unregisterTopicSessions(topic, sessions)) {
topicUpdated.add(topic);
sendSubscriptionEvent(Constants.Topic.SUBSCRIBERS + Constants.Topic.COLON + topic, getNumberSubscribers(topic));
}
}
return topicUpdated;
}
return Collections.EMPTY_LIST;
} | java |
@Override
public Collection<String> removeSessionToTopics(Session session) {
if (session != null) {
return removeSessionsToTopic(Arrays.asList(session));
// for (String topic : map.keySet()) {
// sendSubscriptionEvent(Constants.Topic.SUBSCRIBERS + Constants.Topic.COLON + topic, unregisterTopicSession(topic, session));
// }
}
return Collections.EMPTY_LIST;
} | java |
void sendSubscriptionEvent(String topic, int nb) {
Collection<Session> sessions = getSessionsForTopic(topic);
if (!sessions.isEmpty()) {
MessageToClient messageToClient = new MessageToClient();
messageToClient.setId(topic);
messageToClient.setType(MessageType.MESSAGE);
messageToClient.setResponse(nb);
// Collection<Session> sessionsClosed = new ArrayList<>(); // throws java.lang.StackOverflowError
for (Session session : sessions) {
if (session.isOpen()) {
session.getAsyncRemote().sendObject(messageToClient);
// } else {
// sessionsClosed.add(session);
}
}
// removeSessionsToTopic(sessionsClosed);
}
} | java |
@Override
public Collection<Session> getSessionsForTopic(String topic) {
Collection<Session> result;
if (map.containsKey(topic)) {
return Collections.unmodifiableCollection(map.get(topic));
} else {
result = Collections.EMPTY_LIST;
}
return result;
} | java |
@Override
public int getNumberSubscribers(String topic) {
if (map.containsKey(topic)) {
return map.get(topic).size();
}
return 0;
} | java |
public SSLSocketFactory getSSLSockectFactory() {
SSLContext context = null;
try {
context = SSLContext.getInstance("TLS");
} catch (NoSuchAlgorithmException e) {
throw new VOMSError(e.getMessage(), e);
}
KeyManager[] keyManagers = new KeyManager[] { credential.getKeyManager() };
X509TrustManager trustManager = SocketFactoryCreator
.getSSLTrustManager(validator);
TrustManager[] trustManagers = new TrustManager[] { trustManager };
SecureRandom secureRandom = null;
/* http://bugs.sun.com/view_bug.do?bug_id=6202721 */
/*
* Use new SecureRandom instead of SecureRandom.getInstance("SHA1PRNG") to
* avoid unnecessary blocking
*/
secureRandom = new SecureRandom();
try {
context.init(keyManagers, trustManagers, secureRandom);
} catch (KeyManagementException e) {
throw new VOMSError(e.getMessage(), e);
}
return context.getSocketFactory();
} | java |
public static void scaleArray(final double[] array, final double factor){
for(int i = 0; i < array.length; i++){
array[i] *= factor;
}
} | java |
@Override
public double calculateObservedDisagreement() {
ensureDistanceFunction();
double result = 0.0;
double maxDistance = 1.0;
for (ICodingAnnotationItem item : study.getItems()) {
Map<Object, Integer> annotationsPerCategory
= CodingAnnotationStudy.countTotalAnnotationsPerCategory(item);
for (Entry<Object, Integer> category1 : annotationsPerCategory.entrySet())
for (Entry<Object, Integer> category2 : annotationsPerCategory.entrySet()) {
if (category1.getValue() == null)
continue;
if (category2.getValue() == null)
continue;
double distance = distanceFunction.measureDistance(study,
category1.getKey(), category2.getKey());
result += category1.getValue() * category2.getValue()
* distance;
if (distance > maxDistance)
maxDistance = distance;
}
}
result /= (double) (maxDistance * study.getItemCount() * study.getRaterCount()
* (study.getRaterCount() - 1));
return result;
} | java |
String getJsInstancename(String classname) {
char chars[] = classname.toCharArray();
chars[0] = Character.toLowerCase(chars[0]);
return new String(chars);
//return Introspector.decapitalize(classname);
} | java |
String getJsClassname(TypeElement typeElement) {
DataService dsAnno = typeElement.getAnnotation(DataService.class);
String name = dsAnno.name();
if (name.isEmpty()) {
name = typeElement.getSimpleName().toString();
}
return name;
} | java |
void browseAndWriteMethods(List<ExecutableElement> methodElements, String classname, Writer writer) throws IOException {
Collection<String> methodProceeds = new ArrayList<>();
boolean first = true;
for (ExecutableElement methodElement : methodElements) {
if (isConsiderateMethod(methodProceeds, methodElement)) {
if(!first) {
writer.append(COMMA).append(CR);
}
visitMethodElement(classname, methodElement, writer);
first = false;
}
}
} | java |
protected List<ExecutableElement> getOrderedMethods(TypeElement typeElement, Comparator<ExecutableElement> comparator) {
List<ExecutableElement> methods = ElementFilter.methodsIn(typeElement.getEnclosedElements());
Collections.sort(methods, comparator);
return methods;
} | java |
List<String> getArgumentsType(ExecutableElement methodElement) {
ExecutableType methodType = (ExecutableType) methodElement.asType();
List<String> res = new ArrayList<>();
for (TypeMirror argumentType : methodType.getParameterTypes()) {
res.add(argumentType.toString());
}
return res;
} | java |
List<String> getArguments(ExecutableElement methodElement) {
List<String> res = new ArrayList<>();
for (VariableElement variableElement : methodElement.getParameters()) {
res.add(variableElement.toString());
}
return res;
} | java |
public CodingAnnotationStudy stripCategories(final Object keepCategory,
final Object nullCategory) {
CodingAnnotationStudy result = new CodingAnnotationStudy(getRaterCount());
for (ICodingAnnotationItem item : getItems()) {
CodingAnnotationItem newItem = new CodingAnnotationItem(raters.size());
for (IAnnotationUnit unit : item.getUnits()) {
Object newCategory;
if (!keepCategory.equals(unit.getCategory())) {
newCategory = nullCategory;
}
else {
newCategory = keepCategory;
}
newItem.addUnit(result.createUnit(result.items.size(),
unit.getRaterIdx(), newCategory));
}
result.items.add(newItem);
}
return result;
} | java |
public double computePhase(int idx){
double r = real[idx];
double i = imag[idx];
return atan2(r, i);
} | java |
private Map findLoaders() {
Map loaders = getContainer().getComponentDescriptorMap(ProviderLoader.class.getName());
if (loaders == null) {
throw new Error("No provider loaders found");
}
Set keys = loaders.keySet();
Map found = null;
ProviderLoader defaultLoader = null;
for (Iterator iter = keys.iterator(); iter.hasNext();) {
String key = (String)iter.next();
ProviderLoader loader;
try {
loader = (ProviderLoader) getContainer().lookup(ProviderLoader.class.getName(), key);
}
catch (Exception e) {
log.warn("Failed to lookup provider loader for key: {}", key, e);
continue;
}
if (loader != null) {
if (found == null) {
// we need an ordered map
found = new LinkedHashMap();
}
if (key.equals(SELECT_DEFAULT)) {
defaultLoader = loader;
}
else {
found.put(key, loader);
}
}
}
// the default should be added at the end (as fallback)
assert defaultLoader != null;
found.put(SELECT_DEFAULT, defaultLoader);
return found;
} | java |
public static byte[] getBytes(String text) {
byte[] bytes = new byte[] {};
try {
bytes = text.getBytes("utf-8");
} catch (UnsupportedEncodingException e) {
}
return bytes;
} | java |
public static byte[] loadBytesFromFile(File file) {
byte[] bytes = null;
try {
bytes = Files.readAllBytes(Paths.get(file.getAbsolutePath()));
} catch (IOException e) {
e.printStackTrace();
}
return bytes;
} | java |
public static void saveBytesToFile(byte[] data, File file) {
if (data == null) {
return;
}
FileOutputStream fos = null;
BufferedOutputStream bos = null;
try {
fos = new FileOutputStream(file);
bos = new BufferedOutputStream(fos);
bos.write(data);
bos.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (bos != null) {
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
} | java |
public static BufferedImage loadImage(String fileName){
File f = new File(fileName);
if(f.exists()){
return loadImage(f);
}
throw new ImageLoaderException(new FileNotFoundException(fileName));
} | java |
public static BufferedImage loadImage(File file){
try {
BufferedImage bimg = ImageIO.read(file);
if(bimg == null){
throw new ImageLoaderException("Could not load Image! ImageIO.read() returned null.");
}
return bimg;
} catch (IOException e) {
throw new ImageLoaderException(e);
}
} | java |
MessageToClient _createMessageToClient(MessageFromClient message, T session) {
MessageToClient messageToClient = new MessageToClient();
messageToClient.setId(message.getId());
try {
Class cls = Class.forName(message.getDataService());
Object dataService = this.getDataService(session, cls);
logger.debug("Process message {}", message);
List<Object> arguments = getArrayList();
Method method = methodServices.getMethodFromDataService(cls, message, arguments);
injectSession(method.getParameterTypes(), arguments, session);
messageToClient.setResult(method.invoke(dataService, arguments.toArray()));
if (method.isAnnotationPresent(JsonMarshaller.class)) {
messageToClient.setJson(argumentServices.getJsonResultFromSpecificMarshaller(method.getAnnotation(JsonMarshaller.class), messageToClient.getResponse()));
}
try {
Method nonProxiedMethod = methodServices.getNonProxiedMethod(cls, method.getName(), method.getParameterTypes());
messageToClient.setDeadline(cacheManager.processCacheAnnotations(nonProxiedMethod, message.getParameters()));
} catch (NoSuchMethodException ex) {
logger.error("Fail to process extra annotations (JsCacheResult, JsCacheRemove) for method : " + method.getName(), ex);
}
logger.debug("Method {} proceed messageToClient : {}.", method.getName(), messageToClient);
} catch (InvocationTargetException ex) {
Throwable cause = ex.getCause();
if (ConstraintViolationException.class.isInstance(cause)) {
messageToClient.setConstraints(constraintServices.extractViolations((ConstraintViolationException) cause));
} else {
messageToClient.setFault(faultServices.buildFault(cause));
}
} catch (Throwable ex) {
messageToClient.setFault(faultServices.buildFault(ex));
}
return messageToClient;
} | java |
void injectSession(Class<?>[] parameterTypes, List<Object> arguments, T session) {
if (parameterTypes != null) {
int i = 0;
for (Class<?> parameterType : parameterTypes) {
if (parameterType.isInstance(session)) {
arguments.set(i, session);
break;
}
i++;
}
}
} | java |
private void loadCertificateFromFile(File file) {
certificateFileSanityChecks(file);
try {
X509Certificate aaCert = CertificateUtils.loadCertificate(
new FileInputStream(file), Encoding.PEM);
// Get certificate subject hash, using the CANL implementation for CA
// files
String aaCertHash = getOpensslCAHash(aaCert.getSubjectX500Principal());
// Store certificate in the local map
localAACertificatesByHash.put(aaCertHash, aaCert);
synchronized (listenerLock) {
listener.notifyCertificateLoadEvent(aaCert, file);
}
} catch (IOException e) {
String errorMessage = String.format(
"Error parsing VOMS trusted certificate from %s. Reason: %s",
file.getAbsolutePath(), e.getMessage());
throw new VOMSError(errorMessage, e);
}
} | java |
private void certificateFileSanityChecks(File certFile) {
if (!certFile.exists())
throw new VOMSError("Local VOMS trusted certificate does not exist:"
+ certFile.getAbsolutePath());
if (!certFile.canRead())
throw new VOMSError("Local VOMS trusted certificate is not readable:"
+ certFile.getAbsolutePath());
} | java |
private void directorySanityChecks(File directory) {
if (!directory.exists())
throw new VOMSError("Local trust directory does not exists:"
+ directory.getAbsolutePath());
if (!directory.isDirectory())
throw new VOMSError("Local trust directory is not a directory:"
+ directory.getAbsolutePath());
if (!directory.canRead())
throw new VOMSError("Local trust directory is not readable:"
+ directory.getAbsolutePath());
if (!directory.canExecute())
throw new VOMSError("Local trust directory is not traversable:"
+ directory.getAbsolutePath());
} | java |
private boolean doesItemMatchAppropriateCondition(Object item) {
Matcher<?> matcher;
if (item instanceof View) {
matcher = loaded();
} else if (item instanceof Element) {
matcher = displayed();
} else {
matcher = present();
}
return matcher.matches(item);
} | java |
String getClassnameFromProxy(Object dataservice) {
String ds = dataservice.toString();
return getClassnameFromProxyname(ds);
} | java |
String getClassnameFromProxyname(String proxyname) {
Pattern pattern = Pattern.compile("[@$]");
Matcher matcher = pattern.matcher(proxyname);
matcher.find();
matcher.start();
return proxyname.substring(0, matcher.start());
} | java |
public static X509CertChainValidatorExt buildCertificateValidator() {
return buildCertificateValidator(
DefaultVOMSValidator.DEFAULT_TRUST_ANCHORS_DIR, null, null, 0L,
DEFAULT_NS_CHECKS, DEFAULT_CRL_CHECKS, DEFAULT_OCSP_CHECKS);
} | java |
public int getIndexOfMaxValue(int channel){
double[] values = getData()[channel];
int index = 0;
double val = values[index];
for(int i = 1; i < numValues(); i++){
if(values[i] > val){
index = i;
val = values[index];
}
}
return index;
} | java |
public int getIndexOfMinValue(int channel){
double[] values = getData()[channel];
int index = 0;
double val = values[index];
for(int i = 1; i < numValues(); i++){
if(values[i] < val){
index = i;
val = values[index];
}
}
return index;
} | java |
public void setValue(final int channel, final int x, final int y, final double value){
this.data[channel][y*this.width + x] = value;
} | java |
boolean isMonitored(HttpSession session) {
boolean monitor = false;
if (null != session && session.getAttribute(Constants.Options.OPTIONS) != null) {
monitor = ((Options) session.getAttribute(Constants.Options.OPTIONS)).isMonitor();
}
return monitor;
} | java |
public void saveToCache(String topic, Class<? extends JsTopicMessageController> cls) {
if(null != topic && null != cls) {
messageControllers.put(topic, cls);
}
} | java |
public JsTopicMessageController loadFromCache(String topic) {
if(null == topic) {
return null;
}
if(messageControllers.containsKey(topic)) {
Instance<? extends JsTopicMessageController> instances = getInstances(messageControllers.get(topic));
if(!instances.isUnsatisfied()) {
return instances.get();
}
}
return null;
} | java |
public static IUnitizingAnnotationUnit findNextUnit(
final Iterator<IUnitizingAnnotationUnit> units, int raterIdx) {
return findNextUnit(units, raterIdx, null);
} | java |
public static IUnitizingAnnotationUnit findNextUnit(
final Iterator<IUnitizingAnnotationUnit> units, final Object category) {
return findNextUnit(units, -1, category);
} | java |
public static IUnitizingAnnotationUnit findNextUnit(
final Iterator<IUnitizingAnnotationUnit> units, int raterIdx,
final Object category) {
while (units.hasNext()) {
IUnitizingAnnotationUnit result = units.next();
if (category != null && !category.equals(result.getCategory())) {
continue;
}
if (raterIdx < 0 || result.getRaterIdx() == raterIdx) {
return result;
}
}
return null;
} | java |
public static Object deserialize(String json, String containerType, Class cls, NestedContent nestedContent) throws ApiException {
try{
if(("List".equals(containerType) || "Array".equals(containerType)) && nestedContent != null){
if(NestedContent.CONTEXT.equals(nestedContent)){
JavaType typeInfo = JsonUtil.getJsonMapper().getTypeFactory().constructFromCanonical("java.util.List<java.util.List<io.cortical.rest.model.Context>>");
Object response = (java.lang.Object) JsonUtil.getJsonMapper().readValue(json, typeInfo);
return response;
}else if(NestedContent.TERM.equals(nestedContent)){
JavaType typeInfo = JsonUtil.getJsonMapper().getTypeFactory().constructFromCanonical("java.util.List<java.util.List<io.cortical.rest.model.Term>>");
Object response = (java.lang.Object) JsonUtil.getJsonMapper().readValue(json, typeInfo);
return response;
}else{
return null;
}
}
else if("List".equals(containerType) || "Array".equals(containerType)) {
JavaType typeInfo = JsonUtil.getJsonMapper().getTypeFactory().constructCollectionType(List.class, cls);
List response = (List<?>) JsonUtil.getJsonMapper().readValue(json, typeInfo);
return response;
}
else if(String.class.equals(cls)) {
if(json != null && json.startsWith("\"") && json.endsWith("\"") && json.length() > 1)
return json.substring(1, json.length() - 2);
else
return json;
}
else {
return JsonUtil.getJsonMapper().readValue(json, cls);
}
}
catch (IOException e) {
throw new ApiException(500, e.getMessage());
}
} | java |
public void checkAccessTopic(UserContext ctx, String topic) throws IllegalAccessException {
boolean tacPresent0 = checkAccessTopicGlobalAC(ctx, topic);
boolean tacPresent1 = checkAccessTopicFromJsTopicControl(ctx, topic);
boolean tacPresent2 = checkAccessTopicFromJsTopicControls(ctx, topic);
if (logger.isDebugEnabled() && !(tacPresent0 | tacPresent1 | tacPresent2)) {
logger.debug("No '{}' access control found in project, add {} implementation annotated with {}({}) in your project for add subscription security.", topic, JsTopicAccessController.class, JsTopicControl.class, topic);
}
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.