_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q5000 | AppServiceRegistry.bulkRegisterSingleton | train | synchronized void bulkRegisterSingleton() {
for (Map.Entry<Class<? extends AppService>, AppService> entry : registry.entrySet()) {
if (isSingletonService(entry.getKey())) {
app.registerSingleton(entry.getKey(), entry.getValue());
}
}
} | java | {
"resource": ""
} |
q5001 | ActionContext.paramKeys | train | @Override
public Set<String> paramKeys() {
Set<String> set = new HashSet<String>();
set.addAll(C.<String>list(request.paramNames()));
set.addAll(extraParams.keySet());
set.addAll(bodyParams().keySet());
set.remove("_method");
set.remove("_body");
return set;
} | java | {
"resource": ""
} |
q5002 | ActionContext.applyContentType | train | public ActionContext applyContentType(Result result) {
if (!result.status().isError()) {
return applyContentType();
}
return applyContentType(contentTypeForErrorResult(req()));
} | java | {
"resource": ""
} |
q5003 | ActionContext.cached | train | public <T> T cached(String key) {
H.Session sess = session();
if (null != sess) {
return sess.cached(key);
} else {
return app().cache().get(key);
}
} | java | {
"resource": ""
} |
q5004 | ActionContext.cache | train | public void cache(String key, Object obj) {
H.Session sess = session();
if (null != sess) {
sess.cache(key, obj);
} else {
app().cache().put(key, obj);
}
} | java | {
"resource": ""
} |
q5005 | ActionContext.cache | train | public void cache(String key, Object obj, int expiration) {
H.Session session = this.session;
if (null != session) {
session.cache(key, obj, expiration);
} else {
app().cache().put(key, obj, expiration);
}
} | java | {
"resource": ""
} |
q5006 | ActionContext.evictCache | train | public void evictCache(String key) {
H.Session sess = session();
if (null != sess) {
sess.evict(key);
} else {
app().cache().evict(key);
}
} | java | {
"resource": ""
} |
q5007 | ActionContext.login | train | public void login(Object userIdentifier) {
session().put(config().sessionKeyUsername(), userIdentifier);
app().eventBus().trigger(new LoginEvent(userIdentifier.toString()));
} | java | {
"resource": ""
} |
q5008 | ActionContext.loginAndRedirectBack | train | public void loginAndRedirectBack(Object userIdentifier, String defaultLandingUrl) {
login(userIdentifier);
RedirectToLoginUrl.redirectToOriginalUrl(this, defaultLandingUrl);
} | java | {
"resource": ""
} |
q5009 | ActionContext.logout | train | public void logout() {
String userIdentifier = session.get(config().sessionKeyUsername());
SessionManager sessionManager = app().sessionManager();
sessionManager.logout(session);
if (S.notBlank(userIdentifier)) {
app().eventBus().trigger(new LogoutEvent(userIdentifier));
}
} | java | {
"resource": ""
} |
q5010 | JobContext.init | train | public static void init(String jobId) {
JobContext parent = current_.get();
JobContext ctx = new JobContext(parent);
current_.set(ctx);
// don't call setJobId(String)
// as it will trigger listeners -- TODO fix me
ctx.jobId = jobId;
if (null == parent) {
Act.eventBus().trigger(new JobContextInitialized(ctx));
}
} | java | {
"resource": ""
} |
q5011 | JobContext.clear | train | public static void clear() {
JobContext ctx = current_.get();
if (null != ctx) {
ctx.bag_.clear();
JobContext parent = ctx.parent;
if (null != parent) {
current_.set(parent);
ctx.parent = null;
} else {
current_.remove();
Act.eventBus().trigger(new JobContextDestroyed(ctx));
}
}
} | java | {
"resource": ""
} |
q5012 | JobContext.get | train | public static <T> T get(String key, Class<T> clz) {
return (T)m().get(key);
} | java | {
"resource": ""
} |
q5013 | JobContext.copy | train | static JobContext copy() {
JobContext current = current_.get();
//JobContext ctxt = new JobContext(keepParent ? current : null);
JobContext ctxt = new JobContext(null);
if (null != current) {
ctxt.bag_.putAll(current.bag_);
}
return ctxt;
} | java | {
"resource": ""
} |
q5014 | JobContext.loadFromOrigin | train | static void loadFromOrigin(JobContext origin) {
if (origin.bag_.isEmpty()) {
return;
}
ActContext<?> actContext = ActContext.Base.currentContext();
if (null != actContext) {
Locale locale = (Locale) origin.bag_.get("locale");
if (null != locale) {
actContext.locale(locale);
}
H.Session session = (H.Session) origin.bag_.get("session");
if (null != session) {
actContext.attribute("__session", session);
}
}
} | java | {
"resource": ""
} |
q5015 | CaptchaSession.getToken | train | public String getToken() {
String id = null == answer ? text : answer;
return Act.app().crypto().generateToken(id);
} | java | {
"resource": ""
} |
q5016 | RouterRegexMacroLookup.expand | train | public String expand(String macro) {
if (!isMacro(macro)) {
return macro;
}
String definition = macros.get(Config.canonical(macro));
if (null == definition) {
warn("possible missing definition of macro[%s]", macro);
}
return null == definition ? macro : definition;
} | java | {
"resource": ""
} |
q5017 | JavaNames.isPackageOrClassName | train | public static boolean isPackageOrClassName(String s) {
if (S.blank(s)) {
return false;
}
S.List parts = S.fastSplit(s, ".");
if (parts.size() < 2) {
return false;
}
for (String part: parts) {
if (!Character.isJavaIdentifierStart(part.charAt(0))) {
return false;
}
for (int i = 1, len = part.length(); i < len; ++i) {
if (!Character.isJavaIdentifierPart(part.charAt(i))) {
return false;
}
}
}
return true;
} | java | {
"resource": ""
} |
q5018 | JavaNames.packageNameOf | train | public static String packageNameOf(Class<?> clazz) {
String name = clazz.getName();
int pos = name.lastIndexOf('.');
E.unexpectedIf(pos < 0, "Class does not have package: " + name);
return name.substring(0, pos);
} | java | {
"resource": ""
} |
q5019 | RouteInfo.of | train | public static RouteInfo of(ActionContext context) {
H.Method m = context.req().method();
String path = context.req().url();
RequestHandler handler = context.handler();
if (null == handler) {
handler = UNKNOWN_HANDLER;
}
return new RouteInfo(m, path, handler);
} | java | {
"resource": ""
} |
q5020 | WebSocketConnectionRegistry.get | train | public List<WebSocketConnection> get(String key) {
final List<WebSocketConnection> retList = new ArrayList<>();
accept(key, C.F.addTo(retList));
return retList;
} | java | {
"resource": ""
} |
q5021 | WebSocketConnectionRegistry.signIn | train | public void signIn(String key, WebSocketConnection connection) {
ConcurrentMap<WebSocketConnection, WebSocketConnection> bag = ensureConnectionList(key);
bag.put(connection, connection);
} | java | {
"resource": ""
} |
q5022 | WebSocketConnectionRegistry.signIn | train | public void signIn(String key, Collection<WebSocketConnection> connections) {
if (connections.isEmpty()) {
return;
}
Map<WebSocketConnection, WebSocketConnection> newMap = new HashMap<>();
for (WebSocketConnection conn : connections) {
newMap.put(conn, conn);
}
ConcurrentMap<WebSocketConnection, WebSocketConnection> bag = ensureConnectionList(key);
bag.putAll(newMap);
} | java | {
"resource": ""
} |
q5023 | WebSocketConnectionRegistry.signOff | train | public void signOff(String key, WebSocketConnection connection) {
ConcurrentMap<WebSocketConnection, WebSocketConnection> connections = registry.get(key);
if (null == connections) {
return;
}
connections.remove(connection);
} | java | {
"resource": ""
} |
q5024 | WebSocketConnectionRegistry.signOff | train | public void signOff(WebSocketConnection connection) {
for (ConcurrentMap<WebSocketConnection, WebSocketConnection> connections : registry.values()) {
connections.remove(connection);
}
} | java | {
"resource": ""
} |
q5025 | WebSocketConnectionRegistry.signOff | train | public void signOff(String key, Collection<WebSocketConnection> connections) {
if (connections.isEmpty()) {
return;
}
ConcurrentMap<WebSocketConnection, WebSocketConnection> bag = ensureConnectionList(key);
bag.keySet().removeAll(connections);
} | java | {
"resource": ""
} |
q5026 | WebSocketConnectionRegistry.count | train | public int count() {
int n = 0;
for (ConcurrentMap<?, ?> bag : registry.values()) {
n += bag.size();
}
return n;
} | java | {
"resource": ""
} |
q5027 | WebSocketConnectionRegistry.count | train | public int count(String key) {
ConcurrentMap<WebSocketConnection, WebSocketConnection> bag = registry.get(key);
return null == bag ? 0 : bag.size();
} | java | {
"resource": ""
} |
q5028 | ReflectedInvokerHelper.tryGetSingleton | train | public static Object tryGetSingleton(Class<?> invokerClass, App app) {
Object singleton = app.singleton(invokerClass);
if (null == singleton) {
if (isGlobalOrStateless(invokerClass, new HashSet<Class>())) {
singleton = app.getInstance(invokerClass);
}
}
if (null != singleton) {
app.registerSingleton(singleton);
}
return singleton;
} | java | {
"resource": ""
} |
q5029 | JsonUtilConfig.writeJson | train | private static final void writeJson(Writer os, //
Object object, //
SerializeConfig config, //
SerializeFilter[] filters, //
DateFormat dateFormat, //
int defaultFeatures, //
SerializerFeature... features) {
SerializeWriter writer = new SerializeWriter(os, defaultFeatures, features);
try {
JSONSerializer serializer = new JSONSerializer(writer, config);
if (dateFormat != null) {
serializer.setDateFormat(dateFormat);
serializer.config(SerializerFeature.WriteDateUseDateFormat, true);
}
if (filters != null) {
for (SerializeFilter filter : filters) {
serializer.addFilter(filter);
}
}
serializer.write(object);
} finally {
writer.close();
}
} | java | {
"resource": ""
} |
q5030 | DbService.entityClasses | train | public Set<Class> entityClasses() {
EntityMetaInfoRepo repo = app().entityMetaInfoRepo().forDb(id);
return null == repo ? C.<Class>set() : repo.entityClasses();
} | java | {
"resource": ""
} |
q5031 | WebSocketContext.messageReceived | train | public WebSocketContext messageReceived(String receivedMessage) {
this.stringMessage = S.string(receivedMessage).trim();
isJson = stringMessage.startsWith("{") || stringMessage.startsWith("]");
tryParseQueryParams();
return this;
} | java | {
"resource": ""
} |
q5032 | WebSocketContext.reTag | train | public WebSocketContext reTag(String label) {
WebSocketConnectionRegistry registry = manager.tagRegistry();
registry.signOff(connection);
registry.signIn(label, connection);
return this;
} | java | {
"resource": ""
} |
q5033 | WebSocketContext.sendToPeers | train | public WebSocketContext sendToPeers(String message, boolean excludeSelf) {
return sendToConnections(message, url, manager.urlRegistry(), excludeSelf);
} | java | {
"resource": ""
} |
q5034 | WebSocketContext.sendToTagged | train | public WebSocketContext sendToTagged(String message, String tag) {
return sendToTagged(message, tag, false);
} | java | {
"resource": ""
} |
q5035 | WebSocketContext.sendToTagged | train | public WebSocketContext sendToTagged(String message, String tag, boolean excludeSelf) {
return sendToConnections(message, tag, manager.tagRegistry(), excludeSelf);
} | java | {
"resource": ""
} |
q5036 | WebSocketContext.sendToUser | train | public WebSocketContext sendToUser(String message, String username) {
return sendToConnections(message, username, manager.usernameRegistry(), true);
} | java | {
"resource": ""
} |
q5037 | WebSocketContext.sendJsonToUser | train | public WebSocketContext sendJsonToUser(Object data, String username) {
return sendToTagged(JSON.toJSONString(data), username);
} | java | {
"resource": ""
} |
q5038 | ApplicationModule.bindMappers | train | public void bindMappers()
{
JacksonXmlModule xmlModule = new JacksonXmlModule();
xmlModule.setDefaultUseWrapper(false);
XmlMapper xmlMapper = new XmlMapper(xmlModule);
xmlMapper.enable(ToXmlGenerator.Feature.WRITE_XML_DECLARATION);
this.bind(XmlMapper.class).toInstance(xmlMapper);
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
objectMapper.configure(DeserializationFeature.ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT, true);
objectMapper.configure(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT, true);
objectMapper.configure(DeserializationFeature.EAGER_DESERIALIZER_FETCH, true);
objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
objectMapper.configure(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS, true);
objectMapper.registerModule(new AfterburnerModule());
objectMapper.registerModule(new Jdk8Module());
this.bind(ObjectMapper.class).toInstance(objectMapper);
this.requestStaticInjection(Extractors.class);
this.requestStaticInjection(ServerResponse.class);
} | java | {
"resource": ""
} |
q5039 | Reader.read | train | public Swagger read(Set<Class<?>> classes) {
Set<Class<?>> sortedClasses = new TreeSet<>((class1, class2) -> {
if (class1.equals(class2)) {
return 0;
} else if (class1.isAssignableFrom(class2)) {
return -1;
} else if (class2.isAssignableFrom(class1)) {
return 1;
}
return class1.getName().compareTo(class2.getName());
});
sortedClasses.addAll(classes);
Map<Class<?>, ReaderListener> listeners = new HashMap<Class<?>, ReaderListener>();
for (Class<?> cls : sortedClasses) {
if (ReaderListener.class.isAssignableFrom(cls) && !listeners.containsKey(cls)) {
try {
listeners.put(cls, (ReaderListener) cls.newInstance());
} catch (Exception e) {
LOGGER.error("Failed to create ReaderListener", e);
}
}
}
// for (ReaderListener listener : listeners.values()) {
// try {
// listener.beforeScan(this, swagger);
// } catch (Exception e) {
// LOGGER.error("Unexpected error invoking beforeScan listener [" + listener.getClass().getName() + "]", e);
// }
// }
// process SwaggerDefinitions first - so we get tags in desired order
for (Class<?> cls : sortedClasses) {
SwaggerDefinition swaggerDefinition = cls.getAnnotation(SwaggerDefinition.class);
if (swaggerDefinition != null) {
readSwaggerConfig(cls, swaggerDefinition);
}
}
for (Class<?> cls : sortedClasses) {
read(cls, "", null, false, new String[0], new String[0], new LinkedHashMap<>(), new ArrayList<>(), new HashSet<>());
}
// for (ReaderListener listener : listeners.values()) {
// try {
// listener.afterScan(this, swagger);
// } catch (Exception e) {
// LOGGER.error("Unexpected error invoking afterScan listener [" + listener.getClass().getName() + "]", e);
// }
// }
return swagger;
} | java | {
"resource": ""
} |
q5040 | Reader.read | train | public Swagger read(Class<?> cls) {
SwaggerDefinition swaggerDefinition = cls.getAnnotation(SwaggerDefinition.class);
if (swaggerDefinition != null) {
readSwaggerConfig(cls, swaggerDefinition);
}
return read(cls, "", null, false, new String[0], new String[0], new LinkedHashMap<>(), new ArrayList<>(), new HashSet<>());
} | java | {
"resource": ""
} |
q5041 | HandlerGenerator.generateRoutes | train | protected void generateRoutes()
{
try {
// Optional<io.sinistral.proteus.annotations.Chain> typeLevelWrapAnnotation = Optional.ofNullable(controllerClass.getAnnotation(io.sinistral.proteus.annotations.Chain.class));
//
// typeLevelWrapAnnotation.ifPresent( a -> {
//
// io.sinistral.proteus.annotations.Chain w = typeLevelWrapAnnotation.get();
//
// Class<? extends HandlerWrapper> wrapperClasses[] = w.value();
//
// for (int i = 0; i < wrapperClasses.length; i++)
// {
// Class<? extends HandlerWrapper> wrapperClass = wrapperClasses[i];
//
// String wrapperName = generateFieldName(wrapperClass.getCanonicalName());
//
// handlerWrapperMap.put(wrapperClass, wrapperName);
// }
//
// });
//
// for(Method m : this.controllerClass.getDeclaredMethods())
// {
//
// Optional<io.sinistral.proteus.annotations.Chain> methodLevelWrapAnnotation = Optional.ofNullable(m.getAnnotation(io.sinistral.proteus.annotations.Chain.class));
//
// methodLevelWrapAnnotation.ifPresent( a -> {
//
// io.sinistral.proteus.annotations.Chain w = methodLevelWrapAnnotation.get();
//
// Class<? extends HandlerWrapper> wrapperClasses[] = w.value();
//
// for (int i = 0; i < wrapperClasses.length; i++)
// {
// Class<? extends HandlerWrapper> wrapperClass = wrapperClasses[i];
//
// String wrapperName = generateFieldName(wrapperClass.getCanonicalName());
//
// handlerWrapperMap.put(wrapperClass, wrapperName);
// }
//
// });
//
// }
//
// log.info("handlerWrapperMap: " + handlerWrapperMap);
TypeSpec.Builder typeBuilder = TypeSpec.classBuilder(className).addModifiers(Modifier.PUBLIC)
.addSuperinterface(ParameterizedTypeName.get(Supplier.class, RoutingHandler.class));
ClassName extractorClass = ClassName.get("io.sinistral.proteus.server", "Extractors");
ClassName injectClass = ClassName.get("com.google.inject", "Inject");
MethodSpec.Builder constructor = MethodSpec.constructorBuilder().addModifiers(Modifier.PUBLIC).addAnnotation(injectClass);
String className = this.controllerClass.getSimpleName().toLowerCase() + "Controller";
typeBuilder.addField(this.controllerClass, className, Modifier.PROTECTED, Modifier.FINAL);
ClassName wrapperClass = ClassName.get("io.undertow.server", "HandlerWrapper");
ClassName stringClass = ClassName.get("java.lang", "String");
ClassName mapClass = ClassName.get("java.util", "Map");
TypeName mapOfWrappers = ParameterizedTypeName.get(mapClass, stringClass, wrapperClass);
TypeName annotatedMapOfWrappers = mapOfWrappers
.annotated(AnnotationSpec.builder(com.google.inject.name.Named.class).addMember("value", "$S", "registeredHandlerWrappers").build());
typeBuilder.addField(mapOfWrappers, "registeredHandlerWrappers", Modifier.PROTECTED, Modifier.FINAL);
constructor.addParameter(this.controllerClass, className);
constructor.addParameter(annotatedMapOfWrappers, "registeredHandlerWrappers");
constructor.addStatement("this.$N = $N", className, className);
constructor.addStatement("this.$N = $N", "registeredHandlerWrappers", "registeredHandlerWrappers");
addClassMethodHandlers(typeBuilder, this.controllerClass);
typeBuilder.addMethod(constructor.build());
JavaFile javaFile = JavaFile.builder(packageName, typeBuilder.build()).addStaticImport(extractorClass, "*").build();
StringBuilder sb = new StringBuilder();
javaFile.writeTo(sb);
this.sourceString = sb.toString();
} catch (Exception e) {
log.error(e.getMessage(), e);
}
} | java | {
"resource": ""
} |
q5042 | ProteusApplication.addDefaultRoutes | train | public ProteusApplication addDefaultRoutes(RoutingHandler router)
{
if (config.hasPath("health.statusPath")) {
try {
final String statusPath = config.getString("health.statusPath");
router.add(Methods.GET, statusPath, (final HttpServerExchange exchange) ->
{
exchange.getResponseHeaders().add(Headers.CONTENT_TYPE, MediaType.TEXT_PLAIN);
exchange.getResponseSender().send("OK");
});
this.registeredEndpoints.add(EndpointInfo.builder().withConsumes("*/*").withProduces("text/plain").withPathTemplate(statusPath).withControllerName("Internal").withMethod(Methods.GET).build());
} catch (Exception e) {
log.error("Error adding health status route.", e.getMessage());
}
}
if (config.hasPath("application.favicon")) {
try {
final ByteBuffer faviconImageBuffer;
final File faviconFile = new File(config.getString("application.favicon"));
if (!faviconFile.exists()) {
try (final InputStream stream = this.getClass().getResourceAsStream(config.getString("application.favicon"))) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] buffer = new byte[4096];
int read = 0;
while (read != -1) {
read = stream.read(buffer);
if (read > 0) {
baos.write(buffer, 0, read);
}
}
faviconImageBuffer = ByteBuffer.wrap(baos.toByteArray());
}
} else {
try (final InputStream stream = Files.newInputStream(Paths.get(config.getString("application.favicon")))) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] buffer = new byte[4096];
int read = 0;
while (read != -1) {
read = stream.read(buffer);
if (read > 0) {
baos.write(buffer, 0, read);
}
}
faviconImageBuffer = ByteBuffer.wrap(baos.toByteArray());
}
}
router.add(Methods.GET, "favicon.ico", (final HttpServerExchange exchange) ->
{
exchange.getResponseHeaders().add(Headers.CONTENT_TYPE, io.sinistral.proteus.server.MediaType.IMAGE_X_ICON.toString());
exchange.getResponseSender().send(faviconImageBuffer);
});
} catch (Exception e) {
log.error("Error adding favicon route.", e.getMessage());
}
}
return this;
} | java | {
"resource": ""
} |
q5043 | ProteusApplication.setServerConfigurationFunction | train | public ProteusApplication setServerConfigurationFunction(Function<Undertow.Builder, Undertow.Builder> serverConfigurationFunction)
{
this.serverConfigurationFunction = serverConfigurationFunction;
return this;
} | java | {
"resource": ""
} |
q5044 | Utils.getDisplayMetrics | train | static DisplayMetrics getDisplayMetrics(final Context context) {
final WindowManager
windowManager =
(WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
final DisplayMetrics metrics = new DisplayMetrics();
windowManager.getDefaultDisplay().getMetrics(metrics);
return metrics;
} | java | {
"resource": ""
} |
q5045 | LiveBlurWorker.crop | train | private static Bitmap crop(Bitmap srcBmp, View canvasView, int downsampling) {
float scale = 1f / downsampling;
return Bitmap.createBitmap(
srcBmp,
(int) Math.floor((ViewCompat.getX(canvasView)) * scale),
(int) Math.floor((ViewCompat.getY(canvasView)) * scale),
(int) Math.floor((canvasView.getWidth()) * scale),
(int) Math.floor((canvasView.getHeight()) * scale)
);
} | java | {
"resource": ""
} |
q5046 | PerformanceProfiler.startTask | train | public void startTask(int id, String taskName) {
if (isActivated) {
durations.add(new Duration(id, taskName, BenchmarkUtil.elapsedRealTimeNanos()));
}
} | java | {
"resource": ""
} |
q5047 | PerformanceProfiler.getDurationMs | train | public double getDurationMs() {
double durationMs = 0;
for (Duration duration : durations) {
if (duration.taskFinished()) {
durationMs += duration.getDurationMS();
}
}
return durationMs;
} | java | {
"resource": ""
} |
q5048 | LegacySDKUtil.setViewBackground | train | public static void setViewBackground(View v, Drawable d) {
if (Build.VERSION.SDK_INT >= 16) {
v.setBackground(d);
} else {
v.setBackgroundDrawable(d);
}
} | java | {
"resource": ""
} |
q5049 | LegacySDKUtil.byteSizeOf | train | public static int byteSizeOf(Bitmap bitmap) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
return bitmap.getAllocationByteCount();
} else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR1) {
return bitmap.getByteCount();
} else {
return bitmap.getRowBytes() * bitmap.getHeight();
}
} | java | {
"resource": ""
} |
q5050 | LegacySDKUtil.getCacheDir | train | public static String getCacheDir(Context ctx) {
return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()) || (!Environment.isExternalStorageRemovable() && ctx.getExternalCacheDir() != null) ?
ctx.getExternalCacheDir().getPath() : ctx.getCacheDir().getPath();
} | java | {
"resource": ""
} |
q5051 | ImageReference.measureImage | train | public Point measureImage(Resources resources) {
BitmapFactory.Options justBoundsOptions = new BitmapFactory.Options();
justBoundsOptions.inJustDecodeBounds = true;
if (bitmap != null) {
return new Point(bitmap.getWidth(), bitmap.getHeight());
} else if (resId != null) {
BitmapFactory.decodeResource(resources, resId, justBoundsOptions);
float scale = (float) justBoundsOptions.inTargetDensity / justBoundsOptions.inDensity;
return new Point((int) (justBoundsOptions.outWidth * scale + 0.5f), (int) (justBoundsOptions.outHeight * scale + 0.5f));
} else if (fileToBitmap != null) {
BitmapFactory.decodeFile(fileToBitmap.getAbsolutePath(), justBoundsOptions);
} else if (inputStream != null) {
BitmapFactory.decodeStream(inputStream, null, justBoundsOptions);
try {
inputStream.reset();
} catch (IOException ignored) {
}
} else if (view != null) {
return new Point(view.getWidth(), view.getHeight());
}
return new Point(justBoundsOptions.outWidth, justBoundsOptions.outHeight);
} | java | {
"resource": ""
} |
q5052 | ExecutorManager.cancelByTag | train | public synchronized int cancelByTag(String tagToCancel) {
int i = 0;
if (taskList.containsKey(tagToCancel)) {
removeDoneTasks();
for (Future<BlurWorker.Result> future : taskList.get(tagToCancel)) {
BuilderUtil.logVerbose(Dali.getConfig().logTag, "Canceling task with tag " + tagToCancel, Dali.getConfig().debugMode);
future.cancel(true);
i++;
}
//remove all canceled tasks
Iterator<Future<BlurWorker.Result>> iter = taskList.get(tagToCancel).iterator();
while (iter.hasNext()) {
if (iter.next().isCancelled()) {
iter.remove();
}
}
}
return i;
} | java | {
"resource": ""
} |
q5053 | BitmapUtil.flip | train | public static Bitmap flip(Bitmap src) {
Matrix m = new Matrix();
m.preScale(-1, 1);
return Bitmap.createBitmap(src, 0, 0, src.getWidth(), src.getHeight(), m, false);
} | java | {
"resource": ""
} |
q5054 | TwoLevelCache.purge | train | public void purge(String cacheKey) {
try {
if (useMemoryCache) {
if (memoryCache != null) {
memoryCache.remove(cacheKey);
}
}
if (useDiskCache) {
if (diskLruCache != null) {
diskLruCache.remove(cacheKey);
}
}
} catch (Exception e) {
Log.w(TAG, "Could not remove entry in cache purge", e);
}
} | java | {
"resource": ""
} |
q5055 | ContextWrapper.getRenderScript | train | public RenderScript getRenderScript() {
if (renderScript == null) {
renderScript = RenderScript.create(context, renderScriptContextType);
}
return renderScript;
} | java | {
"resource": ""
} |
q5056 | DaliBlurDrawerToggle.renderBlurLayer | train | private void renderBlurLayer(float slideOffset) {
if (enableBlur) {
if (slideOffset == 0 || forceRedraw) {
clearBlurView();
}
if (slideOffset > 0f && blurView == null) {
if (drawerLayout.getChildCount() == 2) {
blurView = new ImageView(drawerLayout.getContext());
blurView.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
blurView.setScaleType(ImageView.ScaleType.FIT_CENTER);
drawerLayout.addView(blurView, 1);
}
if (BuilderUtil.isOnUiThread()) {
if (cacheMode.equals(CacheMode.AUTO) || forceRedraw) {
dali.load(drawerLayout.getChildAt(0)).blurRadius(blurRadius).downScale(downSample).noFade().error(Dali.NO_RESID).concurrent().skipCache().into(blurView);
forceRedraw = false;
} else {
dali.load(drawerLayout.getChildAt(0)).blurRadius(blurRadius).downScale(downSample).noFade().error(Dali.NO_RESID).concurrent().into(blurView);
}
}
}
if (slideOffset > 0f && slideOffset < 1f) {
int alpha = (int) Math.ceil((double) slideOffset * 255d);
LegacySDKUtil.setImageAlpha(blurView, alpha);
}
}
} | java | {
"resource": ""
} |
q5057 | DaliBlurDrawerToggle.onDrawerOpened | train | public void onDrawerOpened(View drawerView) {
super.onDrawerOpened(drawerView);
if (listener != null) listener.onDrawerClosed(drawerView);
} | java | {
"resource": ""
} |
q5058 | BuilderUtil.getIBlurAlgorithm | train | public static IBlur getIBlurAlgorithm(EBlurAlgorithm algorithm, ContextWrapper contextWrapper) {
RenderScript rs = contextWrapper.getRenderScript();
Context ctx = contextWrapper.getContext();
switch (algorithm) {
case RS_GAUSS_FAST:
return new RenderScriptGaussianBlur(rs);
case RS_BOX_5x5:
return new RenderScriptBox5x5Blur(rs);
case RS_GAUSS_5x5:
return new RenderScriptGaussian5x5Blur(rs);
case RS_STACKBLUR:
return new RenderScriptStackBlur(rs, ctx);
case STACKBLUR:
return new StackBlur();
case GAUSS_FAST:
return new GaussianFastBlur();
case BOX_BLUR:
return new BoxBlur();
default:
return new IgnoreBlur();
}
} | java | {
"resource": ""
} |
q5059 | BlurBuilder.downScale | train | public BlurBuilder downScale(int scaleInSample) {
data.options.inSampleSize = Math.min(Math.max(1, scaleInSample), 16384);
return this;
} | java | {
"resource": ""
} |
q5060 | BlurBuilder.brightness | train | public BlurBuilder brightness(float brightness) {
data.preProcessors.add(new RenderscriptBrightnessProcessor(data.contextWrapper.getRenderScript(), brightness, data.contextWrapper.getResources()));
return this;
} | java | {
"resource": ""
} |
q5061 | BlurBuilder.contrast | train | public BlurBuilder contrast(float contrast) {
data.preProcessors.add(new ContrastProcessor(data.contextWrapper.getRenderScript(), Math.max(Math.min(1500.f, contrast), -1500.f)));
return this;
} | java | {
"resource": ""
} |
q5062 | Dali.resetAndSetNewConfig | train | public static synchronized void resetAndSetNewConfig(Context ctx, Config config) {
GLOBAL_CONFIG = config;
if (DISK_CACHE_MANAGER != null) {
DISK_CACHE_MANAGER.clear();
DISK_CACHE_MANAGER = null;
createCache(ctx);
}
if (EXECUTOR_MANAGER != null) {
EXECUTOR_MANAGER.shutDown();
EXECUTOR_MANAGER = null;
}
Log.i(TAG, "New config set");
} | java | {
"resource": ""
} |
q5063 | IbanUtil.getIbanLength | train | public static int getIbanLength(final CountryCode countryCode) {
final BbanStructure structure = getBbanStructure(countryCode);
return COUNTRY_CODE_LENGTH + CHECK_DIGIT_LENGTH + structure.getBbanLength();
} | java | {
"resource": ""
} |
q5064 | IbanUtil.getCountryCodeAndCheckDigit | train | public static String getCountryCodeAndCheckDigit(final String iban) {
return iban.substring(COUNTRY_CODE_INDEX,
COUNTRY_CODE_INDEX + COUNTRY_CODE_LENGTH + CHECK_DIGIT_LENGTH);
} | java | {
"resource": ""
} |
q5065 | IbanUtil.replaceCheckDigit | train | static String replaceCheckDigit(final String iban, final String checkDigit) {
return getCountryCode(iban) + checkDigit + getBban(iban);
} | java | {
"resource": ""
} |
q5066 | IbanUtil.toFormattedString | train | static String toFormattedString(final String iban) {
final StringBuilder ibanBuffer = new StringBuilder(iban);
final int length = ibanBuffer.length();
for (int i = 0; i < length / 4; i++) {
ibanBuffer.insert((i + 1) * 4 + i, ' ');
}
return ibanBuffer.toString().trim();
} | java | {
"resource": ""
} |
q5067 | Bic.valueOf | train | public static Bic valueOf(final String bic) throws BicFormatException,
UnsupportedCountryException {
BicUtil.validate(bic);
return new Bic(bic);
} | java | {
"resource": ""
} |
q5068 | BicUtil.validate | train | public static void validate(final String bic) throws BicFormatException,
UnsupportedCountryException {
try {
validateEmpty(bic);
validateLength(bic);
validateCase(bic);
validateBankCode(bic);
validateCountryCode(bic);
validateLocationCode(bic);
if(hasBranchCode(bic)) {
validateBranchCode(bic);
}
} catch (UnsupportedCountryException e) {
throw e;
} catch (RuntimeException e) {
throw new BicFormatException(UNKNOWN, e.getMessage());
}
} | java | {
"resource": ""
} |
q5069 | PhantomJSDriver.getScreenshotAs | train | @Override
public <X> X getScreenshotAs(OutputType<X> target) {
// Get the screenshot as base64 and convert it to the requested type (i.e. OutputType<T>)
String base64 = (String) execute(DriverCommand.SCREENSHOT).getValue();
return target.convertFromBase64Png(base64);
} | java | {
"resource": ""
} |
q5070 | PayloadBuilder.sound | train | public PayloadBuilder sound(final String sound) {
if (sound != null) {
aps.put("sound", sound);
} else {
aps.remove("sound");
}
return this;
} | java | {
"resource": ""
} |
q5071 | PayloadBuilder.category | train | public PayloadBuilder category(final String category) {
if (category != null) {
aps.put("category", category);
} else {
aps.remove("category");
}
return this;
} | java | {
"resource": ""
} |
q5072 | PayloadBuilder.customField | train | public PayloadBuilder customField(final String key, final Object value) {
root.put(key, value);
return this;
} | java | {
"resource": ""
} |
q5073 | PayloadBuilder.resizeAlertBody | train | public PayloadBuilder resizeAlertBody(final int payloadLength, final String postfix) {
int currLength = length();
if (currLength <= payloadLength) {
return this;
}
// now we are sure that truncation is required
String body = (String)customAlert.get("body");
final int acceptableSize = Utilities.toUTF8Bytes(body).length
- (currLength - payloadLength
+ Utilities.toUTF8Bytes(postfix).length);
body = Utilities.truncateWhenUTF8(body, acceptableSize) + postfix;
// set it back
customAlert.put("body", body);
// calculate the length again
currLength = length();
if(currLength > payloadLength) {
// string is still too long, just remove the body as the body is
// anyway not the cause OR the postfix might be too long
customAlert.remove("body");
}
return this;
} | java | {
"resource": ""
} |
q5074 | PayloadBuilder.build | train | public String build() {
if (!root.containsKey("mdm")) {
insertCustomAlert();
root.put("aps", aps);
}
try {
return mapper.writeValueAsString(root);
} catch (final Exception e) {
throw new RuntimeException(e);
}
} | java | {
"resource": ""
} |
q5075 | ApnsServiceBuilder.withSocksProxy | train | public ApnsServiceBuilder withSocksProxy(String host, int port) {
Proxy proxy = new Proxy(Proxy.Type.SOCKS,
new InetSocketAddress(host, port));
return withProxy(proxy);
} | java | {
"resource": ""
} |
q5076 | ApnsServiceBuilder.withAuthProxy | train | public ApnsServiceBuilder withAuthProxy(Proxy proxy, String proxyUsername, String proxyPassword) {
this.proxy = proxy;
this.proxyUsername = proxyUsername;
this.proxyPassword = proxyPassword;
return this;
} | java | {
"resource": ""
} |
q5077 | ApnsServiceBuilder.withProxySocket | train | @Deprecated
public ApnsServiceBuilder withProxySocket(Socket proxySocket) {
return this.withProxy(new Proxy(Proxy.Type.SOCKS,
proxySocket.getRemoteSocketAddress()));
} | java | {
"resource": ""
} |
q5078 | ApnsServiceBuilder.withDelegate | train | public ApnsServiceBuilder withDelegate(ApnsDelegate delegate) {
this.delegate = delegate == null ? ApnsDelegate.EMPTY : delegate;
return this;
} | java | {
"resource": ""
} |
q5079 | SimpleApnsNotification.length | train | public int length() {
int length = 1 + 2 + deviceToken.length + 2 + payload.length;
final int marshalledLength = marshall().length;
assert marshalledLength == length;
return length;
} | java | {
"resource": ""
} |
q5080 | MultiPageStack.setPadding | train | public void setPadding(float padding, Layout.Axis axis) {
OrientedLayout layout = null;
switch(axis) {
case X:
layout = mShiftLayout;
break;
case Y:
layout = mShiftLayout;
break;
case Z:
layout = mStackLayout;
break;
}
if (layout != null) {
if (!equal(layout.getDividerPadding(axis), padding)) {
layout.setDividerPadding(padding, axis);
if (layout.getOrientationAxis() == axis) {
requestLayout();
}
}
}
} | java | {
"resource": ""
} |
q5081 | MultiPageStack.setShiftOrientation | train | public void setShiftOrientation(OrientedLayout.Orientation orientation) {
if (mShiftLayout.getOrientation() != orientation &&
orientation != OrientedLayout.Orientation.STACK) {
mShiftLayout.setOrientation(orientation);
requestLayout();
}
} | java | {
"resource": ""
} |
q5082 | TouchManager.removeHandlerFor | train | public boolean removeHandlerFor(final GVRSceneObject sceneObject) {
sceneObject.detachComponent(GVRCollider.getComponentType());
return null != touchHandlers.remove(sceneObject);
} | java | {
"resource": ""
} |
q5083 | TouchManager.makePickable | train | public void makePickable(GVRSceneObject sceneObject) {
try {
GVRMeshCollider collider = new GVRMeshCollider(sceneObject.getGVRContext(), false);
sceneObject.attachComponent(collider);
} catch (Exception e) {
// Possible that some objects (X3D panel nodes) are without mesh
Log.e(Log.SUBSYSTEM.INPUT, TAG, "makePickable(): possible that some objects (X3D panel nodes) are without mesh!");
}
} | java | {
"resource": ""
} |
q5084 | GearWearableUtility.isInCircle | train | static boolean isInCircle(float x, float y, float centerX, float centerY, float
radius) {
return Math.abs(x - centerX) < radius && Math.abs(y - centerY) < radius;
} | java | {
"resource": ""
} |
q5085 | GVRRotationKey.setValue | train | public void setValue(Quaternionf rot) {
mX = rot.x;
mY = rot.y;
mZ = rot.z;
mW = rot.w;
} | java | {
"resource": ""
} |
q5086 | GVRFloatImage.update | train | public void update(int width, int height, float[] data)
throws IllegalArgumentException
{
if ((width <= 0) || (height <= 0) ||
(data == null) || (data.length < height * width * mFloatsPerPixel))
{
throw new IllegalArgumentException();
}
NativeFloatImage.update(getNative(), width, height, 0, data);
} | java | {
"resource": ""
} |
q5087 | ImageTexture.getUrl | train | public String[] getUrl() {
String[] valueDestination = new String[ url.size() ];
this.url.getValue(valueDestination);
return valueDestination;
} | java | {
"resource": ""
} |
q5088 | ArchLayout.getSizeArcLength | train | protected float getSizeArcLength(float angle) {
if (mRadius <= 0) {
throw new IllegalArgumentException("mRadius is not specified!");
}
return angle == Float.MAX_VALUE ? Float.MAX_VALUE :
LayoutHelpers.lengthOfArc(angle, mRadius);
} | java | {
"resource": ""
} |
q5089 | GVRConsole.writeLine | train | public void writeLine(String pattern, Object... parameters) {
String line = (parameters == null || parameters.length == 0) ? pattern
: String.format(pattern, parameters);
lines.add(0, line); // we'll write bottom to top, then purge unwritten
// lines from end
updateHUD();
} | java | {
"resource": ""
} |
q5090 | GVRConsole.setCanvasWidthHeight | train | public void setCanvasWidthHeight(int width, int height) {
hudWidth = width;
hudHeight = height;
HUD = Bitmap.createBitmap(width, height, Config.ARGB_8888);
canvas = new Canvas(HUD);
texture = null;
} | java | {
"resource": ""
} |
q5091 | MeshUtils.scale | train | public static void scale(GVRMesh mesh, float x, float y, float z) {
final float [] vertices = mesh.getVertices();
final int vsize = vertices.length;
for (int i = 0; i < vsize; i += 3) {
vertices[i] *= x;
vertices[i + 1] *= y;
vertices[i + 2] *= z;
}
mesh.setVertices(vertices);
} | java | {
"resource": ""
} |
q5092 | MeshUtils.resize | train | public static void resize(GVRMesh mesh, float xsize, float ysize, float zsize) {
float dim[] = getBoundingSize(mesh);
scale(mesh, xsize / dim[0], ysize / dim[1], zsize / dim[2]);
} | java | {
"resource": ""
} |
q5093 | MeshUtils.resize | train | public static void resize(GVRMesh mesh, float size) {
float dim[] = getBoundingSize(mesh);
float maxsize = 0.0f;
if (dim[0] > maxsize) maxsize = dim[0];
if (dim[1] > maxsize) maxsize = dim[1];
if (dim[2] > maxsize) maxsize = dim[2];
scale(mesh, size / maxsize);
} | java | {
"resource": ""
} |
q5094 | MeshUtils.getBoundingSize | train | public static float[] getBoundingSize(GVRMesh mesh) {
final float [] dim = new float[3];
final float [] vertices = mesh.getVertices();
final int vsize = vertices.length;
float minx = Integer.MAX_VALUE;
float miny = Integer.MAX_VALUE;
float minz = Integer.MAX_VALUE;
float maxx = Integer.MIN_VALUE;
float maxy = Integer.MIN_VALUE;
float maxz = Integer.MIN_VALUE;
for (int i = 0; i < vsize; i += 3) {
if (vertices[i] < minx) minx = vertices[i];
if (vertices[i] > maxx) maxx = vertices[i];
if (vertices[i + 1] < miny) miny = vertices[i + 1];
if (vertices[i + 1] > maxy) maxy = vertices[i + 1];
if (vertices[i + 2] < minz) minz = vertices[i + 2];
if (vertices[i + 2] > maxz) maxz = vertices[i + 2];
}
dim[0] = maxx - minx;
dim[1] = maxy - miny;
dim[2] = maxz - minz;
return dim;
} | java | {
"resource": ""
} |
q5095 | MeshUtils.createQuad | train | public static GVRMesh createQuad(GVRContext gvrContext, float width, float height) {
GVRMesh mesh = new GVRMesh(gvrContext);
float[] vertices = { width * -0.5f, height * 0.5f, 0.0f, width * -0.5f,
height * -0.5f, 0.0f, width * 0.5f, height * 0.5f, 0.0f,
width * 0.5f, height * -0.5f, 0.0f };
mesh.setVertices(vertices);
final float[] normals = { 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f, 1.0f };
mesh.setNormals(normals);
final float[] texCoords = { 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f,
1.0f };
mesh.setTexCoords(texCoords);
char[] triangles = { 0, 1, 2, 1, 3, 2 };
mesh.setIndices(triangles);
return mesh;
} | java | {
"resource": ""
} |
q5096 | OvrViewManager.onSurfaceChanged | train | void onSurfaceChanged(int width, int height) {
Log.v(TAG, "onSurfaceChanged");
final VrAppSettings.EyeBufferParams.DepthFormat depthFormat = mApplication.getAppSettings().getEyeBufferParams().getDepthFormat();
mApplication.getConfigurationManager().configureRendering(VrAppSettings.EyeBufferParams.DepthFormat.DEPTH_24_STENCIL_8 == depthFormat);
} | java | {
"resource": ""
} |
q5097 | OvrViewManager.onDrawEye | train | void onDrawEye(int eye, int swapChainIndex, boolean use_multiview) {
mCurrentEye = eye;
if (!(mSensoredScene == null || !mMainScene.equals(mSensoredScene))) {
GVRCameraRig mainCameraRig = mMainScene.getMainCameraRig();
if (use_multiview) {
if (DEBUG_STATS) {
mTracerDrawEyes1.enter(); // this eye is drawn first
mTracerDrawEyes2.enter();
}
GVRRenderTarget renderTarget = mRenderBundle.getRenderTarget(EYE.MULTIVIEW, swapChainIndex);
GVRCamera camera = mMainScene.getMainCameraRig().getCenterCamera();
GVRCamera left_camera = mMainScene.getMainCameraRig().getLeftCamera();
renderTarget.cullFromCamera(mMainScene, camera,mRenderBundle.getShaderManager());
captureCenterEye(renderTarget, true);
capture3DScreenShot(renderTarget, true);
renderTarget.render(mMainScene, left_camera, mRenderBundle.getShaderManager(),mRenderBundle.getPostEffectRenderTextureA(),
mRenderBundle.getPostEffectRenderTextureB());
captureRightEye(renderTarget, true);
captureLeftEye(renderTarget, true);
captureFinish();
if (DEBUG_STATS) {
mTracerDrawEyes1.leave();
mTracerDrawEyes2.leave();
}
} else {
if (eye == 1) {
if (DEBUG_STATS) {
mTracerDrawEyes1.enter();
}
GVRCamera rightCamera = mainCameraRig.getRightCamera();
GVRRenderTarget renderTarget = mRenderBundle.getRenderTarget(EYE.RIGHT, swapChainIndex);
renderTarget.render(mMainScene, rightCamera, mRenderBundle.getShaderManager(), mRenderBundle.getPostEffectRenderTextureA(),
mRenderBundle.getPostEffectRenderTextureB());
captureRightEye(renderTarget, false);
captureFinish();
if (DEBUG_STATS) {
mTracerDrawEyes1.leave();
mTracerDrawEyes.leave();
}
} else {
if (DEBUG_STATS) {
mTracerDrawEyes1.leave();
mTracerDrawEyes.leave();
}
GVRRenderTarget renderTarget = mRenderBundle.getRenderTarget(EYE.LEFT, swapChainIndex);
GVRCamera leftCamera = mainCameraRig.getLeftCamera();
capture3DScreenShot(renderTarget, false);
renderTarget.cullFromCamera(mMainScene, mainCameraRig.getCenterCamera(), mRenderBundle.getShaderManager());
captureCenterEye(renderTarget, false);
renderTarget.render(mMainScene, leftCamera, mRenderBundle.getShaderManager(), mRenderBundle.getPostEffectRenderTextureA(), mRenderBundle.getPostEffectRenderTextureB());
captureLeftEye(renderTarget, false);
if (DEBUG_STATS) {
mTracerDrawEyes2.leave();
}
}
}
}
} | java | {
"resource": ""
} |
q5098 | GVRResourceVolume.openResource | train | public GVRAndroidResource openResource(String filePath) throws IOException {
// Error tolerance: Remove initial '/' introduced by file::///filename
// In this case, the path is interpreted as relative to defaultPath,
// which is the root of the filesystem.
if (filePath.startsWith(File.separator)) {
filePath = filePath.substring(File.separator.length());
}
filePath = adaptFilePath(filePath);
String path;
int resourceId;
GVRAndroidResource resourceKey;
switch (volumeType) {
case ANDROID_ASSETS:
// Resolve '..' and '.'
path = getFullPath(defaultPath, filePath);
path = new File(path).getCanonicalPath();
if (path.startsWith(File.separator)) {
path = path.substring(1);
}
resourceKey = new GVRAndroidResource(gvrContext, path);
break;
case ANDROID_RESOURCE:
path = FileNameUtils.getBaseName(filePath);
resourceId = gvrContext.getContext().getResources().getIdentifier(path, "raw", gvrContext.getContext().getPackageName());
if (resourceId == 0) {
throw new FileNotFoundException(filePath + " resource not found");
}
resourceKey = new GVRAndroidResource(gvrContext, resourceId);
break;
case LINUX_FILESYSTEM:
resourceKey = new GVRAndroidResource(
getFullPath(defaultPath, filePath));
break;
case ANDROID_SDCARD:
String linuxPath = Environment.getExternalStorageDirectory()
.getAbsolutePath();
resourceKey = new GVRAndroidResource(
getFullPath(linuxPath, defaultPath, filePath));
break;
case INPUT_STREAM:
resourceKey = new GVRAndroidResource(getFullPath(defaultPath, filePath), volumeInputStream);
break;
case NETWORK:
resourceKey = new GVRAndroidResource(gvrContext,
getFullURL(defaultPath, filePath), enableUrlLocalCache);
break;
default:
throw new IOException(
String.format("Unrecognized volumeType %s", volumeType));
}
return addResource(resourceKey);
} | java | {
"resource": ""
} |
q5099 | GVRResourceVolume.adaptFilePath | train | protected String adaptFilePath(String filePath) {
// Convert windows file path to target FS
String targetPath = filePath.replaceAll("\\\\", volumeType.getSeparator());
return targetPath;
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.