code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
private static String createImageStreamRequest(String name, String version, String image, boolean insecure) {
JSONObject imageStream = new JSONObject();
JSONObject metadata = new JSONObject();
JSONObject annotations = new JSONObject();
metadata.put("name", name);
annotations.put("openshift.io/image.insecureRepository", insecure);
metadata.put("annotations", annotations);
// Definition of the image
JSONObject from = new JSONObject();
from.put("kind", "DockerImage");
from.put("name", image);
JSONObject importPolicy = new JSONObject();
importPolicy.put("insecure", insecure);
JSONObject tag = new JSONObject();
tag.put("name", version);
tag.put("from", from);
tag.put("importPolicy", importPolicy);
JSONObject tagAnnotations = new JSONObject();
tagAnnotations.put("version", version);
tag.put("annotations", tagAnnotations);
JSONArray tags = new JSONArray();
tags.add(tag);
// Add image definition to image stream
JSONObject spec = new JSONObject();
spec.put("tags", tags);
imageStream.put("kind", "ImageStream");
imageStream.put("apiVersion", "v1");
imageStream.put("metadata", metadata);
imageStream.put("spec", spec);
return imageStream.toJSONString();
} | java |
static <T> List<Template> getTemplates(T objectType) {
try {
List<Template> templates = new ArrayList<>();
TEMP_FINDER.findAnnotations(templates, objectType);
return templates;
} catch (Exception e) {
throw new IllegalStateException(e);
}
} | java |
static <T> boolean syncInstantiation(T objectType) {
List<Template> templates = new ArrayList<>();
Templates tr = TEMP_FINDER.findAnnotations(templates, objectType);
if (tr == null) {
/* Default to synchronous instantiation */
return true;
} else {
return tr.syncInstantiation();
}
} | java |
public void deployApplication(String applicationName, String... classpathLocations) throws IOException {
final List<URL> classpathElements = Arrays.stream(classpathLocations)
.map(classpath -> Thread.currentThread().getContextClassLoader().getResource(classpath))
.collect(Collectors.toList());
deployApplication(applicationName, classpathElements.toArray(new URL[classpathElements.size()]));
} | java |
public void deployApplication(String applicationName, URL... urls) throws IOException {
this.applicationName = applicationName;
for (URL url : urls) {
try (InputStream inputStream = url.openStream()) {
deploy(inputStream);
}
}
} | java |
public void deploy(InputStream inputStream) throws IOException {
final List<? extends HasMetadata> entities = deploy("application", inputStream);
if (this.applicationName == null) {
Optional<String> deployment = entities.stream()
.filter(hm -> hm instanceof Deployment)
.map(hm -> (Deployment) hm)
.map(rc -> rc.getMetadata().getName()).findFirst();
deployment.ifPresent(name -> this.applicationName = name);
}
} | java |
public Optional<URL> getServiceUrl(String name) {
Service service = client.services().inNamespace(namespace).withName(name).get();
return service != null ? createUrlForService(service) : Optional.empty();
} | java |
public Optional<URL> getServiceUrl() {
Optional<Service> optionalService = client.services().inNamespace(namespace)
.list().getItems()
.stream()
.findFirst();
return optionalService
.map(this::createUrlForService)
.orElse(Optional.empty());
} | java |
public void cleanup() {
List<String> keys = new ArrayList<>(created.keySet());
keys.sort(String::compareTo);
for (String key : keys) {
created.remove(key)
.stream()
.sorted(Comparator.comparing(HasMetadata::getKind))
.forEach(metadata -> {
log.info(String.format("Deleting %s : %s", key, metadata.getKind()));
deleteWithRetries(metadata);
});
}
} | java |
public void awaitPodReadinessOrFail(Predicate<Pod> filter) {
await().atMost(5, TimeUnit.MINUTES).until(() -> {
List<Pod> list = client.pods().inNamespace(namespace).list().getItems();
return list.stream()
.filter(filter)
.filter(Readiness::isPodReady)
.collect(Collectors.toList()).size() >= 1;
}
);
} | java |
private static Version getDockerVersion(String serverUrl) {
try {
DockerClient client = DockerClientBuilder.getInstance(serverUrl).build();
return client.versionCmd().exec();
} catch (Exception e) {
return null;
}
} | java |
public void configure(@Observes(precedence = -10) ArquillianDescriptor arquillianDescriptor) {
Map<String, String> config = arquillianDescriptor.extension(EXTENSION_NAME).getExtensionProperties();
CubeConfiguration cubeConfiguration = CubeConfiguration.fromMap(config);
configurationProducer.set(cubeConfiguration);
} | java |
public void configure(@Observes(precedence = -200) ArquillianDescriptor arquillianDescriptor) {
restAssuredConfigurationInstanceProducer.set(
RestAssuredConfiguration.fromMap(arquillianDescriptor
.extension("restassured")
.getExtensionProperties()));
} | java |
public Map<String, String> resolve(Map<String, String> config) {
config = resolveSystemEnvironmentVariables(config);
config = resolveSystemDefaultSetup(config);
config = resolveDockerInsideDocker(config);
config = resolveDownloadDockerMachine(config);
config = resolveAutoStartDockerMachine(config);
config = resolveDefaultDockerMachine(config);
config = resolveServerUriByOperativeSystem(config);
config = resolveServerIp(config);
config = resolveTlsVerification(config);
return config;
} | java |
public static String fromClassPath() {
Set<String> versions = new HashSet<>();
try {
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
Enumeration<URL> manifests = classLoader.getResources("META-INF/MANIFEST.MF");
while (manifests.hasMoreElements()) {
URL manifestURL = manifests.nextElement();
try (InputStream is = manifestURL.openStream()) {
Manifest manifest = new Manifest();
manifest.read(is);
Attributes buildInfo = manifest.getAttributes("Build-Info");
if (buildInfo != null) {
if (buildInfo.getValue("Selenium-Version") != null) {
versions.add(buildInfo.getValue("Selenium-Version"));
} else {
// might be in build-info part
if (manifest.getEntries() != null) {
if (manifest.getEntries().containsKey("Build-Info")) {
final Attributes attributes = manifest.getEntries().get("Build-Info");
if (attributes.getValue("Selenium-Version") != null) {
versions.add(attributes.getValue("Selenium-Version"));
}
}
}
}
}
}
}
} catch (Exception e) {
logger.log(Level.WARNING,
"Exception {0} occurred while resolving selenium version and latest image is going to be used.",
e.getMessage());
return SELENIUM_VERSION;
}
if (versions.isEmpty()) {
logger.log(Level.INFO, "No version of Selenium found in classpath. Using latest image.");
return SELENIUM_VERSION;
}
String foundVersion = versions.iterator().next();
if (versions.size() > 1) {
logger.log(Level.WARNING, "Multiple versions of Selenium found in classpath. Using the first one found {0}.",
foundVersion);
}
return foundVersion;
} | java |
public static URL getKubernetesConfigurationUrl(Map<String, String> map) throws MalformedURLException {
if (Strings.isNotNullOrEmpty(Utils.getSystemPropertyOrEnvVar(ENVIRONMENT_CONFIG_URL, ""))) {
return new URL(Utils.getSystemPropertyOrEnvVar(ENVIRONMENT_CONFIG_URL, ""));
} else if (Strings.isNotNullOrEmpty(Utils.getSystemPropertyOrEnvVar(ENVIRONMENT_CONFIG_RESOURCE_NAME, ""))) {
String resourceName = Utils.getSystemPropertyOrEnvVar(ENVIRONMENT_CONFIG_RESOURCE_NAME, "");
return findConfigResource(resourceName);
} else if (map.containsKey(ENVIRONMENT_CONFIG_URL)) {
return new URL(map.get(ENVIRONMENT_CONFIG_URL));
} else if (map.containsKey(ENVIRONMENT_CONFIG_RESOURCE_NAME)) {
String resourceName = map.get(ENVIRONMENT_CONFIG_RESOURCE_NAME);
return findConfigResource(resourceName);
} else {
// Let the resource locator find the resource
return null;
}
} | java |
public static URL findConfigResource(String resourceName) {
if (Strings.isNullOrEmpty(resourceName)) {
return null;
}
final URL url = resourceName.startsWith(ROOT) ? DefaultConfiguration.class.getResource(resourceName)
: DefaultConfiguration.class.getResource(ROOT + resourceName);
if (url != null) {
return url;
}
// This is useful to get resource under META-INF directory
String[] resourceNamePrefix = new String[] {"META-INF/fabric8/", "META-INF/fabric8/"};
for (String resource : resourceNamePrefix) {
String fullResourceName = resource + resourceName;
URL candidate = KubernetesResourceLocator.class.getResource(fullResourceName.startsWith(ROOT) ? fullResourceName : ROOT + fullResourceName);
if (candidate != null) {
return candidate;
}
}
return null;
} | java |
public static URL asUrlOrResource(String s) {
if (Strings.isNullOrEmpty(s)) {
return null;
}
try {
return new URL(s);
} catch (MalformedURLException e) {
//If its not a valid URL try to treat it as a local resource.
return findConfigResource(s);
}
} | java |
@Override
public void deploy(InputStream inputStream) throws IOException {
final List<? extends HasMetadata> entities = deploy("application", inputStream);
if (this.applicationName == null) {
Optional<String> deploymentConfig = entities.stream()
.filter(hm -> hm instanceof DeploymentConfig)
.map(hm -> (DeploymentConfig) hm)
.map(dc -> dc.getMetadata().getName()).findFirst();
deploymentConfig.ifPresent(name -> this.applicationName = name);
}
} | java |
public Optional<URL> getRoute(String routeName) {
Route route = getClient().routes()
.inNamespace(namespace).withName(routeName).get();
return route != null ? Optional.ofNullable(createUrlFromRoute(route)) : Optional.empty();
} | java |
public Optional<URL> getRoute() {
Optional<Route> optionalRoute = getClient().routes().inNamespace(namespace)
.list().getItems()
.stream()
.findFirst();
return optionalRoute
.map(OpenShiftRouteLocator::createUrlFromRoute);
} | java |
public boolean projectExists(String name) throws IllegalArgumentException {
if (name == null || name.isEmpty()) {
throw new IllegalArgumentException("Project name cannot be empty");
}
return listProjects().stream()
.map(p -> p.getMetadata().getName())
.anyMatch(Predicate.isEqual(name));
} | java |
public Optional<Project> findProject(String name) throws IllegalArgumentException {
if (name == null || name.isEmpty()) {
throw new IllegalArgumentException("Project name cannot be empty");
}
return getProject(name);
} | java |
private static Constraint loadConstraint(Annotation context) {
Constraint constraint = null;
final ServiceLoader<Constraint> constraints = ServiceLoader.load(Constraint.class);
for (Constraint aConstraint : constraints) {
try {
aConstraint.getClass().getDeclaredMethod("check", context.annotationType());
constraint = aConstraint;
break;
} catch (NoSuchMethodException e) {
// Look for next implementation if method not found with required signature.
}
}
if (constraint == null) {
throw new IllegalStateException("Couldn't found any implementation of " + Constraint.class.getName());
}
return constraint;
} | java |
public void createEnvironment(@Observes(precedence = 10) BeforeClass event, OpenShiftAdapter client,
CubeOpenShiftConfiguration cubeOpenShiftConfiguration) {
final TestClass testClass = event.getTestClass();
log.info(String.format("Creating environment for %s", testClass.getName()));
OpenShiftResourceFactory.createResources(testClass.getName(), client, testClass.getJavaClass(),
cubeOpenShiftConfiguration.getProperties());
classTemplateProcessor = new ClassTemplateProcessor(client, cubeOpenShiftConfiguration, testClass);
final List<? extends OpenShiftResource> templateResources = classTemplateProcessor.processTemplateResources();
templateDetailsProducer.set(() -> templateResources);
} | java |
public DockerContainerObjectBuilder<T> withContainerObjectClass(Class<T> containerObjectClass) {
if (containerObjectClass == null) {
throw new IllegalArgumentException("container object class cannot be null");
}
this.containerObjectClass = containerObjectClass;
//First we check if this ContainerObject is defining a @CubeDockerFile in static method
final List<Method> methodsWithCubeDockerFile =
ReflectionUtil.getMethodsWithAnnotation(containerObjectClass, CubeDockerFile.class);
if (methodsWithCubeDockerFile.size() > 1) {
throw new IllegalArgumentException(
String.format(
"More than one %s annotation found and only one was expected. Methods where annotation was found are: %s",
CubeDockerFile.class.getSimpleName(), methodsWithCubeDockerFile));
}
classHasMethodWithCubeDockerFile = !methodsWithCubeDockerFile.isEmpty();
classDefinesCubeDockerFile = containerObjectClass.isAnnotationPresent(CubeDockerFile.class);
classDefinesImage = containerObjectClass.isAnnotationPresent(Image.class);
if (classHasMethodWithCubeDockerFile) {
methodWithCubeDockerFile = methodsWithCubeDockerFile.get(0);
boolean isMethodStatic = Modifier.isStatic(methodWithCubeDockerFile.getModifiers());
boolean methodHasNoArguments = methodWithCubeDockerFile.getParameterCount() == 0;
boolean methodReturnsAnArchive = Archive.class.isAssignableFrom(methodWithCubeDockerFile.getReturnType());
if (!isMethodStatic || !methodHasNoArguments || !methodReturnsAnArchive) {
throw new IllegalArgumentException(
String.format("Method %s annotated with %s is expected to be static, no args and return %s.",
methodWithCubeDockerFile, CubeDockerFile.class.getSimpleName(), Archive.class.getSimpleName()));
}
}
// User has defined @CubeDockerfile on the class and a method
if (classHasMethodWithCubeDockerFile && classDefinesCubeDockerFile) {
throw new IllegalArgumentException(
String.format(
"More than one %s annotation found and only one was expected. Both class and method %s has the annotation.",
CubeDockerFile.class.getSimpleName(), methodWithCubeDockerFile));
}
// User has defined @CubeDockerfile and @Image
if ((classHasMethodWithCubeDockerFile || classDefinesCubeDockerFile) && classDefinesImage) {
throw new IllegalArgumentException(
String.format("Container Object %s has defined %s annotation and %s annotation together.",
containerObjectClass.getSimpleName(), Image.class.getSimpleName(),
CubeDockerFile.class.getSimpleName()));
}
// User has not defined either @CubeDockerfile or @Image
if (!classDefinesCubeDockerFile && !classDefinesImage && !classHasMethodWithCubeDockerFile) {
throw new IllegalArgumentException(
String.format("Container Object %s is not annotated with either %s or %s annotations.",
containerObjectClass.getName(), CubeDockerFile.class.getSimpleName(), Image.class.getSimpleName()));
}
return this;
} | java |
public DockerContainerObjectBuilder<T> withEnrichers(Collection<TestEnricher> enrichers) {
if (enrichers == null) {
throw new IllegalArgumentException("enrichers cannot be null");
}
this.enrichers = enrichers;
return this;
} | java |
public T build() throws IllegalAccessException, IOException, InvocationTargetException {
generatedConfigutation = new CubeContainer();
findContainerName();
// if needed, prepare prepare resources required to build a docker image
prepareImageBuild();
// instantiate container object
instantiateContainerObject();
// enrich container object (without cube instance)
enrichContainerObjectBeforeCube();
// extract configuration from container object class
extractConfigurationFromContainerObject();
// merge received configuration with extracted configuration
mergeContainerObjectConfiguration();
// create/start/register associated cube
initializeCube();
// enrich container object (with cube instance)
enrichContainerObjectWithCube();
// return created container object
return containerObjectInstance;
} | java |
private static Path resolveDockerDefinition(Path fullpath) {
final Path ymlPath = fullpath.resolveSibling(fullpath.getFileName() + ".yml");
if (Files.exists(ymlPath)) {
return ymlPath;
} else {
final Path yamlPath = fullpath.resolveSibling(fullpath.getFileName() + ".yaml");
if (Files.exists(yamlPath)) {
return yamlPath;
}
}
return null;
} | java |
public static void awaitRoute(URL routeUrl, int timeout, TimeUnit timeoutUnit, int repetitions, int... statusCodes) {
AtomicInteger successfulAwaitsInARow = new AtomicInteger(0);
await().atMost(timeout, timeoutUnit).until(() -> {
if (tryConnect(routeUrl, statusCodes)) {
successfulAwaitsInARow.incrementAndGet();
} else {
successfulAwaitsInARow.set(0);
}
return successfulAwaitsInARow.get() >= repetitions;
});
} | java |
public static Constructor<?> getConstructor(final Class<?> clazz,
final Class<?>... argumentTypes) throws NoSuchMethodException {
try {
return AccessController
.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
public Constructor<?> run()
throws NoSuchMethodException {
return clazz.getConstructor(argumentTypes);
}
});
}
// Unwrap
catch (final PrivilegedActionException pae) {
final Throwable t = pae.getCause();
// Rethrow
if (t instanceof NoSuchMethodException) {
throw (NoSuchMethodException) t;
} else {
// No other checked Exception thrown by Class.getConstructor
try {
throw (RuntimeException) t;
}
// Just in case we've really messed up
catch (final ClassCastException cce) {
throw new RuntimeException(
"Obtained unchecked Exception; this code should never be reached",
t);
}
}
}
} | java |
public static String getStringProperty(String name, Map<String, String> map, String defaultValue) {
if (map.containsKey(name) && Strings.isNotNullOrEmpty(map.get(name))) {
defaultValue = map.get(name);
}
return getPropertyOrEnvironmentVariable(name, defaultValue);
} | java |
public OpenShiftAssistantTemplate parameter(String name, String value) {
parameterValues.put(name, value);
return this;
} | java |
public static Timespan create(Timespan... timespans) {
if (timespans == null) {
return null;
}
if (timespans.length == 0) {
return ZERO_MILLISECONDS;
}
Timespan res = timespans[0];
for (int i = 1; i < timespans.length; i++) {
Timespan timespan = timespans[i];
res = res.add(timespan);
}
return res;
} | java |
public void install(@Observes(precedence = 90) CubeDockerConfiguration configuration,
ArquillianDescriptor arquillianDescriptor) {
DockerCompositions cubes = configuration.getDockerContainersContent();
final SeleniumContainers seleniumContainers =
SeleniumContainers.create(getBrowser(arquillianDescriptor), cubeDroneConfigurationInstance.get());
cubes.add(seleniumContainers.getSeleniumContainerName(), seleniumContainers.getSeleniumContainer());
final boolean recording = cubeDroneConfigurationInstance.get().isRecording();
if (recording) {
cubes.add(seleniumContainers.getVncContainerName(), seleniumContainers.getVncContainer());
cubes.add(seleniumContainers.getVideoConverterContainerName(),
seleniumContainers.getVideoConverterContainer());
}
seleniumContainersInstanceProducer.set(seleniumContainers);
System.out.println("SELENIUM INSTALLED");
System.out.println(ConfigUtil.dump(cubes));
} | java |
public void startDockerMachine(String cliPathExec, String machineName) {
commandLineExecutor.execCommand(createDockerMachineCommand(cliPathExec), "start", machineName);
this.manuallyStarted = true;
} | java |
public boolean isDockerMachineInstalled(String cliPathExec) {
try {
commandLineExecutor.execCommand(createDockerMachineCommand(cliPathExec));
return true;
} catch (Exception e) {
return false;
}
} | java |
public void overrideCubeProperties(DockerCompositions overrideDockerCompositions) {
final Set<String> containerIds = overrideDockerCompositions.getContainerIds();
for (String containerId : containerIds) {
// main definition of containers contains a container that must be overrode
if (containers.containsKey(containerId)) {
final CubeContainer cubeContainer = containers.get(containerId);
final CubeContainer overrideCubeContainer = overrideDockerCompositions.get(containerId);
cubeContainer.setRemoveVolumes(overrideCubeContainer.getRemoveVolumes());
cubeContainer.setAlwaysPull(overrideCubeContainer.getAlwaysPull());
if (overrideCubeContainer.hasAwait()) {
cubeContainer.setAwait(overrideCubeContainer.getAwait());
}
if (overrideCubeContainer.hasBeforeStop()) {
cubeContainer.setBeforeStop(overrideCubeContainer.getBeforeStop());
}
if (overrideCubeContainer.isManual()) {
cubeContainer.setManual(overrideCubeContainer.isManual());
}
if (overrideCubeContainer.isKillContainer()) {
cubeContainer.setKillContainer(overrideCubeContainer.isKillContainer());
}
} else {
logger.warning(String.format("Overriding Container %s are not defined in main definition of containers.",
containerId));
}
}
} | java |
public static String replaceParameters(final InputStream stream) {
String content = IOUtil.asStringPreservingNewLines(stream);
return resolvePlaceholders(content);
} | java |
public static String join(final Collection<?> collection, final String separator) {
StringBuffer buffer = new StringBuffer();
boolean first = true;
Iterator<?> iter = collection.iterator();
while (iter.hasNext()) {
Object next = iter.next();
if (first) {
first = false;
} else {
buffer.append(separator);
}
buffer.append(next);
}
return buffer.toString();
} | java |
public static List<String> splitAsList(String text, String delimiter) {
List<String> answer = new ArrayList<String>();
if (text != null && text.length() > 0) {
answer.addAll(Arrays.asList(text.split(delimiter)));
}
return answer;
} | java |
public static List<String> splitAndTrimAsList(String text, String sep) {
ArrayList<String> answer = new ArrayList<>();
if (text != null && text.length() > 0) {
for (String v : text.split(sep)) {
String trim = v.trim();
if (trim.length() > 0) {
answer.add(trim);
}
}
}
return answer;
} | java |
public void waitForDeployments(@Observes(precedence = -100) AfterStart event, OpenShiftAdapter client,
CEEnvironmentProcessor.TemplateDetails details, TestClass testClass, CubeOpenShiftConfiguration configuration, OpenShiftClient openshiftClient)
throws Exception {
if (testClass == null) {
// nothing to do, since we're not in ClassScoped context
return;
}
if (details == null) {
log.warning(String.format("No environment for %s", testClass.getName()));
return;
}
log.info(String.format("Waiting for environment for %s", testClass.getName()));
try {
delay(client, details.getResources());
} catch (Throwable t) {
throw new IllegalArgumentException("Error waiting for template resources to deploy: " + testClass.getName(), t);
}
} | java |
public static boolean validate(final String ip) {
Matcher matcher = pattern.matcher(ip);
return matcher.matches();
} | java |
@Override
protected AbstractFilePickerFragment<File> getFragment(
final String startPath, final int mode, final boolean allowMultiple,
final boolean allowDirCreate, final boolean allowExistingFile,
final boolean singleClick) {
// startPath is allowed to be null.
// In that case, default folder should be SD-card and not "/"
String path = (startPath != null ? startPath
: Environment.getExternalStorageDirectory().getPath());
currentFragment = new BackHandlingFilePickerFragment();
currentFragment.setArgs(path, mode, allowMultiple, allowDirCreate,
allowExistingFile, singleClick);
return currentFragment;
} | java |
@NonNull
@Override
public File getParent(@NonNull final File from) {
if (from.getPath().equals(getRoot().getPath())) {
// Already at root, we can't go higher
return from;
} else if (from.getParentFile() != null) {
return from.getParentFile();
} else {
return from;
}
} | java |
@NonNull
@Override
public Loader<SortedList<File>> getLoader() {
return new AsyncTaskLoader<SortedList<File>>(getActivity()) {
FileObserver fileObserver;
@Override
public SortedList<File> loadInBackground() {
File[] listFiles = mCurrentPath.listFiles();
final int initCap = listFiles == null ? 0 : listFiles.length;
SortedList<File> files = new SortedList<>(File.class, new SortedListAdapterCallback<File>(getDummyAdapter()) {
@Override
public int compare(File lhs, File rhs) {
return compareFiles(lhs, rhs);
}
@Override
public boolean areContentsTheSame(File file, File file2) {
return file.getAbsolutePath().equals(file2.getAbsolutePath()) && (file.isFile() == file2.isFile());
}
@Override
public boolean areItemsTheSame(File file, File file2) {
return areContentsTheSame(file, file2);
}
}, initCap);
files.beginBatchedUpdates();
if (listFiles != null) {
for (java.io.File f : listFiles) {
if (isItemVisible(f)) {
files.add(f);
}
}
}
files.endBatchedUpdates();
return files;
}
/**
* Handles a request to start the Loader.
*/
@Override
protected void onStartLoading() {
super.onStartLoading();
// handle if directory does not exist. Fall back to root.
if (mCurrentPath == null || !mCurrentPath.isDirectory()) {
mCurrentPath = getRoot();
}
// Start watching for changes
fileObserver = new FileObserver(mCurrentPath.getPath(),
FileObserver.CREATE |
FileObserver.DELETE
| FileObserver.MOVED_FROM | FileObserver.MOVED_TO
) {
@Override
public void onEvent(int event, String path) {
// Reload
onContentChanged();
}
};
fileObserver.startWatching();
forceLoad();
}
/**
* Handles a request to completely reset the Loader.
*/
@Override
protected void onReset() {
super.onReset();
// Stop watching
if (fileObserver != null) {
fileObserver.stopWatching();
fileObserver = null;
}
}
};
} | java |
@Override
public void onLoadFinished(final Loader<SortedList<T>> loader,
final SortedList<T> data) {
isLoading = false;
mCheckedItems.clear();
mCheckedVisibleViewHolders.clear();
mFiles = data;
mAdapter.setList(data);
if (mCurrentDirView != null) {
mCurrentDirView.setText(getFullPath(mCurrentPath));
}
// Stop loading now to avoid a refresh clearing the user's selections
getLoaderManager().destroyLoader( 0 );
} | java |
public void clearSelections() {
for (CheckableViewHolder vh : mCheckedVisibleViewHolders) {
vh.checkbox.setChecked(false);
}
mCheckedVisibleViewHolders.clear();
mCheckedItems.clear();
} | java |
protected boolean isMultimedia(File file) {
//noinspection SimplifiableIfStatement
if (isDir(file)) {
return false;
}
String path = file.getPath().toLowerCase();
for (String ext : MULTIMEDIA_EXTENSIONS) {
if (path.endsWith(ext)) {
return true;
}
}
return false;
} | java |
@NonNull
@Override
public Loader<SortedList<FtpFile>> getLoader() {
return new AsyncTaskLoader<SortedList<FtpFile>>(getContext()) {
@Override
public SortedList<FtpFile> loadInBackground() {
SortedList<FtpFile> sortedList = new SortedList<>(FtpFile.class, new SortedListAdapterCallback<FtpFile>(getDummyAdapter()) {
@Override
public int compare(FtpFile lhs, FtpFile rhs) {
if (lhs.isDirectory() && !rhs.isDirectory()) {
return -1;
} else if (rhs.isDirectory() && !lhs.isDirectory()) {
return 1;
} else {
return lhs.getName().compareToIgnoreCase(rhs.getName());
}
}
@Override
public boolean areContentsTheSame(FtpFile oldItem, FtpFile newItem) {
return oldItem.getName().equals(newItem.getName());
}
@Override
public boolean areItemsTheSame(FtpFile item1, FtpFile item2) {
return item1.getName().equals(item2.getName());
}
});
if (!ftp.isConnected()) {
// Connect
try {
ftp.connect(server, port);
ftp.setFileType(FTP.ASCII_FILE_TYPE);
ftp.enterLocalPassiveMode();
ftp.setUseEPSVwithIPv4(false);
if (!(loggedIn = ftp.login(username, password))) {
ftp.logout();
Log.e(TAG, "Login failed");
}
} catch (IOException e) {
if (ftp.isConnected()) {
try {
ftp.disconnect();
} catch (IOException ignored) {
}
}
Log.e(TAG, "Could not connect to server.");
}
}
if (loggedIn) {
try {
// handle if directory does not exist. Fall back to root.
if (mCurrentPath == null || !mCurrentPath.isDirectory()) {
mCurrentPath = getRoot();
}
sortedList.beginBatchedUpdates();
for (FTPFile f : ftp.listFiles(mCurrentPath.getPath())) {
FtpFile file;
if (f.isDirectory()) {
file = new FtpDir(mCurrentPath, f.getName());
} else {
file = new FtpFile(mCurrentPath, f.getName());
}
if (isItemVisible(file)) {
sortedList.add(file);
}
}
sortedList.endBatchedUpdates();
} catch (IOException e) {
Log.e(TAG, "IOException: " + e.getMessage());
}
}
return sortedList;
}
/**
* Handles a request to start the Loader.
*/
@Override
protected void onStartLoading() {
super.onStartLoading();
// handle if directory does not exist. Fall back to root.
if (mCurrentPath == null || !mCurrentPath.isDirectory()) {
mCurrentPath = getRoot();
}
forceLoad();
}
};
} | java |
@JsonProperty
public String timestamp() {
if (timestampAsText == null) {
timestampAsText = DateTimeFormatter.ISO_INSTANT.format(timestamp);
}
return timestampAsText;
} | java |
public static CentralDogma forConfig(File configFile) throws IOException {
requireNonNull(configFile, "configFile");
return new CentralDogma(Jackson.readValue(configFile, CentralDogmaConfig.class));
} | java |
public Optional<ServerPort> activePort() {
final Server server = this.server;
return server != null ? server.activePort() : Optional.empty();
} | java |
public Map<InetSocketAddress, ServerPort> activePorts() {
final Server server = this.server;
if (server != null) {
return server.activePorts();
} else {
return Collections.emptyMap();
}
} | java |
public CompletableFuture<Void> stop() {
numPendingStopRequests.incrementAndGet();
return startStop.stop().thenRun(numPendingStopRequests::decrementAndGet);
} | java |
public static void initializeInternalProject(CommandExecutor executor) {
final long creationTimeMillis = System.currentTimeMillis();
try {
executor.execute(createProject(creationTimeMillis, Author.SYSTEM, INTERNAL_PROJ))
.get();
} catch (Throwable cause) {
cause = Exceptions.peel(cause);
if (!(cause instanceof ProjectExistsException)) {
throw new Error("failed to initialize an internal project", cause);
}
}
// These repositories might be created when creating an internal project, but we try to create them
// again here in order to make sure them exist because sometimes their names are changed.
for (final String repo : ImmutableList.of(Project.REPO_META, Project.REPO_DOGMA)) {
try {
executor.execute(createRepository(creationTimeMillis, Author.SYSTEM, INTERNAL_PROJ, repo))
.get();
} catch (Throwable cause) {
cause = Exceptions.peel(cause);
if (!(cause instanceof RepositoryExistsException)) {
throw new Error(cause);
}
}
}
} | java |
@Override
protected <T> CompletableFuture<T> doExecute(Command<T> command) throws Exception {
final CompletableFuture<T> future = new CompletableFuture<>();
executor.execute(() -> {
try {
future.complete(blockingExecute(command));
} catch (Throwable t) {
future.completeExceptionally(t);
}
});
return future;
} | java |
public static long makeReasonable(long expectedTimeoutMillis, long bufferMillis) {
checkArgument(expectedTimeoutMillis > 0,
"expectedTimeoutMillis: %s (expected: > 0)", expectedTimeoutMillis);
checkArgument(bufferMillis >= 0,
"bufferMillis: %s (expected: > 0)", bufferMillis);
final long timeout = Math.min(expectedTimeoutMillis, MAX_MILLIS);
if (bufferMillis == 0) {
return timeout;
}
if (timeout > MAX_MILLIS - bufferMillis) {
return MAX_MILLIS;
} else {
return bufferMillis + timeout;
}
} | java |
public CentralDogmaBuilder port(InetSocketAddress localAddress, SessionProtocol protocol) {
return port(new ServerPort(localAddress, protocol));
} | java |
void close(Supplier<CentralDogmaException> failureCauseSupplier) {
requireNonNull(failureCauseSupplier, "failureCauseSupplier");
if (closePending.compareAndSet(null, failureCauseSupplier)) {
repositoryWorker.execute(() -> {
rwLock.writeLock().lock();
try {
if (commitIdDatabase != null) {
try {
commitIdDatabase.close();
} catch (Exception e) {
logger.warn("Failed to close a commitId database:", e);
}
}
if (jGitRepository != null) {
try {
jGitRepository.close();
} catch (Exception e) {
logger.warn("Failed to close a Git repository: {}",
jGitRepository.getDirectory(), e);
}
}
} finally {
rwLock.writeLock().unlock();
commitWatchers.close(failureCauseSupplier);
closeFuture.complete(null);
}
});
}
closeFuture.join();
} | java |
@Override
public CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern) {
final ServiceRequestContext ctx = context();
return CompletableFuture.supplyAsync(() -> {
requireNonNull(from, "from");
requireNonNull(to, "to");
requireNonNull(pathPattern, "pathPattern");
failFastIfTimedOut(this, logger, ctx, "diff", from, to, pathPattern);
final RevisionRange range = normalizeNow(from, to).toAscending();
readLock();
try (RevWalk rw = new RevWalk(jGitRepository)) {
final RevTree treeA = rw.parseTree(commitIdDatabase.get(range.from()));
final RevTree treeB = rw.parseTree(commitIdDatabase.get(range.to()));
// Compare the two Git trees.
// Note that we do not cache here because CachingRepository caches the final result already.
return toChangeMap(blockingCompareTreesUncached(treeA, treeB,
pathPatternFilterOrTreeFilter(pathPattern)));
} catch (StorageException e) {
throw e;
} catch (Exception e) {
throw new StorageException("failed to parse two trees: range=" + range, e);
} finally {
readUnlock();
}
}, repositoryWorker);
} | java |
private Revision uncachedHeadRevision() {
try (RevWalk revWalk = new RevWalk(jGitRepository)) {
final ObjectId headRevisionId = jGitRepository.resolve(R_HEADS_MASTER);
if (headRevisionId != null) {
final RevCommit revCommit = revWalk.parseCommit(headRevisionId);
return CommitUtil.extractRevision(revCommit.getFullMessage());
}
} catch (CentralDogmaException e) {
throw e;
} catch (Exception e) {
throw new StorageException("failed to get the current revision", e);
}
throw new StorageException("failed to determine the HEAD: " + jGitRepository.getDirectory());
} | java |
public static String simpleTypeName(Object obj) {
if (obj == null) {
return "null";
}
return simpleTypeName(obj.getClass(), false);
} | java |
public final B accessToken(String accessToken) {
requireNonNull(accessToken, "accessToken");
checkArgument(!accessToken.isEmpty(), "accessToken is empty.");
this.accessToken = accessToken;
return self();
} | java |
public static JsonPatch fromJson(final JsonNode node) throws IOException {
requireNonNull(node, "node");
try {
return Jackson.treeToValue(node, JsonPatch.class);
} catch (JsonMappingException e) {
throw new JsonPatchException("invalid JSON patch", e);
}
} | java |
public static JsonPatch generate(final JsonNode source, final JsonNode target, ReplaceMode replaceMode) {
requireNonNull(source, "source");
requireNonNull(target, "target");
final DiffProcessor processor = new DiffProcessor(replaceMode, () -> unchangedValues(source, target));
generateDiffs(processor, EMPTY_JSON_POINTER, source, target);
return processor.getPatch();
} | java |
public JsonNode apply(final JsonNode node) {
requireNonNull(node, "node");
JsonNode ret = node.deepCopy();
for (final JsonPatchOperation operation : operations) {
ret = operation.apply(ret);
}
return ret;
} | java |
static Project convert(
String name, com.linecorp.centraldogma.server.storage.project.Project project) {
return new Project(name);
} | java |
@Override
public List<Revision> getMatrixHistory(final int start, final int limit) throws StoreException {
return delegate.getMatrixHistory(start, limit);
} | java |
private static File getUserDirectory(final String prefix, final String suffix, final File parent) {
final String dirname = formatDirName(prefix, suffix);
return new File(parent, dirname);
} | java |
private static String formatDirName(final String prefix, final String suffix) {
// Replace all invalid characters with '-'
final CharMatcher invalidCharacters = VALID_SUFFIX_CHARS.negate();
return String.format("%s-%s", prefix, invalidCharacters.trimAndCollapseFrom(suffix.toLowerCase(), '-'));
} | java |
private static void deleteUserDirectories(final File root,
final FileFilter filter) {
final File[] dirs = root.listFiles(filter);
LOGGER.info("Identified (" + dirs.length + ") directories to delete");
for (final File dir : dirs) {
LOGGER.info("Deleting " + dir);
if (!FileUtils.deleteQuietly(dir)) {
LOGGER.info("Failed to delete directory " + dir);
}
}
} | java |
@Nonnull
public static Proctor construct(@Nonnull final TestMatrixArtifact matrix, ProctorLoadResult loadResult, FunctionMapper functionMapper) {
final ExpressionFactory expressionFactory = RuleEvaluator.EXPRESSION_FACTORY;
final Map<String, TestChooser<?>> testChoosers = Maps.newLinkedHashMap();
final Map<String, String> versions = Maps.newLinkedHashMap();
for (final Entry<String, ConsumableTestDefinition> entry : matrix.getTests().entrySet()) {
final String testName = entry.getKey();
final ConsumableTestDefinition testDefinition = entry.getValue();
final TestType testType = testDefinition.getTestType();
final TestChooser<?> testChooser;
if (TestType.RANDOM.equals(testType)) {
testChooser = new RandomTestChooser(expressionFactory, functionMapper, testName, testDefinition);
} else {
testChooser = new StandardTestChooser(expressionFactory, functionMapper, testName, testDefinition);
}
testChoosers.put(testName, testChooser);
versions.put(testName, testDefinition.getVersion());
}
return new Proctor(matrix, loadResult, testChoosers);
} | java |
public static ProctorLoadResult verifyWithoutSpecification(@Nonnull final TestMatrixArtifact testMatrix,
final String matrixSource) {
final ProctorLoadResult.Builder resultBuilder = ProctorLoadResult.newBuilder();
for (final Entry<String, ConsumableTestDefinition> entry : testMatrix.getTests().entrySet()) {
final String testName = entry.getKey();
final ConsumableTestDefinition testDefinition = entry.getValue();
try {
verifyInternallyConsistentDefinition(testName, matrixSource, testDefinition);
} catch (IncompatibleTestMatrixException e) {
LOGGER.info(String.format("Unable to load test matrix for %s", testName), e);
resultBuilder.recordError(testName, e);
}
}
return resultBuilder.build();
} | java |
public static ProctorLoadResult verify(
@Nonnull final TestMatrixArtifact testMatrix,
final String matrixSource,
@Nonnull final Map<String, TestSpecification> requiredTests,
@Nonnull final FunctionMapper functionMapper,
final ProvidedContext providedContext,
@Nonnull final Set<String> dynamicTests
) {
final ProctorLoadResult.Builder resultBuilder = ProctorLoadResult.newBuilder();
final Map<String, Map<Integer, String>> allTestsKnownBuckets = Maps.newHashMapWithExpectedSize(requiredTests.size());
for (final Entry<String, TestSpecification> entry : requiredTests.entrySet()) {
final Map<Integer, String> bucketValueToName = Maps.newHashMap();
for (final Entry<String, Integer> bucket : entry.getValue().getBuckets().entrySet()) {
bucketValueToName.put(bucket.getValue(), bucket.getKey());
}
allTestsKnownBuckets.put(entry.getKey(), bucketValueToName);
}
final Map<String, ConsumableTestDefinition> definedTests = testMatrix.getTests();
final SetView<String> missingTests = Sets.difference(requiredTests.keySet(), definedTests.keySet());
resultBuilder.recordAllMissing(missingTests);
for (final Entry<String, ConsumableTestDefinition> entry : definedTests.entrySet()) {
final String testName = entry.getKey();
final Map<Integer, String> knownBuckets;
final TestSpecification specification;
final boolean isRequired;
if (allTestsKnownBuckets.containsKey(testName)) {
// required in specification
isRequired = true;
knownBuckets = allTestsKnownBuckets.remove(testName);
specification = requiredTests.get(testName);
} else if (dynamicTests.contains(testName)) {
// resolved by dynamic filter
isRequired = false;
knownBuckets = Collections.emptyMap();
specification = new TestSpecification();
} else {
// we don't care about this test
continue;
}
final ConsumableTestDefinition testDefinition = entry.getValue();
try {
verifyTest(testName, testDefinition, specification, knownBuckets, matrixSource, functionMapper, providedContext);
} catch (IncompatibleTestMatrixException e) {
if (isRequired) {
LOGGER.error(String.format("Unable to load test matrix for a required test %s", testName), e);
resultBuilder.recordError(testName, e);
} else {
LOGGER.info(String.format("Unable to load test matrix for a dynamic test %s", testName), e);
resultBuilder.recordIncompatibleDynamicTest(testName, e);
}
}
}
// TODO mjs - is this check additive?
resultBuilder.recordAllMissing(allTestsKnownBuckets.keySet());
resultBuilder.recordVerifiedRules(providedContext.shouldEvaluate());
final ProctorLoadResult loadResult = resultBuilder.build();
return loadResult;
} | java |
static boolean isEmptyWhitespace(@Nullable final String s) {
if (s == null) {
return true;
}
return CharMatcher.WHITESPACE.matchesAllOf(s);
} | java |
public static TestSpecification generateSpecification(@Nonnull final TestDefinition testDefinition) {
final TestSpecification testSpecification = new TestSpecification();
// Sort buckets by value ascending
final Map<String,Integer> buckets = Maps.newLinkedHashMap();
final List<TestBucket> testDefinitionBuckets = Ordering.from(new Comparator<TestBucket>() {
@Override
public int compare(final TestBucket lhs, final TestBucket rhs) {
return Ints.compare(lhs.getValue(), rhs.getValue());
}
}).immutableSortedCopy(testDefinition.getBuckets());
int fallbackValue = -1;
if(testDefinitionBuckets.size() > 0) {
final TestBucket firstBucket = testDefinitionBuckets.get(0);
fallbackValue = firstBucket.getValue(); // buckets are sorted, choose smallest value as the fallback value
final PayloadSpecification payloadSpecification = new PayloadSpecification();
if(firstBucket.getPayload() != null && !firstBucket.getPayload().equals(Payload.EMPTY_PAYLOAD)) {
final PayloadType payloadType = PayloadType.payloadTypeForName(firstBucket.getPayload().fetchType());
payloadSpecification.setType(payloadType.payloadTypeName);
if (payloadType == PayloadType.MAP) {
final Map<String, String> payloadSpecificationSchema = new HashMap<String, String>();
for (Map.Entry<String, Object> entry : firstBucket.getPayload().getMap().entrySet()) {
payloadSpecificationSchema.put(entry.getKey(), PayloadType.payloadTypeForValue(entry.getValue()).payloadTypeName);
}
payloadSpecification.setSchema(payloadSpecificationSchema);
}
testSpecification.setPayload(payloadSpecification);
}
for (int i = 0; i < testDefinitionBuckets.size(); i++) {
final TestBucket bucket = testDefinitionBuckets.get(i);
buckets.put(bucket.getName(), bucket.getValue());
}
}
testSpecification.setBuckets(buckets);
testSpecification.setDescription(testDefinition.getDescription());
testSpecification.setFallbackValue(fallbackValue);
return testSpecification;
} | java |
@Nonnull
protected Payload getPayload(final String testName) {
// Get the current bucket.
final TestBucket testBucket = buckets.get(testName);
// Lookup Payloads for this test
if (testBucket != null) {
final Payload payload = testBucket.getPayload();
if (null != payload) {
return payload;
}
}
return Payload.EMPTY_PAYLOAD;
} | java |
@Nonnull
public static Map<String, Integer> parseForcedGroups(@Nonnull final HttpServletRequest request) {
final String forceGroupsList = getForceGroupsStringFromRequest(request);
return parseForceGroupsList(forceGroupsList);
} | java |
private void precheckStateAllNull() throws IllegalStateException {
if ((doubleValue != null) || (doubleArray != null)
|| (longValue != null) || (longArray != null)
|| (stringValue != null) || (stringArray != null)
|| (map != null)) {
throw new IllegalStateException("Expected all properties to be empty: " + this);
}
} | java |
private Map<String, Integer> runSampling(
final ProctorContext proctorContext,
final Set<String> targetTestNames,
final TestType testType,
final int determinationsToRun
) {
final Set<String> targetTestGroups = getTargetTestGroups(targetTestNames);
final Map<String, Integer> testGroupToOccurrences = Maps.newTreeMap();
for (final String testGroup : targetTestGroups) {
testGroupToOccurrences.put(testGroup, 0);
}
for (int i = 0; i < determinationsToRun; ++i) {
final Identifiers identifiers = TestType.RANDOM.equals(testType)
? new Identifiers(Collections.<TestType, String>emptyMap(), /* randomEnabled */ true)
: Identifiers.of(testType, Long.toString(random.nextLong()));
final AbstractGroups groups = supplier.getRandomGroups(proctorContext, identifiers);
for (final Entry<String, TestBucket> e : groups.getProctorResult().getBuckets().entrySet()) {
final String testName = e.getKey();
if (targetTestNames.contains(testName)) {
final int group = e.getValue().getValue();
final String testGroup = testName + group;
testGroupToOccurrences.put(testGroup, testGroupToOccurrences.get(testGroup) + 1);
}
}
}
return testGroupToOccurrences;
} | java |
private Proctor getProctorNotNull() {
final Proctor proctor = proctorLoader.get();
if (proctor == null) {
throw new IllegalStateException("Proctor specification and/or text matrix has not been loaded");
}
return proctor;
} | java |
@SafeVarargs
public static void registerFilterTypes(final Class<? extends DynamicFilter>... types) {
FILTER_TYPES.addAll(Arrays.asList(types));
} | java |
private ProctorContext getProctorContext(final HttpServletRequest request) throws IllegalAccessException, InstantiationException {
final ProctorContext proctorContext = contextClass.newInstance();
final BeanWrapper beanWrapper = new BeanWrapperImpl(proctorContext);
for (final PropertyDescriptor descriptor : beanWrapper.getPropertyDescriptors()) {
final String propertyName = descriptor.getName();
if (!"class".equals(propertyName)) { // ignore class property which every object has
final String parameterValue = request.getParameter(propertyName);
if (parameterValue != null) {
beanWrapper.setPropertyValue(propertyName, parameterValue);
}
}
}
return proctorContext;
} | java |
public static String resolveSvnMigratedRevision(final Revision revision, final String branch) {
if (revision == null) {
return null;
}
final Pattern pattern = Pattern.compile("^git-svn-id: .*" + branch + "@([0-9]+) ", Pattern.MULTILINE);
final Matcher matcher = pattern.matcher(revision.getMessage());
if (matcher.find()) {
return matcher.group(1);
} else {
return revision.getRevision();
}
} | java |
public T mapRow(ResultSet rs) throws SQLException {
Map<String, Object> map = new HashMap<String, Object>();
ResultSetMetaData metadata = rs.getMetaData();
for (int i = 1; i <= metadata.getColumnCount(); ++i) {
String label = metadata.getColumnLabel(i);
final Object value;
// calling getObject on a BLOB/CLOB produces weird results
switch (metadata.getColumnType(i)) {
case Types.BLOB:
value = rs.getBytes(i);
break;
case Types.CLOB:
value = rs.getString(i);
break;
default:
value = rs.getObject(i);
}
// don't use table name extractor because we don't want aliased table name
boolean overwrite = this.tableName != null && this.tableName.equals(metadata.getTableName(i));
String tableName = TABLE_NAME_EXTRACTOR.getTableName(metadata, i);
if (tableName != null && !tableName.isEmpty()) {
String qualifiedName = tableName + "." + metadata.getColumnName(i);
add(map, qualifiedName, value, overwrite);
}
add(map, label, value, overwrite);
}
return objectMapper.convertValue(map, type);
} | java |
public int getOpacity() {
int opacity = Math
.round((mPosToOpacFactor * (mBarPointerPosition - mBarPointerHaloRadius)));
if (opacity < 5) {
return 0x00;
} else if (opacity > 250) {
return 0xFF;
} else {
return opacity;
}
} | java |
private int calculateColor(float angle) {
float unit = (float) (angle / (2 * Math.PI));
if (unit < 0) {
unit += 1;
}
if (unit <= 0) {
mColor = COLORS[0];
return COLORS[0];
}
if (unit >= 1) {
mColor = COLORS[COLORS.length - 1];
return COLORS[COLORS.length - 1];
}
float p = unit * (COLORS.length - 1);
int i = (int) p;
p -= i;
int c0 = COLORS[i];
int c1 = COLORS[i + 1];
int a = ave(Color.alpha(c0), Color.alpha(c1), p);
int r = ave(Color.red(c0), Color.red(c1), p);
int g = ave(Color.green(c0), Color.green(c1), p);
int b = ave(Color.blue(c0), Color.blue(c1), p);
mColor = Color.argb(a, r, g, b);
return Color.argb(a, r, g, b);
} | java |
private float colorToAngle(int color) {
float[] colors = new float[3];
Color.colorToHSV(color, colors);
return (float) Math.toRadians(-colors[0]);
} | java |
private float[] calculatePointerPosition(float angle) {
float x = (float) (mColorWheelRadius * Math.cos(angle));
float y = (float) (mColorWheelRadius * Math.sin(angle));
return new float[] { x, y };
} | java |
public void addOpacityBar(OpacityBar bar) {
mOpacityBar = bar;
// Give an instance of the color picker to the Opacity bar.
mOpacityBar.setColorPicker(this);
mOpacityBar.setColor(mColor);
} | java |
public void setNewCenterColor(int color) {
mCenterNewColor = color;
mCenterNewPaint.setColor(color);
if (mCenterOldColor == 0) {
mCenterOldColor = color;
mCenterOldPaint.setColor(color);
}
if (onColorChangedListener != null && color != oldChangedListenerColor ) {
onColorChangedListener.onColorChanged(color);
oldChangedListenerColor = color;
}
invalidate();
} | java |
public void setValue(float value) {
mBarPointerPosition = Math.round((mSVToPosFactor * (1 - value))
+ mBarPointerHaloRadius + (mBarLength / 2));
calculateColor(mBarPointerPosition);
mBarPointerPaint.setColor(mColor);
// Check whether the Saturation/Value bar is added to the ColorPicker
// wheel
if (mPicker != null) {
mPicker.setNewCenterColor(mColor);
mPicker.changeOpacityBarColor(mColor);
}
invalidate();
} | java |
public static int getNavigationBarHeight(Context context) {
Resources resources = context.getResources();
int id = resources.getIdentifier(context.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT ? "navigation_bar_height" : "navigation_bar_height_landscape", "dimen", "android");
if (id > 0) {
return resources.getDimensionPixelSize(id);
}
return 0;
} | java |
public static int getActionBarHeight(Context context) {
int actionBarHeight = UIUtils.getThemeAttributeDimensionSize(context, R.attr.actionBarSize);
if (actionBarHeight == 0) {
actionBarHeight = context.getResources().getDimensionPixelSize(R.dimen.abc_action_bar_default_height_material);
}
return actionBarHeight;
} | java |
public static int getStatusBarHeight(Context context, boolean force) {
int result = 0;
int resourceId = context.getResources().getIdentifier("status_bar_height", "dimen", "android");
if (resourceId > 0) {
result = context.getResources().getDimensionPixelSize(resourceId);
}
int dimenResult = context.getResources().getDimensionPixelSize(R.dimen.tool_bar_top_padding);
//if our dimension is 0 return 0 because on those devices we don't need the height
if (dimenResult == 0 && !force) {
return 0;
} else {
//if our dimens is > 0 && the result == 0 use the dimenResult else the result;
return result == 0 ? dimenResult : result;
}
} | java |
public static void setTranslucentStatusFlag(Activity activity, boolean on) {
if (Build.VERSION.SDK_INT >= 19) {
setFlag(activity, WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS, on);
}
} | java |
public static void setTranslucentNavigationFlag(Activity activity, boolean on) {
if (Build.VERSION.SDK_INT >= 19) {
setFlag(activity, WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION, on);
}
} | java |
public static void setFlag(Activity activity, final int bits, boolean on) {
Window win = activity.getWindow();
WindowManager.LayoutParams winParams = win.getAttributes();
if (on) {
winParams.flags |= bits;
} else {
winParams.flags &= ~bits;
}
win.setAttributes(winParams);
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.