code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
public GroupUrls lookupGroup(String url) throws JinxException {
JinxUtils.validateParams(url);
Map<String, String> params = new TreeMap<>();
params.put("method", "flickr.urls.lookupGroup");
params.put("url", url);
return jinx.flickrGet(params, GroupUrls.class, false);
} | java |
public UserUrls lookupUser(String url) throws JinxException {
JinxUtils.validateParams(url);
Map<String, String> params = new TreeMap<>();
params.put("method", "flickr.urls.lookupUser");
params.put("url", url);
return jinx.flickrGet(params, UserUrls.class);
} | java |
public synchronized void storeToXML(OutputStream os, String comment)
throws IOException
{
if (os == null)
throw new NullPointerException();
storeToXML(os, comment, "UTF-8");
} | java |
public void list(PrintStream out) {
out.println("-- listing properties --");
Hashtable h = new Hashtable();
enumerate(h);
for (Enumeration e = h.keys() ; e.hasMoreElements() ;) {
String key = (String)e.nextElement();
String val = (String)h.get(key);
if (val.length() > 40) {
val = val.substring(0, 37) + "...";
}
out.println(key + "=" + val);
}
} | java |
@Deprecated
public Response browse(String categoryId) throws JinxException {
Map<String, String> params = new TreeMap<>();
params.put("method", "flickr.groups.browse");
return jinx.flickrGet(params, Response.class);
} | java |
public void setoAuthAccessToken(OAuthAccessToken oAuthAccessToken) {
this.oAuthAccessToken = oAuthAccessToken;
this.accessToken = new Token(oAuthAccessToken.getOauthToken(), oAuthAccessToken.getOauthTokenSecret());
} | java |
public static void setDecodeHintAllowedLengths(Intent intent, int[] lengths) {
intent.putExtra(DecodeHintType.ALLOWED_LENGTHS.name(), lengths);
} | java |
public PlaceInfo getInfo(String placeId, String woeId) throws JinxException {
if (JinxUtils.isNullOrEmpty(placeId)) {
JinxUtils.validateParams(woeId);
}
Map<String, String> params = new TreeMap<>();
params.put("method", "flickr.places.getInfo");
if (JinxUtils.isNullOrEmpty(placeId)) {
params.put("woe_id", woeId);
} else {
params.put("place_id", placeId);
}
return jinx.flickrGet(params, PlaceInfo.class, false);
} | java |
public Places getPlacesForBoundingBox(String boundingBox, JinxConstants.PlaceTypeId placeTypeId) throws JinxException {
JinxUtils.validateParams(boundingBox, placeTypeId);
Map<String, String> params = new TreeMap<>();
params.put("method", "flickr.places.placesForBoundingBox");
params.put("bbox", boundingBox);
params.put("place_type_id", placeTypeId.getTypeId().toString());
return jinx.flickrGet(params, Places.class, false);
} | java |
public Places getPlacesForContacts(JinxConstants.PlaceTypeId placeTypeId, String placeId, String woeId,
Integer threshold, JinxConstants.Contacts contacts,
Date minimumUploadDate, Date maximumUploadDate,
Date minimumTakenDate, Date maximumTakenDate) throws JinxException {
JinxUtils.validateParams(placeTypeId);
if (JinxUtils.isNullOrEmpty(placeId)) {
JinxUtils.validateParams(woeId);
}
Map<String, String> params = new TreeMap<>();
params.put("method", "flickr.places.placesForContacts");
params.put("place_type_id", placeTypeId.getTypeId().toString());
if (JinxUtils.isNullOrEmpty(placeId)) {
params.put("woe_id", woeId);
} else {
params.put("place_id", placeId);
}
if (threshold != null) {
params.put("threshold", threshold.toString());
}
if (contacts != null) {
params.put("contacts", contacts.toString());
}
if (minimumUploadDate != null) {
params.put("min_upload_date", JinxUtils.formatDateAsUnixTimestamp(minimumUploadDate));
}
if (maximumUploadDate != null) {
params.put("max_upload_date", JinxUtils.formatDateAsUnixTimestamp(maximumUploadDate));
}
if (minimumTakenDate != null) {
params.put("min_taken_date", JinxUtils.formatDateAsMySqlTimestamp(minimumTakenDate));
}
if (maximumTakenDate != null) {
params.put("max_taken_date", JinxUtils.formatDateAsMySqlTimestamp(maximumTakenDate));
}
return jinx.flickrGet(params, Places.class);
} | java |
public Methods getMethods() throws JinxException {
Map<String, String> params = new TreeMap<>();
params.put("method", "flickr.reflection.getMethods");
return jinx.flickrGet(params, Methods.class, false);
} | java |
public MethodInfo getMethodInfo(String methodName) throws JinxException {
JinxUtils.validateParams(methodName);
Map<String, String> params = new TreeMap<>();
params.put("method", "flickr.reflection.getMethodInfo");
params.put("method_name", methodName);
return jinx.flickrGet(params, MethodInfo.class, false);
} | java |
public Clusters getClusters(String tag) throws JinxException {
JinxUtils.validateParams(tag);
Map<String, String> params = new TreeMap<>();
params.put("method", "flickr.tags.getClusters");
params.put("tag", tag);
return jinx.flickrGet(params, Clusters.class, false);
} | java |
public PhotoTagList getListPhoto(String photoId) throws JinxException {
JinxUtils.validateParams(photoId);
Map<String, String> params = new TreeMap<>();
params.put("method", "flickr.tags.getListPhoto");
params.put("photo_id", photoId);
return jinx.flickrGet(params, PhotoTagList.class, false);
} | java |
public TagsForUser getMostFrequentlyUsed() throws JinxException {
Map<String, String> params = new TreeMap<>();
params.put("method", "flickr.tags.getMostFrequentlyUsed");
return jinx.flickrGet(params, TagsForUser.class);
} | java |
public RelatedTags getRelated(String tag) throws JinxException {
JinxUtils.validateParams(tag);
Map<String, String> params = new TreeMap<>();
params.put("method", "flickr.tags.getRelated");
params.put("tag", tag);
return jinx.flickrGet(params, RelatedTags.class);
} | java |
public String getPhotosFirstDateTaken() {
return (person == null || person.photos == null || person.photos.firstDateTaken == null) ? null : person.photos.firstDateTaken._content;
} | java |
public String getPhotosFirstDate() {
return (person == null || person.photos == null || person.photos.firstDate == null) ? null : person.photos.firstDate._content;
} | java |
public CameraModels getBrandModels(String brandId) throws JinxException {
JinxUtils.validateParams(brandId);
Map<String, String> params = new TreeMap<>();
params.put("method", "flickr.cameras.getBrandModels");
params.put("brand", brandId);
return jinx.flickrGet(params, CameraModels.class, false);
} | java |
public static String generateAuthorizeUrl(String oAuthUri, String clientId, String[] scope){
StringBuilder sb = new StringBuilder(oAuthUri);
sb.append("/oauth/authorize?response_type=code");
sb.append("&client_id=" + clientId);
if (scope != null) {
sb.append("&scope=");
for (int i = 0; i < scope.length; i++) {
if (i > 0) {
sb.append("%20");
}
sb.append(scope[i]);
}
}
return sb.toString();
} | java |
public Response correctLocation(String photoId, String placeId, String woeId, String foursquareId) throws JinxException {
JinxUtils.validateParams(photoId);
if (JinxUtils.isNullOrEmpty(placeId)) {
JinxUtils.validateParams(woeId);
}
Map<String, String> params = new TreeMap<>();
params.put("method", "flickr.photos.geo.correctLocation");
params.put("photo_id", photoId);
if (!JinxUtils.isNullOrEmpty(placeId)) {
params.put("place_id", placeId);
}
if (!JinxUtils.isNullOrEmpty(woeId)) {
params.put("woe_id", woeId);
}
if (!JinxUtils.isNullOrEmpty(foursquareId)) {
params.put("foursquare_id", foursquareId);
}
return jinx.flickrPost(params, Response.class);
} | java |
public GalleryInfo galleryInfo(String galleryId) throws JinxException {
JinxUtils.validateParams(galleryId);
Map<String, String> params = new TreeMap<>();
params.put("method", "flickr.galleries.getInfo");
params.put("gallery_id", galleryId);
return jinx.flickrPost(params, GalleryInfo.class);
} | java |
public Subscriptions getSubscriptions() throws JinxException {
Map<String, String> params = new TreeMap<>();
params.put("method", "flickr.push.getSubscriptions");
return jinx.flickrGet(params, Subscriptions.class);
} | java |
public Topics getTopics() throws JinxException {
Map<String, String> params = new TreeMap<>();
params.put("method", "flickr.push.getTopics");
return jinx.flickrGet(params, Topics.class);
} | java |
public Response subscribe(String topic, String callbackUrl, JinxConstants.VerificationMode mode,
String verificationToken, Integer leaseSeconds, Integer woeIds,
List<String> placeIds, Float latitude, Float longitude, Integer radius,
JinxConstants.RadiusUnits radiusUnits, Integer accuracy, List<String> commonsNSIDs,
List<String> tags) throws JinxException {
JinxUtils.validateParams(topic, callbackUrl, mode);
Map<String, String> params = new TreeMap<>();
params.put("method", "flickr.push.subscribe");
params.put("topic", topic);
params.put("callback", callbackUrl);
params.put("verify", mode.toString());
if (!JinxUtils.isNullOrEmpty(verificationToken)) {
params.put("verify_token", verificationToken);
}
if (leaseSeconds != null && leaseSeconds > 59) {
params.put("lease_seconds", leaseSeconds.toString());
}
if (woeIds != null) {
params.put("woe_ids", woeIds.toString());
}
if (!JinxUtils.isNullOrEmpty(placeIds)) {
params.put("place_ids", JinxUtils.buildCommaDelimitedList(placeIds));
}
if (latitude != null) {
params.put("lat", latitude.toString());
}
if (longitude != null) {
params.put("lon", longitude.toString());
}
if (radius != null) {
params.put("radius", radius.toString());
}
if (radiusUnits != null) {
params.put("radius_units", radiusUnits.toString());
}
if (accuracy != null) {
params.put("accuracy", accuracy.toString());
}
if (!JinxUtils.isNullOrEmpty(commonsNSIDs)) {
params.put("nsids", JinxUtils.buildCommaDelimitedList(commonsNSIDs));
}
if (!JinxUtils.isNullOrEmpty(tags)) {
params.put("tags", JinxUtils.buildCommaDelimitedList(tags));
}
return jinx.flickrGet(params, Response.class);
} | java |
public Response unsubscribe(String topic, String callbackUrl, JinxConstants.VerificationMode mode, String verificationToken) throws JinxException {
JinxUtils.validateParams(topic, callbackUrl, mode);
Map<String, String> params = new TreeMap<>();
params.put("method", "flickr.push.unsubscribe");
params.put("topic", topic);
params.put("callback", callbackUrl);
params.put("verify", mode.toString());
if (!JinxUtils.isNullOrEmpty(verificationToken)) {
params.put("verify_token", verificationToken);
}
return jinx.flickrGet(params, Response.class);
} | java |
public void log(String message, Throwable t) {
System.out.println(message);
System.out.println(getStackTrace(t));
} | java |
public synchronized void stopPreview() {
if (autoFocusManager != null) {
autoFocusManager.stop();
autoFocusManager = null;
}
if (camera != null && previewing) {
camera.stopPreview();
previewCallback.setHandler(null, 0);
previewing = false;
}
} | java |
public Integer getPerPage() {
int ret = 0;
if (photos != null) {
int pp;
if (photos.perpage == null) {
pp = 0;
} else {
pp = photos.perpage;
}
int pP;
if (photos.perPage == null ) {
pP = 0;
} else {
pP = photos.perPage;
}
if (pp > pP) {
ret = pp;
} else {
ret = pP;
}
}
return ret;
} | java |
public String getComment(String key) {
String raw = getRawComment(key);
return cookComment(raw);
} | java |
public static BufferedImage getImageForSize(JinxConstants.PhotoSize size, Photo photo) throws JinxException {
if (photo == null || size == null) {
throw new JinxException("Cannot look up null photo or size.");
}
BufferedImage image;
try {
image = ImageIO.read(getUrlForSize(size, photo));
} catch (JinxException je) {
throw je;
} catch (Exception e) {
throw new JinxException("Unable to get image for size " + size.toString(), e);
}
return image;
} | java |
public static BufferedImage getImageForSize(JinxConstants.PhotoSize size, PhotoInfo info) throws JinxException {
if (info == null || size == null) {
throw new JinxException("Cannot look up null photo or size.");
}
BufferedImage image;
try {
image = ImageIO.read(getUrlForSize(size, info));
} catch (JinxException je) {
throw je;
} catch (Exception e) {
throw new JinxException("Unable to get image for size " + size.toString(), e);
}
return image;
} | java |
public static URL getUrlForSize(
JinxConstants.PhotoSize size, String photoId, String secret, String farm, String server, String originalFormat, String originalSecret) throws JinxException {
JinxUtils.validateParams(photoId, size, farm, server);
if (size == JinxConstants.PhotoSize.SIZE_ORIGINAL) {
JinxUtils.validateParams(originalFormat, originalSecret);
} else {
JinxUtils.validateParams(secret);
}
StringBuilder sb = new StringBuilder("https://farm");
sb.append(farm);
sb.append(".static.flickr.com/");
sb.append(server).append("/");
sb.append(photoId).append('_');
switch (size) {
case SIZE_SMALL_SQUARE:
sb.append(secret).append("_s.jpg");
break;
case SIZE_LARGE_SQUARE:
sb.append(secret).append("_q.jpg");
break;
case SIZE_THUMBNAIL:
sb.append(secret).append("_t.jpg");
break;
case SIZE_SMALL:
sb.append(secret).append("_m.jpg");
break;
case SIZE_SMALL_320:
sb.append(secret).append("_n.jpg");
break;
case SIZE_MEDIUM:
sb.append(secret).append(".jpg");
break;
case SIZE_MEDIUM_640:
sb.append(secret).append("_z.jpg");
break;
case SIZE_MEDIUM_800:
sb.append(secret).append("_c.jpg");
break;
case SIZE_LARGE:
sb.append(secret).append("_b.jpg");
break;
case SIZE_LARGE_1600:
sb.append(secret).append("_h.jpg");
break;
case SIZE_LARGE_2048:
sb.append(secret).append("_k.jpg");
break;
case SIZE_ORIGINAL:
sb.append(originalSecret).append("_o");
sb.append('.').append(originalFormat);
break;
default:
throw new JinxException("Undefined size: " + size);
}
try {
return new URL(sb.toString());
} catch (Exception e) {
throw new JinxException("Could not create URL from string " + sb.toString());
}
} | java |
public Person getContentType() throws JinxException {
Map<String, String> params = new TreeMap<>();
params.put("method", "flickr.prefs.getContentType");
return jinx.flickrGet(params, Person.class);
} | java |
public boolean cancelJob(String slaveJobId) {
final AnalysisResultFuture resultFuture = _runningJobs.remove(slaveJobId);
if (resultFuture != null) {
resultFuture.cancel();
return true;
}
return false;
} | java |
protected final boolean entityExists(final String entityName) {
final Set<EntityType<?>> entityTypes = getEm().getMetamodel().getEntities();
for (final EntityType<?> entityType : entityTypes) {
if (entityType.getName().equals(entityName)) {
return true;
}
}
return false;
} | java |
protected final String createJpqlStreamSelect(final StreamId streamId) {
if (streamId.isProjection()) {
throw new IllegalArgumentException("Projections do not have a stream table : " + streamId);
}
final List<KeyValue> params = new ArrayList<>(streamId.getParameters());
if (params.size() == 0) {
// NoParamsStream
params.add(new KeyValue("streamName", streamId.getName()));
}
final StringBuilder sb = new StringBuilder("SELECT t FROM " + streamEntityName(streamId) + " t");
sb.append(" WHERE ");
for (int i = 0; i < params.size(); i++) {
final KeyValue param = params.get(i);
if (i > 0) {
sb.append(" AND ");
}
sb.append("t." + param.getKey() + "=:" + param.getKey());
}
return sb.toString();
} | java |
@NotNull
protected final JpaStream findStream(@NotNull final StreamId streamId) {
Contract.requireArgNotNull("streamId", streamId);
verifyStreamEntityExists(streamId);
final String sql = createJpqlStreamSelect(streamId);
final TypedQuery<JpaStream> query = getEm().createQuery(sql, JpaStream.class);
setJpqlParameters(query, streamId);
final List<JpaStream> streams = query.getResultList();
if (streams.size() == 0) {
throw new StreamNotFoundException(streamId);
}
final JpaStream stream = streams.get(0);
if (stream.getState() == StreamState.SOFT_DELETED) {
// TODO Remove after event store has a way to distinguish between
// never-existing and soft deleted
// streams
throw new StreamNotFoundException(streamId);
}
return stream;
} | java |
private final String createNativeSqlEventSelect(final StreamId streamId,
final List<NativeSqlCondition> conditions) {
final StringBuilder sb = new StringBuilder("SELECT " + JPA_EVENT_PREFIX + ".* FROM "
+ JpaEvent.TABLE_NAME + " " + JPA_EVENT_PREFIX + ", " + nativeEventsTableName(streamId) + " "
+ JPA_STREAM_EVENT_PREFIX + " WHERE " + JPA_EVENT_PREFIX + "." + JpaEvent.COLUMN_ID + "="
+ JPA_STREAM_EVENT_PREFIX + "." + JpaStreamEvent.COLUMN_EVENTS_ID);
for (final NativeSqlCondition condition : conditions) {
sb.append(" AND ");
sb.append(condition.asWhereConditionWithParam());
}
return sb.toString();
} | java |
public void delete(final boolean hardDelete) {
if (hardDelete) {
this.state = StreamState.HARD_DELETED.dbValue();
} else {
this.state = StreamState.SOFT_DELETED.dbValue();
}
} | java |
public boolean removeDatastore(final String datastoreName) {
final Element datastoreCatalogElement = getDatastoreCatalogElement();
final NodeList childNodes = datastoreCatalogElement.getChildNodes();
final int length = childNodes.getLength();
for (int i = 0; i < length; i++) {
final Node node = childNodes.item(i);
if (node instanceof Element) {
final Element element = (Element) node;
final Attr[] attributes = XmlDomDataContext.getAttributes(element);
for (Attr attr : attributes) {
if ("name".equals(attr.getName())) {
final String value = attr.getValue();
if (datastoreName.equals(value)) {
// we have a match
datastoreCatalogElement.removeChild(element);
onDocumentChanged(getDocument());
return true;
}
}
}
}
}
return false;
} | java |
public final void add(@NotNull final SerializedDataType type, final String contentType,
@NotNull final SerDeserializer serDeserializer) {
this.addSerializer(type, serDeserializer);
this.addDeserializer(type, contentType, serDeserializer);
} | java |
public final void addDeserializer(@NotNull final SerializedDataType type, final String contentType,
@NotNull final Deserializer deserializer) {
Contract.requireArgNotNull("type", type);
Contract.requireArgNotNull("contentType", contentType);
Contract.requireArgNotNull("deserializer", deserializer);
final Key key = new Key(type, contentType);
desMap.put(key, deserializer);
} | java |
public final void setDefaultContentType(@NotNull final SerializedDataType type,
final EnhancedMimeType contentType) {
Contract.requireArgNotNull("type", type);
Contract.requireArgNotNull("contentType", contentType);
contentTypes.put(type, contentType);
} | java |
public final void addSerializer(@NotNull final SerializedDataType type,
@NotNull final Serializer serializer) {
Contract.requireArgNotNull("type", type);
Contract.requireArgNotNull("serializer", serializer);
serMap.put(type, serializer);
} | java |
public void compileProgram() {
program.inputs().forEach(var -> var.calculateFuzzySpace());
program.outputs().forEach(var -> var.calculateFuzzySpace());
program.rules().forEach(rule -> {
updateMemberReferenceCount(rule.getCondition());
rule.assignmentMembers().forEach(member -> member.incrReferenceCount());
});
} | java |
public MutableInputColumn<?> getOutputColumnByName(String name) {
if (StringUtils.isNullOrEmpty(name)) {
return null;
}
final List<MutableInputColumn<?>> outputColumns = getOutputColumns();
for (MutableInputColumn<?> inputColumn : outputColumns) {
if (name.equals(inputColumn.getName())) {
return inputColumn;
}
}
return null;
} | java |
public static InvalidEntityKanbaneryException mostSpecializedException(String response) {
//todo refactor this!!!
if (response == null || "".equals(response)) {
return new InvalidEntityKanbaneryException(response);
} else if (TaskAlreadyInFirstColumnException.isBestExceptionFor(response)) {
return new TaskAlreadyInFirstColumnException(response);
} else if (TaskAlreadyInLastColumnException.isBestExceptionFor(response)) {
return new TaskAlreadyInLastColumnException(response);
} else if (PositionExceedsNumberOfTasksInColumnException.isBestExceptionFor(response)) {
return new PositionExceedsNumberOfTasksInColumnException(response);
} else if (CanOnlyIceBoxTaskFromFirstColumnException.isBestExceptionFor(response)) {
return new CanOnlyIceBoxTaskFromFirstColumnException(response);
} else if (CanOnlyArchiveFromLastColumnException.isBestExceptionFor(response)) {
return new CanOnlyArchiveFromLastColumnException(response);
} else if (NotFixedColumnCannotBeFirstException.isBestExceptionFor(response)) {
return new NotFixedColumnCannotBeFirstException(response);
} else if (BodyMustNotBeBlankException.isBestExceptionFor(response)) {
return new BodyMustNotBeBlankException(response);
} else if (MaximumNumbersOfCollaboratorsReachedException.isBestExceptionFor(response)) {
return new MaximumNumbersOfCollaboratorsReachedException(response);
} else if (UserAlreadyAssignedToThisProjectException.isBestExceptionFor(response)) {
return new UserAlreadyAssignedToThisProjectException(response);
} else if (ProjectOwnerCanNotBeGivenProjectMembership.isBestExceptionFor(response)) {
return new ProjectOwnerCanNotBeGivenProjectMembership(response);
} else if (CanNotDeleteColumnThatContainsTasksException.isBestExceptionFor(response)) {
return new CanNotDeleteColumnThatContainsTasksException(response);
} else {
return new InvalidEntityKanbaneryException(response);
}
} | java |
@Initialize
public void init() {
logger.info("Initializing dictionary: {}", this);
Datastore datastore = getDatastore();
DatastoreConnection dataContextProvider = datastore.openConnection();
getDatastoreConnections().add(dataContextProvider);
} | java |
public static ClassLoader getParentClassLoader() {
logger.debug("getParentClassLoader() invoked, web start mode: {}", IS_WEB_START);
if (IS_WEB_START) {
return Thread.currentThread().getContextClassLoader();
} else {
return ClassLoaderUtils.class.getClassLoader();
}
} | java |
protected Crosstab<Serializable> createMasterCrosstab(Collection<? extends R> results) {
final R firstResult = results.iterator().next();
final Crosstab<?> firstCrosstab = firstResult.getCrosstab();
final Class<?> valueClass = firstCrosstab.getValueClass();
final CrosstabDimension dimension1 = firstCrosstab.getDimension(0);
final CrosstabDimension dimension2 = firstCrosstab.getDimension(1);
@SuppressWarnings({ "unchecked", "rawtypes" })
final Crosstab<Serializable> masterCrosstab = new Crosstab(valueClass, dimension1, dimension2);
return masterCrosstab;
} | java |
public void startFragment(Fragment fragment, String tag, boolean canAddToBackstack) {
FragmentTransaction transaction = getSupportFragmentManager().beginTransaction().replace(R.id.fragmentContainer, fragment);
if (canAddToBackstack) {
transaction.addToBackStack(tag);
}
transaction.commit();
} | java |
public void calculateFuzzySpace() {
double start = getFrom().doubleValue();
double stop = getTo().doubleValue();
double step = getStep().doubleValue();
// enumerate the variable range
members().forEach(member -> {
if (member.haveFunctionCall()) {
for (double i = start; i <= stop; i += step) {
member.calculateFunctionAt(i);
}
} else {
member.calculateEndPoints(start, stop);
for (double i = start; i <= stop; i += step) {
member.calculateValueAt(i);
}
}
});
// find the max over all members
double yMax = Double.MIN_VALUE;
for (Member member : members()) {
double memberMax = member.findMax();
yMax = memberMax > yMax ? memberMax : yMax;
}
// normalize exploded values into a byte range
for (Member member : members()) {
member.normalizeY(yMax, 255);
totalSteps = Math.max(totalSteps, member.normalized().size());
}
this.calculated = true;
} | java |
static void accessFailed() throws Throwable
{
String controllerClassName = getControllerClass().getName();
Logger.debug("Deadbolt: Access failure on [%s]",
controllerClassName);
String responseFormat = null;
if (getActionAnnotation(JSON.class) != null)
{
responseFormat = "json";
}
else if (getActionAnnotation(XML.class) != null)
{
responseFormat = "xml";
}
else if (getControllerAnnotation(JSON.class) != null)
{
responseFormat = "json";
}
else if (getControllerAnnotation(XML.class) != null)
{
responseFormat = "xml";
}
else
{
String defaultResponseFormat = Play.configuration.getProperty(DEFAULT_RESPONSE_FORMAT);
if (!isEmpty(defaultResponseFormat))
{
responseFormat = defaultResponseFormat;
}
}
if (!isEmpty(responseFormat))
{
request.format = responseFormat;
}
DEADBOLT_HANDLER.onAccessFailure(controllerClassName);
} | java |
public static boolean hasAllRoles(RoleHolder roleHolder,
String[] roleNames)
{
boolean hasRole = false;
if (roleHolder != null)
{
List<? extends Role> roles = roleHolder.getRoles();
if (roles != null)
{
List<String> heldRoles = new ArrayList<String>();
for (Role role : roles)
{
if (role != null)
{
heldRoles.add(role.getRoleName());
}
}
boolean roleCheckResult = true;
for (int i = 0; roleCheckResult && i < roleNames.length; i++)
{
boolean invert = false;
String roleName = roleNames[i];
if (roleName.startsWith("!"))
{
invert = true;
roleName = roleName.substring(1);
}
roleCheckResult = heldRoles.contains(roleName);
if (invert)
{
roleCheckResult = !roleCheckResult;
}
}
hasRole = roleCheckResult;
}
}
return hasRole;
} | java |
public static boolean hasRoles(List<String> roleNames) throws Throwable
{
DEADBOLT_HANDLER.beforeRoleCheck();
RoleHolder roleHolder = getRoleHolder();
return roleHolder != null &&
roleHolder.getRoles() != null &&
hasAllRoles(roleHolder,
roleNames.toArray(new String[roleNames.size()]));
} | java |
public void put(E value, boolean createCategories) throws IllegalArgumentException, NullPointerException {
if (createCategories) {
for (int i = 0; i < categories.length; i++) {
String category = categories[i];
CrosstabDimension dimension = crosstab.getDimension(i);
dimension.addCategory(category);
}
}
crosstab.putValue(value, categories);
} | java |
protected String getHeaderValue(HtmlRenderingContext context, int col, String columnName) {
return context.escapeHtml(columnName);
} | java |
public final String asWhereConditionWithParam() {
if (table == null) {
return column + operator + ":" + column;
}
return table + "." + column + operator + ":" + column;
} | java |
public static List<RowProcessingConsumer> sortConsumers(List<RowProcessingConsumer> consumers) {
final RowProcessingConsumerSorter sorter = new RowProcessingConsumerSorter(consumers);
final List<RowProcessingConsumer> sortedConsumers = sorter.createProcessOrderedConsumerList();
if (logger.isDebugEnabled()) {
logger.debug("Row processing order ({} consumers):", sortedConsumers.size());
int i = 1;
for (RowProcessingConsumer rowProcessingConsumer : sortedConsumers) {
logger.debug(" {}) {}", i, rowProcessingConsumer);
i++;
}
}
return sortedConsumers;
} | java |
public void processRows(RowProcessingMetrics rowProcessingMetrics) {
final RowProcessingQueryOptimizer queryOptimizer = getQueryOptimizer();
final Query finalQuery = queryOptimizer.getOptimizedQuery();
final RowIdGenerator idGenerator;
if (finalQuery.getFirstRow() == null) {
idGenerator = new SimpleRowIdGenerator();
} else {
idGenerator = new SimpleRowIdGenerator(finalQuery.getFirstRow());
}
final AnalysisJob analysisJob = _publishers.getAnalysisJob();
final AnalysisListener analysisListener = _publishers.getAnalysisListener();
final TaskRunner taskRunner = _publishers.getTaskRunner();
for (RowProcessingConsumer rowProcessingConsumer : _consumers) {
if (rowProcessingConsumer instanceof AnalyzerConsumer) {
final AnalyzerConsumer analyzerConsumer = (AnalyzerConsumer) rowProcessingConsumer;
final AnalyzerJob analyzerJob = analyzerConsumer.getComponentJob();
final AnalyzerMetrics metrics = rowProcessingMetrics.getAnalysisJobMetrics().getAnalyzerMetrics(
analyzerJob);
analysisListener.analyzerBegin(analysisJob, analyzerJob, metrics);
}
if (rowProcessingConsumer instanceof TransformerConsumer) {
((TransformerConsumer) rowProcessingConsumer).setRowIdGenerator(idGenerator);
}
}
final List<RowProcessingConsumer> consumers = queryOptimizer.getOptimizedConsumers();
final Collection<? extends FilterOutcome> availableOutcomes = queryOptimizer.getOptimizedAvailableOutcomes();
analysisListener.rowProcessingBegin(analysisJob, rowProcessingMetrics);
final RowConsumerTaskListener taskListener = new RowConsumerTaskListener(analysisJob, analysisListener,
taskRunner);
final Datastore datastore = _publishers.getDatastore();
try (final DatastoreConnection con = datastore.openConnection()) {
final DataContext dataContext = con.getDataContext();
if (logger.isDebugEnabled()) {
final String queryString;
if (dataContext instanceof JdbcDataContext) {
final JdbcDataContext jdbcDataContext = (JdbcDataContext) dataContext;
queryString = jdbcDataContext.getQueryRewriter().rewriteQuery(finalQuery);
} else {
queryString = finalQuery.toSql();
}
logger.debug("Final query: {}", queryString);
logger.debug("Final query firstRow={}, maxRows={}", finalQuery.getFirstRow(), finalQuery.getMaxRows());
}
// represents the distinct count of rows as well as the number of
// tasks to execute
int numTasks = 0;
try (final DataSet dataSet = dataContext.executeQuery(finalQuery)) {
final ConsumeRowHandler consumeRowHandler = new ConsumeRowHandler(consumers, availableOutcomes);
while (dataSet.next()) {
if (taskListener.isErrornous()) {
break;
}
numTasks++;
final Row metaModelRow = dataSet.getRow();
final int rowId = idGenerator.nextPhysicalRowId();
final MetaModelInputRow inputRow = new MetaModelInputRow(rowId, metaModelRow);
final ConsumeRowTask task = new ConsumeRowTask(consumeRowHandler, rowProcessingMetrics, inputRow,
analysisListener, numTasks);
taskRunner.run(task, taskListener);
}
}
taskListener.awaitTasks(numTasks);
}
if (taskListener.isErrornous()) {
_successful.set(false);
return;
}
analysisListener.rowProcessingSuccess(analysisJob, rowProcessingMetrics);
} | java |
public AbstractDatastoreType createPojoDatastore(final Datastore datastore, final Set<Column> columns,
final int maxRowsToQuery) {
final PojoDatastoreType datastoreType = new PojoDatastoreType();
datastoreType.setName(datastore.getName());
datastoreType.setDescription(datastore.getDescription());
try (final DatastoreConnection con = datastore.openConnection()) {
final DataContext dataContext = con.getDataContext();
final Schema schema;
final Table[] tables;
if (columns == null || columns.isEmpty()) {
schema = dataContext.getDefaultSchema();
tables = schema.getTables();
} else {
tables = MetaModelHelper.getTables(columns);
// TODO: There's a possibility that tables span multiple
// schemas, but we cannot currently support that in a
// PojoDatastore, so we just pick the first and cross our
// fingers.
schema = tables[0].getSchema();
}
datastoreType.setSchemaName(schema.getName());
for (final Table table : tables) {
final Column[] usedColumns;
if (columns == null || columns.isEmpty()) {
usedColumns = table.getColumns();
} else {
usedColumns = MetaModelHelper.getTableColumns(table, columns);
}
final PojoTableType tableType = createPojoTable(dataContext, table, usedColumns, maxRowsToQuery);
datastoreType.getTable().add(tableType);
}
}
return datastoreType;
} | java |
public static Data valueOf(final String type, final Object obj) {
return new Data(type, mimeType(obj), content(obj));
} | java |
public void run(R row, String value, int distinctCount) {
final List<Token> tokens;
boolean match = false;
try {
tokens = _tokenizer.tokenize(value);
} catch (RuntimeException e) {
throw new IllegalStateException("Error occurred while tokenizing value: " + value, e);
}
final String patternCode = getPatternCode(tokens);
Set<TokenPattern> patterns;
synchronized (this) {
patterns = _patterns.get(patternCode);
if (patterns == null) {
patterns = new HashSet<TokenPattern>();
_patterns.put(patternCode, patterns);
}
for (TokenPattern pattern : patterns) {
if (pattern.match(tokens)) {
storeMatch(pattern, row, value, distinctCount);
match = true;
}
}
if (!match) {
final TokenPattern pattern;
try {
pattern = new TokenPatternImpl(value, tokens, _configuration);
} catch (RuntimeException e) {
throw new IllegalStateException("Error occurred while creating pattern for: " + tokens, e);
}
storeNewPattern(pattern, row, value, distinctCount);
patterns.add(pattern);
}
}
} | java |
public String map(String name) {
String mapped = super.get(name);
if (mapped == null) {
mapped = String.format("%s%03d", BASENAME, count.incrementAndGet());
super.put(name, mapped);
}
return mapped;
} | java |
public static KAFDocument createFromFile(File file) throws IOException {
KAFDocument kaf = null;
try {
kaf = ReadWriteManager.load(file);
} catch(JDOMException e) {
e.printStackTrace();
}
return kaf;
} | java |
public static KAFDocument createFromStream(Reader stream) throws IOException, JDOMException {
KAFDocument kaf = null;
kaf = ReadWriteManager.load(stream);
return kaf;
} | java |
public LinguisticProcessor addLinguisticProcessor(String layer, String name) {
LinguisticProcessor lp = new LinguisticProcessor(name, layer);
//lp.setBeginTimestamp(timestamp); // no default timestamp
List<LinguisticProcessor> layerLps = lps.get(layer);
if (layerLps == null) {
layerLps = new ArrayList<LinguisticProcessor>();
lps.put(layer, layerLps);
}
layerLps.add(lp);
return lp;
} | java |
public boolean linguisticProcessorExists(String layer, String name, String version) {
List<LinguisticProcessor> layerLPs = lps.get(layer);
if (layerLPs == null) {
return false;
}
for (LinguisticProcessor lp : layerLPs) {
if (lp.version == null) {
return false;
}
else if (lp.name.equals(name) && lp.version.equals(version)) {
return true;
}
}
return false;
} | java |
public Term newTerm(String id, Span<WF> span) {
idManager.updateCounter(AnnotationType.TERM, id);
Term newTerm = new Term(id, span, false);
annotationContainer.add(newTerm, Layer.TERMS, AnnotationType.TERM);
addToWfTermIndex(newTerm.getSpan().getTargets(), newTerm); // Rodrirekin hitz egin hau kentzeko
return newTerm;
} | java |
public Dep newDep(Term from, Term to, String rfunc) {
Dep newDep = new Dep(from, to, rfunc);
annotationContainer.add(newDep, Layer.DEPS, AnnotationType.DEP);
return newDep;
} | java |
public Chunk newChunk(String id, String phrase, Span<Term> span) {
idManager.updateCounter(AnnotationType.CHUNK, id);
Chunk newChunk = new Chunk(id, span);
newChunk.setPhrase(phrase);
annotationContainer.add(newChunk, Layer.CHUNKS, AnnotationType.CHUNK);
return newChunk;
} | java |
public Chunk newChunk(String phrase, Span<Term> span) {
String newId = idManager.getNextId(AnnotationType.CHUNK);
Chunk newChunk = new Chunk(newId, span);
newChunk.setPhrase(phrase);
annotationContainer.add(newChunk, Layer.CHUNKS, AnnotationType.CHUNK);
return newChunk;
} | java |
public Entity newEntity(String id, List<Span<Term>> references) {
idManager.updateCounter(AnnotationType.ENTITY, id);
Entity newEntity = new Entity(id, references);
annotationContainer.add(newEntity, Layer.ENTITIES, AnnotationType.ENTITY);
return newEntity;
} | java |
public Entity newEntity(List<Span<Term>> references) {
String newId = idManager.getNextId(AnnotationType.ENTITY);
Entity newEntity = new Entity(newId, references);
annotationContainer.add(newEntity, Layer.ENTITIES, AnnotationType.ENTITY);
return newEntity;
} | java |
public Coref newCoref(String id, List<Span<Term>> mentions) {
idManager.updateCounter(AnnotationType.COREF, id);
Coref newCoref = new Coref(id, mentions);
annotationContainer.add(newCoref, Layer.COREFERENCES, AnnotationType.COREF);
return newCoref;
} | java |
public Coref newCoref(List<Span<Term>> mentions) {
String newId = idManager.getNextId(AnnotationType.COREF);
Coref newCoref = new Coref(newId, mentions);
annotationContainer.add(newCoref, Layer.COREFERENCES, AnnotationType.COREF);
return newCoref;
} | java |
public Timex3 newTimex3(String id, String type) {
idManager.updateCounter(AnnotationType.TIMEX3, id);
Timex3 newTimex3 = new Timex3(id, type);
annotationContainer.add(newTimex3, Layer.TIME_EXPRESSIONS, AnnotationType.TIMEX3);
return newTimex3;
} | java |
public Timex3 newTimex3(String type) {
String newId = idManager.getNextId(AnnotationType.TIMEX3);
Timex3 newTimex3 = new Timex3(newId, type);
annotationContainer.add(newTimex3, Layer.TIME_EXPRESSIONS, AnnotationType.TIMEX3);
return newTimex3;
} | java |
public Factvalue newFactvalue(WF wf, String prediction) {
Factvalue factuality = new Factvalue(wf, prediction);
annotationContainer.add(factuality, Layer.FACTUALITY_LAYER, AnnotationType.FACTVALUE);
return factuality;
} | java |
public Feature newProperty(String id, String lemma, List<Span<Term>> references) {
idManager.updateCounter(AnnotationType.PROPERTY, id);
Feature newProperty = new Feature(id, lemma, references);
annotationContainer.add(newProperty, Layer.PROPERTIES, AnnotationType.PROPERTY);
return newProperty;
} | java |
public Feature newProperty(String lemma, List<Span<Term>> references) {
String newId = idManager.getNextId(AnnotationType.PROPERTY);
Feature newProperty = new Feature(newId, lemma, references);
annotationContainer.add(newProperty, Layer.PROPERTIES, AnnotationType.PROPERTY);
return newProperty;
} | java |
public Feature newCategory(String id, String lemma, List<Span<Term>> references) {
idManager.updateCounter(AnnotationType.CATEGORY, id);
Feature newCategory = new Feature(id, lemma, references);
annotationContainer.add(newCategory, Layer.CATEGORIES, AnnotationType.CATEGORY);
return newCategory;
} | java |
public Feature newCategory(String lemma, List<Span<Term>> references) {
String newId = idManager.getNextId(AnnotationType.CATEGORY);
Feature newCategory = new Feature(newId, lemma, references);
annotationContainer.add(newCategory, Layer.CATEGORIES, AnnotationType.CATEGORY);
return newCategory;
} | java |
public Opinion newOpinion() {
String newId = idManager.getNextId(AnnotationType.OPINION);
Opinion newOpinion = new Opinion(newId);
annotationContainer.add(newOpinion, Layer.OPINIONS, AnnotationType.OPINION);
return newOpinion;
} | java |
public Opinion newOpinion(String id) {
idManager.updateCounter(AnnotationType.OPINION, id);
Opinion newOpinion = new Opinion(id);
annotationContainer.add(newOpinion, Layer.OPINIONS, AnnotationType.OPINION);
return newOpinion;
} | java |
public Predicate newPredicate(String id, Span<Term> span) {
idManager.updateCounter(AnnotationType.PREDICATE, id);
Predicate newPredicate = new Predicate(id, span);
annotationContainer.add(newPredicate, Layer.SRL, AnnotationType.PREDICATE);
return newPredicate;
} | java |
public Predicate newPredicate(Span<Term> span) {
String newId = idManager.getNextId(AnnotationType.PREDICATE);
Predicate newPredicate = new Predicate(newId, span);
annotationContainer.add(newPredicate, Layer.SRL, AnnotationType.PREDICATE);
return newPredicate;
} | java |
public Predicate.Role newRole(String id, Predicate predicate, String semRole, Span<Term> span) {
idManager.updateCounter(AnnotationType.ROLE, id);
Predicate.Role newRole = new Predicate.Role(id, semRole, span);
return newRole;
} | java |
public Predicate.Role newRole(Predicate predicate, String semRole, Span<Term> span) {
String newId = idManager.getNextId(AnnotationType.ROLE);
Predicate.Role newRole = new Predicate.Role(newId, semRole, span);
return newRole;
} | java |
public List<List<WF>> getSentences() {
return (List<List<WF>>)(List<?>) annotationContainer.getSentences(AnnotationType.WF);
} | java |
public List<Term> getTermsFromWFs(List<String> wfIds) {
List<Term> terms = new ArrayList<Term>();
for (String wfId : wfIds) {
terms.addAll(this.wfId2Terms.get(wfId));
}
return terms;
} | java |
public String createTimestamp() {
Date date = new Date();
//SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd H:mm:ss");
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ");
String formattedDate = sdf.format(date);
return formattedDate;
} | java |
static <T extends IdentifiableAnnotation> Span<T> list2Span(List<T> list) {
Span<T> span = new Span<T>();
for (T elem : list) {
span.addTarget(elem);
}
return span;
} | java |
static Span<Term> targetList2Span(List<Target> list) {
Span<Term> span = new Span<Term>();
for (Target target : list) {
if (target.isHead()) {
span.addTarget(target.getTerm(), true);
} else {
span.addTarget(target.getTerm());
}
}
return span;
} | java |
static List<Target> span2TargetList(Span<Term> span) {
List<Target> list = new ArrayList<Target>();
for (Term t : span.getTargets()) {
list.add(KAFDocument.createTarget(t, (t==span.getHead())));
}
return list;
} | java |
@Nullable
public static String findContentText(final Node rootNode, final XPath xPath, final String expression) {
final Node node = findNode(rootNode, xPath, expression);
if (node == null) {
return null;
}
return node.getTextContent();
} | java |
@Nullable
public static Integer findContentInteger(final Node rootNode, final XPath xPath,
final String expression) {
final Node node = findNode(rootNode, xPath, expression);
if (node == null) {
return null;
}
final String str = node.getTextContent();
return Integer.valueOf(str);
} | java |
@Nullable
public static Node findNode(@NotNull final Node rootNode, @NotNull final XPath xPath,
@NotNull final String expression) {
Contract.requireArgNotNull("rootNode", rootNode);
Contract.requireArgNotNull("xPath", xPath);
Contract.requireArgNotNull("expression", expression);
try {
return (Node) xPath.compile(expression).evaluate(rootNode, XPathConstants.NODE);
} catch (final XPathExpressionException ex) {
throw new RuntimeException("Failed to read node: " + expression, ex);
}
} | java |
@Nullable
public static NodeList findNodes(@NotNull final Node rootNode, @NotNull final XPath xPath,
@NotNull final String expression) {
Contract.requireArgNotNull("doc", rootNode);
Contract.requireArgNotNull("xPath", xPath);
Contract.requireArgNotNull("expression", expression);
try {
return (NodeList) xPath.compile(expression).evaluate(rootNode, XPathConstants.NODESET);
} catch (final XPathExpressionException ex) {
throw new RuntimeException("Failed to read node: " + expression, ex);
}
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.