_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q168500 | DefaultParsingHandler.addSegment | validation | private void addSegment(SegmentBase segment) {
containerStack.peekFirst().addSegment(segment);
LOGGER.trace("Add {}", segment);
} | java | {
"resource": ""
} |
q168501 | DefaultParsingHandler.validate | validation | private RootSegmentBase validate() {
ContainerSegmentBase root = containerStack.peekFirst();
if (!(root instanceof RootSegmentBase)) {
throw new MustacheException(
MustacheProblem.COMPILE_INVALID_TEMPLATE,
"Incorrect last container segment on the stack: %s",
containerStack.peekFirst().toString(), line);
}
return (RootSegmentBase) root;
} | java | {
"resource": ""
} |
q168502 | HelperExecutionHandler.splitHelperName | validation | static Iterator<String> splitHelperName(String name, Segment segment) {
boolean stringLiteral = false;
boolean arrayLiteral = false;
boolean space = false;
List<String> parts = new ArrayList<>();
StringBuilder buffer = new StringBuilder();
for (int i = 0; i < name.length(); i++) {
if (name.charAt(i) == ' ') {
if (!space) {
if (!stringLiteral && !arrayLiteral) {
if (buffer.length() > 0) {
parts.add(buffer.toString());
buffer = new StringBuilder();
}
space = true;
} else {
buffer.append(name.charAt(i));
}
}
} else {
if (!arrayLiteral
&& Strings.isStringLiteralSeparator(name.charAt(i))) {
stringLiteral = !stringLiteral;
} else if (!stringLiteral
&& Strings.isListLiteralStart(name.charAt(i))) {
arrayLiteral = true;
} else if (!stringLiteral
&& Strings.isListLiteralEnd(name.charAt(i))) {
arrayLiteral = false;
}
space = false;
buffer.append(name.charAt(i));
}
}
if (buffer.length() > 0) {
if (stringLiteral || arrayLiteral) {
throw new MustacheException(
MustacheProblem.COMPILE_HELPER_VALIDATION_FAILURE,
"Unterminated string or array literal detected: %s",
segment);
}
parts.add(buffer.toString());
}
return parts.iterator();
} | java | {
"resource": ""
} |
q168503 | DecoratorConverter.decorate | validation | public static <T> Builder<T> decorate(Class<T> delegateType) {
return decorate(o -> (delegateType.isAssignableFrom(Decorator.unwrap(o).getClass())));
} | java | {
"resource": ""
} |
q168504 | AsyncAppendable.flush | validation | private void flush() {
try {
parent.append(future.get(60, TimeUnit.SECONDS).collect(this));
parent.append(buffer);
if (parent instanceof AsyncAppendable) {
((AsyncAppendable) parent).flush();
}
} catch (Exception e) {
throw new MustacheException(
MustacheProblem.RENDER_ASYNC_PROCESSING_ERROR, e);
}
} | java | {
"resource": ""
} |
q168505 | ReflectionResolver.findField | validation | static Field findField(Class<?> clazz, String name) {
checkArgumentNotNull(clazz);
checkArgumentNotNull(name);
Field found = null;
for (Field field : SecurityActions.getFields(clazz)) {
if (field.getName().equals(name)) {
found = field;
}
}
LOGGER.debug("Field {} {}found on type: {}", name, found != null ? "" : "not ", clazz.getName());
return found;
} | java | {
"resource": ""
} |
q168506 | ConfigurationExtensions.registerHelpers | validation | public static void registerHelpers(ConfigurationExtensionBuilder builder, Map<String, Helper> helpers) {
Checker.checkArgumentsNotNull(builder, helpers);
for (Entry<String, Helper> entry : helpers.entrySet()) {
registerHelper(builder, entry.getKey(), entry.getValue());
}
} | java | {
"resource": ""
} |
q168507 | ConfigurationExtensions.registerHelper | validation | public static void registerHelper(ConfigurationExtensionBuilder builder, String name, Helper helper) {
Checker.checkArgumentsNotNull(builder, name, helper);
try {
builder.registerHelper(name, helper);
} catch (IllegalArgumentException ignored) {
}
} | java | {
"resource": ""
} |
q168508 | Segments.readSegmentLinesBeforeRendering | validation | static List<List<Segment>> readSegmentLinesBeforeRendering(
AbstractContainerSegment container) {
List<List<Segment>> lines = new ArrayList<>();
List<Segment> currentLine = new ArrayList<>();
for (Segment segment : container) {
if (!SegmentType.LINE_SEPARATOR.equals(segment.getType())) {
currentLine.add(segment);
} else {
// New line separator - flush the line
currentLine.add(segment);
lines.add(currentLine);
currentLine = new ArrayList<>();
}
}
// Add the last line manually - there is no line separator to trigger
// flush
if (!currentLine.isEmpty()) {
lines.add(currentLine);
}
return lines;
} | java | {
"resource": ""
} |
q168509 | CacheHelper.invalidateFragments | validation | public void invalidateFragments(final String keyPart) {
if (fragments == null || keyPart == null) {
return;
}
fragments.invalidate(fragmentKey -> fragmentKey.getKey().contains(keyPart));
} | java | {
"resource": ""
} |
q168510 | TimeFormatHelper.getFormattableObject | validation | protected TemporalAccessor getFormattableObject(Object value,
Locale locale, TimeZone timeZone, MustacheTagInfo tagInfo) {
if (value instanceof TemporalAccessor) {
return (TemporalAccessor) value;
} else if (value instanceof Date) {
return LocalDateTime.ofInstant(((Date) value).toInstant(),
timeZone.toZoneId());
} else if (value instanceof Calendar) {
return LocalDateTime.ofInstant(((Calendar) value).toInstant(),
timeZone.toZoneId());
} else if (value instanceof Number) {
return LocalDateTime.ofInstant(
Instant.ofEpochMilli(((Number) value).longValue()),
timeZone.toZoneId());
} else {
throw valueNotAFormattableObject(value, tagInfo);
}
} | java | {
"resource": ""
} |
q168511 | StorageExt.getLocalStorage | validation | public static StorageExt getLocalStorage() {
if (localStorage == null && Storage.isLocalStorageSupported()) {
localStorage = new StorageExt(Storage.getLocalStorageIfSupported());
}
return localStorage;
} | java | {
"resource": ""
} |
q168512 | StorageExt.getSessionStorage | validation | public static StorageExt getSessionStorage() {
if (sessionStorage == null && Storage.isSessionStorageSupported()) {
sessionStorage = new StorageExt(Storage.getSessionStorageIfSupported());
}
return sessionStorage;
} | java | {
"resource": ""
} |
q168513 | StorageExt.clear | validation | public void clear() {
storage.clear();
cache.clear();
fireEvent(StorageChangeEvent.ChangeType.CLEAR, null, null, null, null, null);
} | java | {
"resource": ""
} |
q168514 | StorageExt.containsKey | validation | public <T> boolean containsKey(StorageKey<T> key) {
return storage.getItem(key.name()) != null;
} | java | {
"resource": ""
} |
q168515 | StorageExt.put | validation | public <T> void put(StorageKey<T> key, T value) throws SerializationException, StorageQuotaExceededException {
if(value == null){
throw new NullPointerException();
}
try {
String data = StorageUtils.serialize(key.getClazz(), value);
// Update store and cache
String oldData = storage.getItem(key.name());
storage.setItem(key.name(), data);
T oldValue = cache.put(key, value);
fireEvent(StorageChangeEvent.ChangeType.PUT, key, value, oldValue, data, oldData);
} catch (JavaScriptException e) {
String msg = e.getMessage();
if (msg != null && msg.contains("QUOTA") && msg.contains("DOM")) {
throw new StorageQuotaExceededException(key, e);
}
throw e;
}
} | java | {
"resource": ""
} |
q168516 | StorageExt.remove | validation | public <T extends Serializable> void remove(StorageKey<T> key) {
String data = storage.getItem(key.name());
storage.removeItem(key.name());
T value = cache.remove(key);
fireEvent(StorageChangeEvent.ChangeType.REMOVE, key, null, value, null, data);
} | java | {
"resource": ""
} |
q168517 | StorageKeyFactory.objectKey | validation | @Deprecated
public static <T> StorageKey<T> objectKey(String keyName){
return new StorageKey<>(keyName, Object.class);
} | java | {
"resource": ""
} |
q168518 | StorageKeyFactory.isSerializableKey | validation | public static <T extends IsSerializable> StorageKey<T> isSerializableKey(String keyName){
return new StorageKey<>(keyName, IsSerializable.class);
} | java | {
"resource": ""
} |
q168519 | StorageKeyFactory.serializableKey | validation | public static <T extends Serializable> StorageKey<T> serializableKey(String keyName){
return new StorageKey<>(keyName, Serializable.class);
} | java | {
"resource": ""
} |
q168520 | FloatingActionButton.obtainSize | validation | private void obtainSize(@NonNull final TypedArray typedArray) {
Size defaultSize = Size.NORMAL;
size = Size.fromValue(
typedArray.getInt(R.styleable.FloatingActionButton_size, defaultSize.getValue()));
} | java | {
"resource": ""
} |
q168521 | FloatingActionButton.obtainColor | validation | private void obtainColor(@NonNull final TypedArray typedArray) {
int defaultColor = ThemeUtil.getColor(getContext(), R.attr.colorAccent);
color = typedArray.getColor(R.styleable.FloatingActionButton_android_color, defaultColor);
} | java | {
"resource": ""
} |
q168522 | FloatingActionButton.obtainActivatedColor | validation | private void obtainActivatedColor(@NonNull final TypedArray typedArray) {
int defaultActivatedColor = getControlActivatedColor();
activatedColor = typedArray
.getColor(R.styleable.FloatingActionButton_activatedColor, defaultActivatedColor);
} | java | {
"resource": ""
} |
q168523 | FloatingActionButton.obtainPressedColor | validation | private void obtainPressedColor(@NonNull final TypedArray typedArray) {
int defaultPressedColor = getControlHighlightColor();
pressedColor = typedArray
.getColor(R.styleable.FloatingActionButton_pressedColor, defaultPressedColor);
} | java | {
"resource": ""
} |
q168524 | FloatingActionButton.obtainDisabledColor | validation | private void obtainDisabledColor(@NonNull final TypedArray typedArray) {
int defaultDisabledColor =
ContextCompat.getColor(getContext(), R.color.floating_action_button_disabled_color);
disabledColor = typedArray
.getColor(R.styleable.FloatingActionButton_disabledColor, defaultDisabledColor);
} | java | {
"resource": ""
} |
q168525 | FloatingActionButton.obtainIcon | validation | private void obtainIcon(@NonNull final TypedArray typedArray) {
Drawable icon = typedArray.getDrawable(R.styleable.FloatingActionButton_android_icon);
setIcon(icon);
} | java | {
"resource": ""
} |
q168526 | FloatingActionButton.obtainVisibilityAnimationDuration | validation | private void obtainVisibilityAnimationDuration(@NonNull final TypedArray typedArray) {
int defaultAnimationDuration = getResources()
.getInteger(R.integer.floating_action_button_visibility_animation_duration);
int duration = typedArray
.getInteger(R.styleable.FloatingActionButton_visibilityAnimationDuration,
defaultAnimationDuration);
setVisibilityAnimationDuration(duration);
} | java | {
"resource": ""
} |
q168527 | FloatingActionButton.adaptShadow | validation | private void adaptShadow() {
if (getSize() == Size.NORMAL) {
setBackgroundResource(R.drawable.floating_action_button_shadow_normal);
} else if (getSize() == Size.SMALL) {
setBackgroundResource(R.drawable.floating_action_button_shadow_small);
} else {
setBackgroundResource(R.drawable.floating_action_button_shadow_large);
}
} | java | {
"resource": ""
} |
q168528 | FloatingActionButton.adaptImageButtonSize | validation | private void adaptImageButtonSize() {
int pixelSize = getPixelSize();
LayoutParams layoutParams = (LayoutParams) imageButton.getLayoutParams();
layoutParams.width = pixelSize;
layoutParams.height = pixelSize;
imageButton.setLayoutParams(layoutParams);
imageButton.requestLayout();
} | java | {
"resource": ""
} |
q168529 | FloatingActionButton.adaptImageButtonBackground | validation | @SuppressLint("NewApi")
private void adaptImageButtonBackground() {
Drawable background = createStateListBackgroundDrawable();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
Drawable rippleDrawable = new RippleDrawable(
new ColorStateList(new int[][]{{}}, new int[]{getPressedColor()}), background,
null);
ViewUtil.setBackground(imageButton, rippleDrawable);
} else {
ViewUtil.setBackground(imageButton, background);
}
} | java | {
"resource": ""
} |
q168530 | FloatingActionButton.createStateListBackgroundDrawable | validation | private Drawable createStateListBackgroundDrawable() {
StateListDrawable drawable = new StateListDrawable();
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
drawable.addState(new int[]{android.R.attr.state_enabled, android.R.attr.state_pressed},
createPressedBackgroundDrawable());
}
drawable.addState(new int[]{android.R.attr.state_enabled, android.R.attr.state_activated},
createActivatedBackgroundDrawable());
drawable.addState(new int[]{android.R.attr.state_enabled},
createBackgroundDrawable(getColor()));
drawable.addState(new int[]{}, createDisabledBackgroundDrawable());
return drawable;
} | java | {
"resource": ""
} |
q168531 | FloatingActionButton.createActivatedBackgroundDrawable | validation | private Drawable createActivatedBackgroundDrawable() {
Drawable drawable = createBackgroundDrawable(getColor());
Drawable hoverDrawable = createBackgroundDrawable(getActivatedColor());
return new LayerDrawable(new Drawable[]{drawable, hoverDrawable});
} | java | {
"resource": ""
} |
q168532 | FloatingActionButton.createPressedBackgroundDrawable | validation | private Drawable createPressedBackgroundDrawable() {
Drawable drawable = createBackgroundDrawable(getColor());
Drawable hoverDrawable = createBackgroundDrawable(getPressedColor());
return new LayerDrawable(new Drawable[]{drawable, hoverDrawable});
} | java | {
"resource": ""
} |
q168533 | FloatingActionButton.createDisabledBackgroundDrawable | validation | private Drawable createDisabledBackgroundDrawable() {
Drawable drawable = createBackgroundDrawable(getColor());
Drawable hoverDrawable = createBackgroundDrawable(getDisabledColor());
return new LayerDrawable(new Drawable[]{drawable, hoverDrawable});
} | java | {
"resource": ""
} |
q168534 | FloatingActionButton.createBackgroundDrawable | validation | private Drawable createBackgroundDrawable(@ColorInt final int color) {
OvalShape shape = new OvalShape();
ShapeDrawable drawable = new ShapeDrawable(shape);
drawable.getPaint().setColor(color);
return drawable;
} | java | {
"resource": ""
} |
q168535 | FloatingActionButton.getPixelSize | validation | private int getPixelSize() {
if (getSize() == Size.NORMAL) {
return getResources().getDimensionPixelSize(R.dimen.floating_action_button_size_normal);
} else if (getSize() == Size.SMALL) {
return getResources().getDimensionPixelSize(R.dimen.floating_action_button_size_small);
} else {
return getResources().getDimensionPixelSize(R.dimen.floating_action_button_size_large);
}
} | java | {
"resource": ""
} |
q168536 | FloatingActionButton.animateVisibility | validation | private void animateVisibility(final int visibility, final long duration) {
if (visibilityAnimator != null) {
visibilityAnimator.cancel();
}
AnimatorListener listener = createVisibilityAnimatorListener(visibility);
float targetScale = visibility == View.VISIBLE ? 1 : 0;
long animationDuration = Math.round(Math.abs(getScaleX() - targetScale) * duration);
Interpolator interpolator = new AccelerateDecelerateInterpolator();
visibilityAnimator =
animate().setInterpolator(interpolator).scaleX(targetScale).scaleY(targetScale)
.setDuration(animationDuration).setListener(listener);
} | java | {
"resource": ""
} |
q168537 | FloatingActionButton.createVisibilityAnimatorListener | validation | private AnimatorListener createVisibilityAnimatorListener(final int visibility) {
return new AnimatorListener() {
@Override
public void onAnimationStart(final Animator animation) {
if (visibility == View.VISIBLE) {
FloatingActionButton.super.setVisibility(visibility);
}
}
@Override
public void onAnimationRepeat(final Animator animation) {
}
@Override
public void onAnimationEnd(final Animator animation) {
FloatingActionButton.super.setVisibility(visibility);
visibilityAnimator = null;
}
@Override
public void onAnimationCancel(final Animator animation) {
visibilityAnimator = null;
}
};
} | java | {
"resource": ""
} |
q168538 | FloatingActionButton.setSize | validation | public final void setSize(@NonNull final Size size) {
Condition.INSTANCE.ensureNotNull(size, "The size may not be null");
this.size = size;
adaptShadow();
adaptImageButtonSize();
requestLayout();
} | java | {
"resource": ""
} |
q168539 | CircularProgressBar.obtainThickness | validation | private void obtainThickness(@NonNull final TypedArray typedArray) {
int defaultThickness = getContext().getResources()
.getDimensionPixelSize(R.dimen.circular_progress_bar_thickness_normal);
thickness = typedArray
.getDimensionPixelSize(R.styleable.CircularProgressBar_android_thickness,
defaultThickness);
} | java | {
"resource": ""
} |
q168540 | CircularProgressDrawable.initializePaint | validation | private void initializePaint() {
paint = new Paint();
paint.setAntiAlias(true);
paint.setStyle(Paint.Style.STROKE);
paint.setStrokeWidth(getThickness());
paint.setColor(getColor());
} | java | {
"resource": ""
} |
q168541 | CircularProgressDrawable.initializeAngleAnimator | validation | private void initializeAngleAnimator() {
angleAnimator = ObjectAnimator.ofFloat(this, createAngleProperty(), MAX_DEGREES);
angleAnimator.setInterpolator(new LinearInterpolator());
angleAnimator.setDuration(ANGLE_ANIMATION_DURATION);
angleAnimator.setRepeatMode(ValueAnimator.RESTART);
angleAnimator.setRepeatCount(ValueAnimator.INFINITE);
} | java | {
"resource": ""
} |
q168542 | CircularProgressDrawable.createAngleProperty | validation | private Property<CircularProgressDrawable, Float> createAngleProperty() {
return new Property<CircularProgressDrawable, Float>(Float.class, "angle") {
@Override
public Float get(final CircularProgressDrawable object) {
return currentGlobalAngle;
}
@Override
public void set(final CircularProgressDrawable object, final Float value) {
currentGlobalAngle = value;
invalidateSelf();
}
};
} | java | {
"resource": ""
} |
q168543 | CircularProgressDrawable.initializeSweepAnimator | validation | private void initializeSweepAnimator() {
sweepAnimator = ObjectAnimator
.ofFloat(this, createSweepProperty(), MAX_DEGREES - MIN_SWEEP_ANGLE * 2);
sweepAnimator.setInterpolator(new DecelerateInterpolator());
sweepAnimator.setDuration(SWEEP_ANIMATION_DURATION);
sweepAnimator.setRepeatMode(ValueAnimator.RESTART);
sweepAnimator.setRepeatCount(ValueAnimator.INFINITE);
sweepAnimator.addListener(createSweepAnimatorListener());
} | java | {
"resource": ""
} |
q168544 | CircularProgressDrawable.createSweepProperty | validation | private Property<CircularProgressDrawable, Float> createSweepProperty() {
return new Property<CircularProgressDrawable, Float>(Float.class, "arc") {
@Override
public Float get(final CircularProgressDrawable object) {
return currentSweepAngle;
}
@Override
public void set(final CircularProgressDrawable object, final Float value) {
currentSweepAngle = value;
invalidateSelf();
}
};
} | java | {
"resource": ""
} |
q168545 | CircularProgressDrawable.createSweepAnimatorListener | validation | private AnimatorListener createSweepAnimatorListener() {
return new AnimatorListener() {
@Override
public void onAnimationStart(final Animator animation) {
}
@Override
public void onAnimationEnd(final Animator animation) {
}
@Override
public void onAnimationCancel(final Animator animation) {
}
@Override
public void onAnimationRepeat(final Animator animation) {
appearing = !appearing;
if (appearing) {
currentGlobalAngleOffset =
(currentGlobalAngleOffset + MIN_SWEEP_ANGLE * 2) % MAX_DEGREES;
}
}
};
} | java | {
"resource": ""
} |
q168546 | MainActivity.initializeFloatingActionButtons | validation | private void initializeFloatingActionButtons() {
smallFloatingActionButton = findViewById(R.id.floating_action_button_small);
smallFloatingActionButton.setOnClickListener(createFloatingActionButtonListener());
normalFloatingActionButton = findViewById(R.id.floating_action_button_normal);
normalFloatingActionButton.setOnClickListener(createFloatingActionButtonListener());
largeFloatingActionButton = findViewById(R.id.floating_action_button_large);
largeFloatingActionButton.setOnClickListener(createFloatingActionButtonListener());
} | java | {
"resource": ""
} |
q168547 | MainActivity.createFloatingActionButtonListener | validation | private OnClickListener createFloatingActionButtonListener() {
return new OnClickListener() {
@Override
public void onClick(final View v) {
Toast toast =
Toast.makeText(MainActivity.this, R.string.floating_action_button_toast,
Toast.LENGTH_SHORT);
toast.show();
}
};
} | java | {
"resource": ""
} |
q168548 | MainActivity.initializeHideFloatingActionButtonsButton | validation | private void initializeHideFloatingActionButtonsButton() {
Button button = findViewById(R.id.hide_floating_action_buttons);
button.setOnClickListener(createHideFloatingActionButtonsListener());
} | java | {
"resource": ""
} |
q168549 | MainActivity.createHideFloatingActionButtonsListener | validation | private OnClickListener createHideFloatingActionButtonsListener() {
return new OnClickListener() {
@Override
public void onClick(final View v) {
int visibility = floatingActionButtonsVisible ? View.INVISIBLE : View.VISIBLE;
smallFloatingActionButton.setVisibility(visibility, true);
normalFloatingActionButton.setVisibility(visibility, true);
largeFloatingActionButton.setVisibility(visibility, true);
floatingActionButtonsVisible = !floatingActionButtonsVisible;
}
};
} | java | {
"resource": ""
} |
q168550 | MainActivity.initializeChips | validation | private void initializeChips() {
Chip closableChipLight = findViewById(R.id.chip_closable_light);
closableChipLight.addCloseListener(createChipCloseListener());
Chip closableChipDark = findViewById(R.id.chip_closable_dark);
closableChipDark.addCloseListener(createChipCloseListener());
Chip closableIconChipLight = findViewById(R.id.chip_icon_closable_light);
closableIconChipLight.addCloseListener(createChipCloseListener());
Chip closableIconChipDark = findViewById(R.id.chip_icon_closable_dark);
closableIconChipDark.addCloseListener(createChipCloseListener());
} | java | {
"resource": ""
} |
q168551 | MainActivity.createChipCloseListener | validation | private Chip.CloseListener createChipCloseListener() {
return new Chip.CloseListener() {
@Override
public void onChipClosed(@NonNull final Chip chip) {
chip.setVisibility(View.GONE);
Toast.makeText(MainActivity.this, R.string.chip_closed_toast, Toast.LENGTH_SHORT)
.show();
}
};
} | java | {
"resource": ""
} |
q168552 | MainActivity.handleSavedInstanceState | validation | private void handleSavedInstanceState(@Nullable final Bundle savedInstanceState) {
if (savedInstanceState != null) {
floatingActionButtonsVisible =
savedInstanceState.getBoolean(FLOATING_ACTION_BUTTONS_VISIBLE_EXTRA);
int visibility = floatingActionButtonsVisible ? View.VISIBLE : View.INVISIBLE;
smallFloatingActionButton.setVisibility(visibility);
normalFloatingActionButton.setVisibility(visibility);
largeFloatingActionButton.setVisibility(visibility);
}
} | java | {
"resource": ""
} |
q168553 | Chip.obtainText | validation | private void obtainText(@NonNull final TypedArray typedArray) {
setText(typedArray.getText(R.styleable.Chip_android_text));
} | java | {
"resource": ""
} |
q168554 | Chip.obtainTextColor | validation | private void obtainTextColor(@NonNull final TypedArray typedArray) {
int defaultColor = ContextCompat.getColor(getContext(), R.color.chip_text_color_light);
setTextColor(typedArray.getColor(R.styleable.Chip_android_textColor, defaultColor));
} | java | {
"resource": ""
} |
q168555 | Chip.obtainColor | validation | private void obtainColor(@NonNull final TypedArray typedArray) {
int defaultColor = ContextCompat.getColor(getContext(), R.color.chip_color_light);
setColor(typedArray.getColor(R.styleable.Chip_android_color, defaultColor));
} | java | {
"resource": ""
} |
q168556 | Chip.obtainIcon | validation | private void obtainIcon(@NonNull final TypedArray typedArray) {
setIcon(typedArray.getDrawable(R.styleable.Chip_android_icon));
} | java | {
"resource": ""
} |
q168557 | Chip.obtainClosable | validation | private void obtainClosable(@NonNull final TypedArray typedArray) {
setClosable(typedArray.getBoolean(R.styleable.Chip_closable, false));
} | java | {
"resource": ""
} |
q168558 | Chip.obtainCloseIcon | validation | private void obtainCloseIcon(@NonNull final TypedArray typedArray) {
Drawable icon = typedArray.getDrawable(R.styleable.Chip_closeButtonIcon);
if (icon != null) {
setCloseButtonIcon(icon);
}
} | java | {
"resource": ""
} |
q168559 | Chip.addCloseListener | validation | public final void addCloseListener(@NonNull final CloseListener listener) {
Condition.INSTANCE.ensureNotNull(listener, "The listener may not be null");
listeners.add(listener);
} | java | {
"resource": ""
} |
q168560 | Chip.removeCloseListener | validation | public final void removeCloseListener(@NonNull final CloseListener listener) {
Condition.INSTANCE.ensureNotNull(listener, "The listener may not be null");
listeners.remove(listener);
} | java | {
"resource": ""
} |
q168561 | Chip.setColor | validation | public final void setColor(@ColorInt final int color) {
this.color = color;
getBackground().setColorFilter(color, PorterDuff.Mode.SRC_IN);
} | java | {
"resource": ""
} |
q168562 | Chip.setClosable | validation | public final void setClosable(final boolean closable) {
this.closable = closable;
if (closable) {
closeButton.setVisibility(View.VISIBLE);
textView.setPadding(textView.getPaddingLeft(), textView.getPaddingTop(), 0,
textView.getPaddingBottom());
} else {
closeButton.setVisibility(View.GONE);
textView.setPadding(textView.getPaddingLeft(), textView.getPaddingTop(),
getResources().getDimensionPixelSize(R.dimen.chip_horizontal_padding),
textView.getPaddingBottom());
}
} | java | {
"resource": ""
} |
q168563 | ModelAndMustacheView.getPartials | validation | @SuppressWarnings("unchecked")
public Map<String, String> getPartials() {
final View view = this.getView();
if (view != null && view instanceof MustacheView) {
MustacheView mustacheView = (MustacheView) view;
return mustacheView.getAliases();
} else {
final Object object = getModelMap().get(MustacheSettings.PARTIALS_KEY);
if (object != null && !(object instanceof Map)) {
throw new MustachePartialsMappingException();
}
final Map<String, String> map;
if (object == null) {
map = new HashMap<String, String>();
} else {
map = (Map<String, String>) object;
}
return map;
}
} | java | {
"resource": ""
} |
q168564 | NashornUtils.getEngine | validation | public static ScriptEngine getEngine(Collection<InputStream> scripts) {
ScriptEngine engine = getEngine();
for (InputStream script : scripts) {
evaluate(engine, script);
}
return engine;
} | java | {
"resource": ""
} |
q168565 | MustacheWebConfiguration.getLayoutMappings | validation | public Map<String, String> getLayoutMappings() {
String mappingsValues = environment.getProperty("mustache.layoutMappings", MustacheSettings.LAYOUT_MAPPINGS).trim();
if (mappingsValues.isEmpty()) {
return emptyMap();
}
Map<String, String> mappings = new HashMap<String, String>();
String[] values = mappingsValues.split(";");
if (values.length > 0) {
for (String value : values) {
String val = value == null ? "" : value.trim();
if (val.isEmpty()) {
continue;
}
String[] mapping = val.split(":");
if (mapping.length != 2) {
throw new IllegalArgumentException("Mapping must use [viewName]:[layout] format!");
}
mappings.put(mapping[0].trim(), mapping[1].trim());
}
}
return unmodifiableMap(mappings);
} | java | {
"resource": ""
} |
q168566 | ClassUtils.isPresent | validation | public static boolean isPresent(String klass) {
hasText(klass, "Class name must not be empty");
try {
Class.forName(klass);
return true;
}
catch (Exception ex) {
return false;
}
} | java | {
"resource": ""
} |
q168567 | ClassUtils.getAnnotationValue | validation | @SuppressWarnings("unchecked")
public static <T> T getAnnotationValue(AnnotationMetadata importingClassMetadata, Class annotationClass, String name, T defaultValue) {
Map<String, Object> attributes = importingClassMetadata.getAnnotationAttributes(annotationClass.getName());
return attributes != null && attributes.containsKey(name) ? (T) attributes.get(name) : defaultValue;
} | java | {
"resource": ""
} |
q168568 | IOUtils.getStream | validation | public static InputStream getStream(String name) {
ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(IOUtils.class.getClassLoader());
InputStream stream = getInputStreamWithResolver(resolver, name);
// Not Found
if (stream == null) {
throw new MustacheIOException("Unable to locate {}" + name);
}
return stream;
} | java | {
"resource": ""
} |
q168569 | IOUtils.getFirstAvailableStream | validation | public static InputStream getFirstAvailableStream(Collection<String> names) {
ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(IOUtils.class.getClassLoader());
for (String name : names) {
try {
InputStream stream = getInputStreamWithResolver(resolver, name);
if (stream != null) {
return stream;
}
}
catch (MustacheIOException ex) {
// Go to the next test
}
}
throw new MustacheIOException("Unable to locate one of: " + names);
} | java | {
"resource": ""
} |
q168570 | MustacheEngine.render | validation | public String render(String template, Map<String, Object> model) {
try {
Invocable invocable = (Invocable) engine;
return (String) invocable.invokeFunction("render", template, model, partials);
}
catch (ScriptException ex) {
throw new NashornException(ex);
}
catch (NoSuchMethodException ex) {
throw new NashornException(ex);
}
} | java | {
"resource": ""
} |
q168571 | MustacheView.addAliases | validation | public void addAliases(Map<String, String> aliases) {
notNull(aliases, "Aliases must not be null");
for (Map.Entry<String, String> entry : aliases.entrySet()) {
addAlias(entry.getKey(), entry.getValue());
}
} | java | {
"resource": ""
} |
q168572 | MustacheView.addAlias | validation | public void addAlias(String key, String value) {
this.aliases.put(
notNull(key, "Key must not be null"),
notNull(value, "Value must not be null")
);
} | java | {
"resource": ""
} |
q168573 | ChronosListenerManager.getListener | validation | @NonNull
public final synchronized ChronosListener getListener(final int id) {
ChronosListener chronosListener = mListeners.get(id);
if (chronosListener == null) {
chronosListener = new ChronosListener(id);
mListeners.put(id, chronosListener);
}
return chronosListener;
} | java | {
"resource": ""
} |
q168574 | Chronos.run | validation | @NonNull
public static <Output> ChronosOperationResult<Output> run(
@NonNull final ChronosOperation<Output> operation) {
return ChronosService.getInstance().runSync(operation, false);
} | java | {
"resource": ""
} |
q168575 | ChronosListener.isCallback | validation | @Contract(pure = true)
private static boolean isCallback(@NonNull final Method method,
@NonNull final Class<?> resultClass,
@NonNull final String methodName) {
if (method.getName().equals(methodName)) {
if (method.getReturnType() == Void.TYPE) {
final Class<?>[] parameters = method.getParameterTypes();
if (parameters.length == 1 && parameters[0].isAssignableFrom(resultClass)) {
return true;
}
}
}
return false;
} | java | {
"resource": ""
} |
q168576 | ChronosListener.onResume | validation | public final void onResume(@NonNull final Object serviceListener) {
logd("onResume");
mServiceListener = serviceListener;
mState = State.RESUMED;
if (!mStoredResults.isEmpty()) {
logd("has undelivered results");
final List<SoftReference<OperationDelivery<?>>> oldResults = new ArrayList<>(
mStoredResults);
mStoredResults.clear();
for (SoftReference<OperationDelivery<?>> result : oldResults) {
final OperationDelivery<?> delivery = result.get();
if (delivery != null) {
deliverResult(delivery);
}
}
logd("no more undelivered results");
} else {
logd("has no undelivered results");
}
} | java | {
"resource": ""
} |
q168577 | ChronosListener.onEventMainThread | validation | @SuppressWarnings("unused")
public final void onEventMainThread(@Nullable final ChronosOperationResult<?> operationResult) {
if (operationResult == null) {
//somehow the bus delivered us a null object, it should be ignored
return;
}
final int operationId = operationResult.getId();
DeliveryMode deliveryMode = null;
if (!RunningOperationStorage.getInstance().isOperationCancelled(operationId)) {
if (mTaggedRequests.containsValue(operationId)) {
deliveryMode = DeliveryMode.NORMAL;
} else if (mUntaggedRequests.contains(operationResult.getId())) {
mUntaggedRequests.remove(Integer.valueOf(operationId));
deliveryMode = DeliveryMode.NORMAL;
} else if (operationResult.isBroadcast()) {
deliveryMode = DeliveryMode.BROADCAST;
}
}
if (deliveryMode != null) {
final OperationDelivery<?> operationDelivery = new OperationDelivery<>(operationResult,
deliveryMode);
logd("operation delivery: " + operationDelivery);
onOperationFinished(operationDelivery);
}
} | java | {
"resource": ""
} |
q168578 | ChronosListener.invoke | validation | public final int invoke(@NonNull final ChronosOperation<?> operation,
final boolean broadcastResult) {
logd("invoking untagged operation");
final int id = ChronosService.getInstance().runAsync(operation, broadcastResult);
mUntaggedRequests.add(id);
return id;
} | java | {
"resource": ""
} |
q168579 | ChronosListener.invoke | validation | public final int invoke(@NonNull final ChronosOperation<?> operation, @NonNull final String tag,
final boolean broadcastResult) {
logd("invoking tagged operation, tag=" + tag);
final Integer savedId = mTaggedRequests.get(tag);
if (savedId != null && isRunning(savedId)) {
logd("operation with tag=" + tag + " is running, do nothing");
return savedId;
}
logd("operation with tag=" + tag + " is not running, start it");
final int id = ChronosService.getInstance().runAsync(operation, broadcastResult);
mTaggedRequests.put(tag, id);
return id;
} | java | {
"resource": ""
} |
q168580 | ChronosListener.cancel | validation | public final boolean cancel(final int id, final boolean mayInterrupt) {
//noinspection SimplifiableIfStatement
if (mUntaggedRequests.contains(id) || mTaggedRequests.containsValue(id)) {
return RunningOperationStorage.getInstance().cancel(id, mayInterrupt);
} else {
return false;
}
} | java | {
"resource": ""
} |
q168581 | ChronosListener.cancel | validation | public final boolean cancel(@NonNull final String tag, final boolean mayInterrupt) {
final Integer id = mTaggedRequests.get(tag);
//noinspection SimplifiableIfStatement
if (id != null) {
return cancel(id, mayInterrupt);
} else {
return false;
}
} | java | {
"resource": ""
} |
q168582 | ChronosListener.isRunning | validation | @Contract(pure = true)
public final boolean isRunning(@NonNull final String tag) {
final Integer id = mTaggedRequests.get(tag);
//noinspection SimplifiableIfStatement
if (id != null) {
return isRunning(id);
} else {
return false;
}
} | java | {
"resource": ""
} |
q168583 | ChronosListener.onOperationFinished | validation | private void onOperationFinished(@NonNull final OperationDelivery<?> operationResult) {
logd("onOperationFinished " + operationResult);
switch (mState) {
case PAUSED:
storeResult(operationResult);
break;
case RESUMED:
deliverResult(operationResult);
break;
default:
throw new IllegalStateException("Unknown state: " + mState);
}
} | java | {
"resource": ""
} |
q168584 | ChronosListener.storeResult | validation | private void storeResult(@NonNull final OperationDelivery<?> operationDelivery) {
logd("store delivery " + operationDelivery);
mStoredResults.add(new SoftReference<OperationDelivery<?>>(operationDelivery));
} | java | {
"resource": ""
} |
q168585 | ChronosListener.deliverResult | validation | private void deliverResult(@NonNull final OperationDelivery<?> operationDelivery) {
logd("deliver delivery " + operationDelivery);
switch (operationDelivery.getDeliveryMode()) {
case NORMAL:
deliverResult(operationDelivery.getResult(), Chronos.OWN_CALLBACK_METHOD_NAME,
true);
break;
case BROADCAST:
deliverResult(operationDelivery.getResult(), Chronos.BROADCAST_CALLBACK_METHOD_NAME,
false);
break;
default:
break;
}
} | java | {
"resource": ""
} |
q168586 | ChronosListener.deliverResult | validation | @SuppressWarnings("TryWithIdenticalCatches")
private void deliverResult(@NonNull final ChronosOperationResult<?> operationResult,
@NonNull final String methodName, final boolean warnIfNoCallback) {
final Class listenerClass = mServiceListener.getClass();
final Method[] listenerMethods = listenerClass.getMethods();
Method callbackMethod = null;
final Class resultClass = operationResult.getClass();
for (Method method : listenerMethods) {
if (isCallback(method, resultClass, methodName)) {
callbackMethod = method;
try {
callbackMethod.invoke(mServiceListener, operationResult);
} catch (IllegalAccessException e) {
Log.w(LOG_TAG, Log.getStackTraceString(e));
} catch (InvocationTargetException e) {
Log.w(LOG_TAG, Log.getStackTraceString(e));
}
}
}
if (warnIfNoCallback && callbackMethod == null) {
Log.w(LOG_TAG,
"Operation result (id=" + operationResult.getId() + "; class=" + operationResult
.getClass().getName() + ") was obtained, but there is no method in "
+ mServiceListener + " to get it"
);
Log.w(LOG_TAG, "Method should look like");
Log.w(LOG_TAG,
"public void " + methodName + "(" + resultClass.getName()
+ " result) {}"
);
}
} | java | {
"resource": ""
} |
q168587 | ChronosListener.logd | validation | private void logd(@NonNull final String message) {
if (LOG_ENABLED) {
Log.d(LOG_TAG, this.toString() + " " + message);
}
} | java | {
"resource": ""
} |
q168588 | RunningOperationStorage.cancel | validation | private synchronized boolean cancel(final int id, final boolean mayInterrupt,
final boolean removeOperation) {
final RunningOperation runningOperation = mRunningOperations.get(id);
if (runningOperation != null) {
if (removeOperation) {
mRunningOperations.remove(id);
}
mCancelledOperations.add(id);
return runningOperation.cancel(mayInterrupt);
} else {
return false;
}
} | java | {
"resource": ""
} |
q168589 | RunningOperationStorage.operationStarted | validation | synchronized final void operationStarted(final int id, @NonNull final ChronosOperation<?> operation,
@NonNull final Future<?> future
) {
mRunningOperations.put(id, new RunningOperation(operation, future));
} | java | {
"resource": ""
} |
q168590 | RunningOperationStorage.cancelAll | validation | synchronized final void cancelAll(final boolean mayInterrupt) {
for (final Integer key : mRunningOperations.keySet()) {
cancel(key, mayInterrupt, false);
}
mRunningOperations.clear();
} | java | {
"resource": ""
} |
q168591 | RunningOperationStorage.isOperationCancelled | validation | @Contract(pure = true)
synchronized final boolean isOperationCancelled(final int id) {
return mCancelledOperations.contains(Integer.valueOf(id));
} | java | {
"resource": ""
} |
q168592 | ChronosService.silentRun | validation | private static <Output> void silentRun(@NonNull final ChronosOperation<Output> operation,
@NonNull final ChronosOperationResult<Output> operationResult) {
try {
final Output output = operation.run();
operationResult.setOutput(output);
} catch (Exception e) {
operationResult.setException(e);
}
} | java | {
"resource": ""
} |
q168593 | ChronosService.createEmptyResult | validation | @NonNull
@Contract(pure = true)
private <Output> ChronosOperationResult<Output> createEmptyResult(
@NonNull final ChronosOperation<Output> operation, final boolean broadcastResult) {
final ChronosOperationResult<Output> operationResult;
final Class<? extends ChronosOperationResult<Output>> resultClass = operation
.getResultClass();
try {
operationResult = resultClass.newInstance();
} catch (InstantiationException e) {
throw new RuntimeException("Can't create a new instance of " + resultClass.getName());
} catch (IllegalAccessException e) {
throw new RuntimeException(resultClass.getName() + " constructor is not accessible");
}
operationResult.setId(mLastOperationId.incrementAndGet());
operationResult.setOperation(operation);
operationResult.setBroadcast(broadcastResult);
return operationResult;
} | java | {
"resource": ""
} |
q168594 | ChronosService.runAsync | validation | final <Output> int runAsync(@NonNull final ChronosOperation<Output> operation,
final boolean broadcastResult) {
final ChronosOperationResult<Output> result = createEmptyResult(operation, broadcastResult);
final int id = result.getId();
synchronized (ChronosService.this) {
RunningOperationStorage.getInstance().operationStarted(id, operation,
mExecutorService.submit(new Runnable() {
@Override
public void run() {
silentRun(operation, result);
mEventBus.post(result);
synchronized (ChronosService.this) {
RunningOperationStorage.getInstance().operationFinished(id);
}
}
}));
}
return id;
} | java | {
"resource": ""
} |
q168595 | ChronosService.runSync | validation | @NonNull
final <Output> ChronosOperationResult<Output> runSync(
@NonNull final ChronosOperation<Output> operation, final boolean broadcastResult) {
final ChronosOperationResult<Output> result = createEmptyResult(operation, broadcastResult);
silentRun(operation, result);
mEventBus.post(result);
return result;
} | java | {
"resource": ""
} |
q168596 | DataLoadCancel.onOperationFinished | validation | public void onOperationFinished(final SimpleOperation.Result result) {
if (result.isSuccessful()) {
mData = result.getOutput();
showData();
} else {
mTextOutput.setText(result.getErrorMessage());
}
} | java | {
"resource": ""
} |
q168597 | Main.main | validation | protected static void main(Main main, String... args) {
main.getInjector().getInstance(main.getMainClass()).doMain(args);
} | java | {
"resource": ""
} |
q168598 | Main.getModules | validation | protected Module[] getModules() {
Module[] modules = { new WireModule(new EventHandlerModule(),
new SpaceModule(new URLClassSpace(Main.class.getClassLoader()))) };
return modules;
} | java | {
"resource": ""
} |
q168599 | Main.doMain | validation | protected void doMain(String... args) {
properties = new MergeableProperties();
properties.putAll(System.getProperties());
for (String arg : args) {
properties.merge(arg);
}
// Read event handling configuration
Map<String, List<EventHandler>> eventHandlers = new LinkedHashMap<>();
MergeableProperties allProperties = properties.getPrefixed("willow-event-handler.handlers");
int i = 0;
while (true) {
MergeableProperties handlerProperties = allProperties.getPrefixed("[" + i++ + "]");
if (handlerProperties.isEmpty()) {
break;
}
String handlerClassName = handlerProperties.getProperty("handler");
String eventClassName = handlerProperties.getProperty("event");
try {
EventHandler eventHandler = (EventHandler) injector.getInstance(Class.forName(handlerClassName));
MergeableProperties beanProperties = handlerProperties.getPrefixed("properties");
for (String propertyName : beanProperties.stringPropertyNames()) {
String propertyValue = beanProperties.getProperty(propertyName);
BeanUtils.setProperty(eventHandler, propertyName, propertyValue);
}
List<EventHandler> eventHandlersForType = eventHandlers.get(eventClassName);
if (eventHandlersForType == null) {
eventHandlersForType = new ArrayList<>();
eventHandlers.put(eventClassName, eventHandlersForType);
}
eventHandlersForType.add(eventHandler);
} catch (ClassNotFoundException | IllegalAccessException | InvocationTargetException e) {
logger.log(Level.SEVERE, "Error instantiating handler", e);
System.exit(1);
}
}
if (eventHandlers .isEmpty()) {
logger.info("No event handlers configured. Exiting.");
System.exit(0);
}
Runtime.getRuntime().addShutdownHook(new Thread() {
@Override
public void run() {
Main.this.stop();
}
});
// Start polling events
String uri = properties.getProperty("willow-event-handler.eventsUri");
try {
logger.info("Initializing event poller");
eventPoller.initialize(eventHandlers, new URI(uri));
} catch (URISyntaxException e) {
logger.log(Level.SEVERE, "Invalid URI: " + uri, e);
System.exit(1);
}
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.