| package a.b; |
| |
| import android.content.pm.ActivityInfo; |
| import android.os.Bundle; |
| import android.os.Parcelable; |
| import androidx.annotation.NonNull; |
| import androidx.annotation.Nullable; |
| import androidx.lifecycle.SavedStateHandle; |
| import androidx.navigation.NavArgs; |
| import java.io.Serializable; |
| import java.lang.IllegalArgumentException; |
| import java.lang.Object; |
| import java.lang.Override; |
| import java.lang.String; |
| import java.lang.SuppressWarnings; |
| import java.lang.System; |
| import java.nio.file.AccessMode; |
| import java.util.HashMap; |
| |
| public class MainFragmentArgs implements NavArgs { |
| private final HashMap arguments = new HashMap(); |
| |
| private MainFragmentArgs() { |
| } |
| |
| @SuppressWarnings("unchecked") |
| private MainFragmentArgs(HashMap argumentsMap) { |
| this.arguments.putAll(argumentsMap); |
| } |
| |
| @NonNull |
| @SuppressWarnings({"unchecked","deprecation"}) |
| public static MainFragmentArgs fromBundle(@NonNull Bundle bundle) { |
| MainFragmentArgs __result = new MainFragmentArgs(); |
| bundle.setClassLoader(MainFragmentArgs.class.getClassLoader()); |
| if (bundle.containsKey("main")) { |
| String main; |
| main = bundle.getString("main"); |
| if (main == null) { |
| throw new IllegalArgumentException("Argument \"main\" is marked as non-null but was passed a null value."); |
| } |
| __result.arguments.put("main", main); |
| } else { |
| throw new IllegalArgumentException("Required argument \"main\" is missing and does not have an android:defaultValue"); |
| } |
| if (bundle.containsKey("optional")) { |
| int optional; |
| optional = bundle.getInt("optional"); |
| __result.arguments.put("optional", optional); |
| } else { |
| __result.arguments.put("optional", -1); |
| } |
| if (bundle.containsKey("reference")) { |
| int reference; |
| reference = bundle.getInt("reference"); |
| __result.arguments.put("reference", reference); |
| } else { |
| __result.arguments.put("reference", R.drawable.background); |
| } |
| if (bundle.containsKey("referenceZeroDefaultValue")) { |
| int referenceZeroDefaultValue; |
| referenceZeroDefaultValue = bundle.getInt("referenceZeroDefaultValue"); |
| __result.arguments.put("referenceZeroDefaultValue", referenceZeroDefaultValue); |
| } else { |
| __result.arguments.put("referenceZeroDefaultValue", 0); |
| } |
| if (bundle.containsKey("floatArg")) { |
| float floatArg; |
| floatArg = bundle.getFloat("floatArg"); |
| __result.arguments.put("floatArg", floatArg); |
| } else { |
| __result.arguments.put("floatArg", 1F); |
| } |
| if (bundle.containsKey("floatArrayArg")) { |
| float[] floatArrayArg; |
| floatArrayArg = bundle.getFloatArray("floatArrayArg"); |
| if (floatArrayArg == null) { |
| throw new IllegalArgumentException("Argument \"floatArrayArg\" is marked as non-null but was passed a null value."); |
| } |
| __result.arguments.put("floatArrayArg", floatArrayArg); |
| } else { |
| throw new IllegalArgumentException("Required argument \"floatArrayArg\" is missing and does not have an android:defaultValue"); |
| } |
| if (bundle.containsKey("objectArrayArg")) { |
| ActivityInfo[] objectArrayArg; |
| Parcelable[] __array = bundle.getParcelableArray("objectArrayArg"); |
| if (__array != null) { |
| objectArrayArg = new ActivityInfo[__array.length]; |
| System.arraycopy(__array, 0, objectArrayArg, 0, __array.length); |
| } else { |
| objectArrayArg = null; |
| } |
| if (objectArrayArg == null) { |
| throw new IllegalArgumentException("Argument \"objectArrayArg\" is marked as non-null but was passed a null value."); |
| } |
| __result.arguments.put("objectArrayArg", objectArrayArg); |
| } else { |
| throw new IllegalArgumentException("Required argument \"objectArrayArg\" is missing and does not have an android:defaultValue"); |
| } |
| if (bundle.containsKey("boolArg")) { |
| boolean boolArg; |
| boolArg = bundle.getBoolean("boolArg"); |
| __result.arguments.put("boolArg", boolArg); |
| } else { |
| __result.arguments.put("boolArg", true); |
| } |
| if (bundle.containsKey("optionalParcelable")) { |
| ActivityInfo optionalParcelable; |
| if (Parcelable.class.isAssignableFrom(ActivityInfo.class) || Serializable.class.isAssignableFrom(ActivityInfo.class)) { |
| optionalParcelable = (ActivityInfo) bundle.get("optionalParcelable"); |
| } else { |
| throw new UnsupportedOperationException(ActivityInfo.class.getName() + " must implement Parcelable or Serializable or must be an Enum."); |
| } |
| __result.arguments.put("optionalParcelable", optionalParcelable); |
| } else { |
| __result.arguments.put("optionalParcelable", null); |
| } |
| if (bundle.containsKey("enumArg")) { |
| AccessMode enumArg; |
| if (Parcelable.class.isAssignableFrom(AccessMode.class) || Serializable.class.isAssignableFrom(AccessMode.class)) { |
| enumArg = (AccessMode) bundle.get("enumArg"); |
| } else { |
| throw new UnsupportedOperationException(AccessMode.class.getName() + " must implement Parcelable or Serializable or must be an Enum."); |
| } |
| if (enumArg == null) { |
| throw new IllegalArgumentException("Argument \"enumArg\" is marked as non-null but was passed a null value."); |
| } |
| __result.arguments.put("enumArg", enumArg); |
| } else { |
| __result.arguments.put("enumArg", AccessMode.READ); |
| } |
| return __result; |
| } |
| |
| @NonNull |
| @SuppressWarnings("unchecked") |
| public static MainFragmentArgs fromSavedStateHandle(@NonNull SavedStateHandle savedStateHandle) { |
| MainFragmentArgs __result = new MainFragmentArgs(); |
| if (savedStateHandle.contains("main")) { |
| String main; |
| main = savedStateHandle.get("main"); |
| if (main == null) { |
| throw new IllegalArgumentException("Argument \"main\" is marked as non-null but was passed a null value."); |
| } |
| __result.arguments.put("main", main); |
| } else { |
| throw new IllegalArgumentException("Required argument \"main\" is missing and does not have an android:defaultValue"); |
| } |
| if (savedStateHandle.contains("optional")) { |
| int optional; |
| optional = savedStateHandle.get("optional"); |
| __result.arguments.put("optional", optional); |
| } else { |
| __result.arguments.put("optional", -1); |
| } |
| if (savedStateHandle.contains("reference")) { |
| int reference; |
| reference = savedStateHandle.get("reference"); |
| __result.arguments.put("reference", reference); |
| } else { |
| __result.arguments.put("reference", R.drawable.background); |
| } |
| if (savedStateHandle.contains("referenceZeroDefaultValue")) { |
| int referenceZeroDefaultValue; |
| referenceZeroDefaultValue = savedStateHandle.get("referenceZeroDefaultValue"); |
| __result.arguments.put("referenceZeroDefaultValue", referenceZeroDefaultValue); |
| } else { |
| __result.arguments.put("referenceZeroDefaultValue", 0); |
| } |
| if (savedStateHandle.contains("floatArg")) { |
| float floatArg; |
| floatArg = savedStateHandle.get("floatArg"); |
| __result.arguments.put("floatArg", floatArg); |
| } else { |
| __result.arguments.put("floatArg", 1F); |
| } |
| if (savedStateHandle.contains("floatArrayArg")) { |
| float[] floatArrayArg; |
| floatArrayArg = savedStateHandle.get("floatArrayArg"); |
| if (floatArrayArg == null) { |
| throw new IllegalArgumentException("Argument \"floatArrayArg\" is marked as non-null but was passed a null value."); |
| } |
| __result.arguments.put("floatArrayArg", floatArrayArg); |
| } else { |
| throw new IllegalArgumentException("Required argument \"floatArrayArg\" is missing and does not have an android:defaultValue"); |
| } |
| if (savedStateHandle.contains("objectArrayArg")) { |
| ActivityInfo[] objectArrayArg; |
| objectArrayArg = savedStateHandle.get("objectArrayArg"); |
| if (objectArrayArg == null) { |
| throw new IllegalArgumentException("Argument \"objectArrayArg\" is marked as non-null but was passed a null value."); |
| } |
| __result.arguments.put("objectArrayArg", objectArrayArg); |
| } else { |
| throw new IllegalArgumentException("Required argument \"objectArrayArg\" is missing and does not have an android:defaultValue"); |
| } |
| if (savedStateHandle.contains("boolArg")) { |
| boolean boolArg; |
| boolArg = savedStateHandle.get("boolArg"); |
| __result.arguments.put("boolArg", boolArg); |
| } else { |
| __result.arguments.put("boolArg", true); |
| } |
| if (savedStateHandle.contains("optionalParcelable")) { |
| ActivityInfo optionalParcelable; |
| optionalParcelable = savedStateHandle.get("optionalParcelable"); |
| __result.arguments.put("optionalParcelable", optionalParcelable); |
| } else { |
| __result.arguments.put("optionalParcelable", null); |
| } |
| if (savedStateHandle.contains("enumArg")) { |
| AccessMode enumArg; |
| enumArg = savedStateHandle.get("enumArg"); |
| if (enumArg == null) { |
| throw new IllegalArgumentException("Argument \"enumArg\" is marked as non-null but was passed a null value."); |
| } |
| __result.arguments.put("enumArg", enumArg); |
| } else { |
| __result.arguments.put("enumArg", AccessMode.READ); |
| } |
| return __result; |
| } |
| |
| @SuppressWarnings("unchecked") |
| @NonNull |
| public String getMain() { |
| return (String) arguments.get("main"); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public int getOptional() { |
| return (int) arguments.get("optional"); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public int getReference() { |
| return (int) arguments.get("reference"); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public int getReferenceZeroDefaultValue() { |
| return (int) arguments.get("referenceZeroDefaultValue"); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public float getFloatArg() { |
| return (float) arguments.get("floatArg"); |
| } |
| |
| @SuppressWarnings("unchecked") |
| @NonNull |
| public float[] getFloatArrayArg() { |
| return (float[]) arguments.get("floatArrayArg"); |
| } |
| |
| @SuppressWarnings("unchecked") |
| @NonNull |
| public ActivityInfo[] getObjectArrayArg() { |
| return (ActivityInfo[]) arguments.get("objectArrayArg"); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public boolean getBoolArg() { |
| return (boolean) arguments.get("boolArg"); |
| } |
| |
| @SuppressWarnings("unchecked") |
| @Nullable |
| public ActivityInfo getOptionalParcelable() { |
| return (ActivityInfo) arguments.get("optionalParcelable"); |
| } |
| |
| @SuppressWarnings("unchecked") |
| @NonNull |
| public AccessMode getEnumArg() { |
| return (AccessMode) arguments.get("enumArg"); |
| } |
| |
| @SuppressWarnings("unchecked") |
| @NonNull |
| public Bundle toBundle() { |
| Bundle __result = new Bundle(); |
| if (arguments.containsKey("main")) { |
| String main = (String) arguments.get("main"); |
| __result.putString("main", main); |
| } |
| if (arguments.containsKey("optional")) { |
| int optional = (int) arguments.get("optional"); |
| __result.putInt("optional", optional); |
| } else { |
| __result.putInt("optional", -1); |
| } |
| if (arguments.containsKey("reference")) { |
| int reference = (int) arguments.get("reference"); |
| __result.putInt("reference", reference); |
| } else { |
| __result.putInt("reference", R.drawable.background); |
| } |
| if (arguments.containsKey("referenceZeroDefaultValue")) { |
| int referenceZeroDefaultValue = (int) arguments.get("referenceZeroDefaultValue"); |
| __result.putInt("referenceZeroDefaultValue", referenceZeroDefaultValue); |
| } else { |
| __result.putInt("referenceZeroDefaultValue", 0); |
| } |
| if (arguments.containsKey("floatArg")) { |
| float floatArg = (float) arguments.get("floatArg"); |
| __result.putFloat("floatArg", floatArg); |
| } else { |
| __result.putFloat("floatArg", 1F); |
| } |
| if (arguments.containsKey("floatArrayArg")) { |
| float[] floatArrayArg = (float[]) arguments.get("floatArrayArg"); |
| __result.putFloatArray("floatArrayArg", floatArrayArg); |
| } |
| if (arguments.containsKey("objectArrayArg")) { |
| ActivityInfo[] objectArrayArg = (ActivityInfo[]) arguments.get("objectArrayArg"); |
| __result.putParcelableArray("objectArrayArg", objectArrayArg); |
| } |
| if (arguments.containsKey("boolArg")) { |
| boolean boolArg = (boolean) arguments.get("boolArg"); |
| __result.putBoolean("boolArg", boolArg); |
| } else { |
| __result.putBoolean("boolArg", true); |
| } |
| if (arguments.containsKey("optionalParcelable")) { |
| ActivityInfo optionalParcelable = (ActivityInfo) arguments.get("optionalParcelable"); |
| if (Parcelable.class.isAssignableFrom(ActivityInfo.class) || optionalParcelable == null) { |
| __result.putParcelable("optionalParcelable", Parcelable.class.cast(optionalParcelable)); |
| } else if (Serializable.class.isAssignableFrom(ActivityInfo.class)) { |
| __result.putSerializable("optionalParcelable", Serializable.class.cast(optionalParcelable)); |
| } else { |
| throw new UnsupportedOperationException(ActivityInfo.class.getName() + " must implement Parcelable or Serializable or must be an Enum."); |
| } |
| } else { |
| __result.putSerializable("optionalParcelable", null); |
| } |
| if (arguments.containsKey("enumArg")) { |
| AccessMode enumArg = (AccessMode) arguments.get("enumArg"); |
| if (Parcelable.class.isAssignableFrom(AccessMode.class) || enumArg == null) { |
| __result.putParcelable("enumArg", Parcelable.class.cast(enumArg)); |
| } else if (Serializable.class.isAssignableFrom(AccessMode.class)) { |
| __result.putSerializable("enumArg", Serializable.class.cast(enumArg)); |
| } else { |
| throw new UnsupportedOperationException(AccessMode.class.getName() + " must implement Parcelable or Serializable or must be an Enum."); |
| } |
| } else { |
| __result.putSerializable("enumArg", AccessMode.READ); |
| } |
| return __result; |
| } |
| |
| @SuppressWarnings("unchecked") |
| @NonNull |
| public SavedStateHandle toSavedStateHandle() { |
| SavedStateHandle __result = new SavedStateHandle(); |
| if (arguments.containsKey("main")) { |
| String main = (String) arguments.get("main"); |
| __result.set("main", main); |
| } |
| if (arguments.containsKey("optional")) { |
| int optional = (int) arguments.get("optional"); |
| __result.set("optional", optional); |
| } else { |
| __result.set("optional", -1); |
| } |
| if (arguments.containsKey("reference")) { |
| int reference = (int) arguments.get("reference"); |
| __result.set("reference", reference); |
| } else { |
| __result.set("reference", R.drawable.background); |
| } |
| if (arguments.containsKey("referenceZeroDefaultValue")) { |
| int referenceZeroDefaultValue = (int) arguments.get("referenceZeroDefaultValue"); |
| __result.set("referenceZeroDefaultValue", referenceZeroDefaultValue); |
| } else { |
| __result.set("referenceZeroDefaultValue", 0); |
| } |
| if (arguments.containsKey("floatArg")) { |
| float floatArg = (float) arguments.get("floatArg"); |
| __result.set("floatArg", floatArg); |
| } else { |
| __result.set("floatArg", 1F); |
| } |
| if (arguments.containsKey("floatArrayArg")) { |
| float[] floatArrayArg = (float[]) arguments.get("floatArrayArg"); |
| __result.set("floatArrayArg", floatArrayArg); |
| } |
| if (arguments.containsKey("objectArrayArg")) { |
| ActivityInfo[] objectArrayArg = (ActivityInfo[]) arguments.get("objectArrayArg"); |
| __result.set("objectArrayArg", objectArrayArg); |
| } |
| if (arguments.containsKey("boolArg")) { |
| boolean boolArg = (boolean) arguments.get("boolArg"); |
| __result.set("boolArg", boolArg); |
| } else { |
| __result.set("boolArg", true); |
| } |
| if (arguments.containsKey("optionalParcelable")) { |
| ActivityInfo optionalParcelable = (ActivityInfo) arguments.get("optionalParcelable"); |
| if (Parcelable.class.isAssignableFrom(ActivityInfo.class) || optionalParcelable == null) { |
| __result.set("optionalParcelable", Parcelable.class.cast(optionalParcelable)); |
| } else if (Serializable.class.isAssignableFrom(ActivityInfo.class)) { |
| __result.set("optionalParcelable", Serializable.class.cast(optionalParcelable)); |
| } else { |
| throw new UnsupportedOperationException(ActivityInfo.class.getName() + " must implement Parcelable or Serializable or must be an Enum."); |
| } |
| } else { |
| __result.set("optionalParcelable", null); |
| } |
| if (arguments.containsKey("enumArg")) { |
| AccessMode enumArg = (AccessMode) arguments.get("enumArg"); |
| if (Parcelable.class.isAssignableFrom(AccessMode.class) || enumArg == null) { |
| __result.set("enumArg", Parcelable.class.cast(enumArg)); |
| } else if (Serializable.class.isAssignableFrom(AccessMode.class)) { |
| __result.set("enumArg", Serializable.class.cast(enumArg)); |
| } else { |
| throw new UnsupportedOperationException(AccessMode.class.getName() + " must implement Parcelable or Serializable or must be an Enum."); |
| } |
| } else { |
| __result.set("enumArg", AccessMode.READ); |
| } |
| return __result; |
| } |
| |
| @Override |
| public boolean equals(Object object) { |
| if (this == object) { |
| return true; |
| } |
| if (object == null || getClass() != object.getClass()) { |
| return false; |
| } |
| MainFragmentArgs that = (MainFragmentArgs) object; |
| if (arguments.containsKey("main") != that.arguments.containsKey("main")) { |
| return false; |
| } |
| if (getMain() != null ? !getMain().equals(that.getMain()) : that.getMain() != null) { |
| return false; |
| } |
| if (arguments.containsKey("optional") != that.arguments.containsKey("optional")) { |
| return false; |
| } |
| if (getOptional() != that.getOptional()) { |
| return false; |
| } |
| if (arguments.containsKey("reference") != that.arguments.containsKey("reference")) { |
| return false; |
| } |
| if (getReference() != that.getReference()) { |
| return false; |
| } |
| if (arguments.containsKey("referenceZeroDefaultValue") != that.arguments.containsKey("referenceZeroDefaultValue")) { |
| return false; |
| } |
| if (getReferenceZeroDefaultValue() != that.getReferenceZeroDefaultValue()) { |
| return false; |
| } |
| if (arguments.containsKey("floatArg") != that.arguments.containsKey("floatArg")) { |
| return false; |
| } |
| if (Float.compare(that.getFloatArg(), getFloatArg()) != 0) { |
| return false; |
| } |
| if (arguments.containsKey("floatArrayArg") != that.arguments.containsKey("floatArrayArg")) { |
| return false; |
| } |
| if (getFloatArrayArg() != null ? !getFloatArrayArg().equals(that.getFloatArrayArg()) : that.getFloatArrayArg() != null) { |
| return false; |
| } |
| if (arguments.containsKey("objectArrayArg") != that.arguments.containsKey("objectArrayArg")) { |
| return false; |
| } |
| if (getObjectArrayArg() != null ? !getObjectArrayArg().equals(that.getObjectArrayArg()) : that.getObjectArrayArg() != null) { |
| return false; |
| } |
| if (arguments.containsKey("boolArg") != that.arguments.containsKey("boolArg")) { |
| return false; |
| } |
| if (getBoolArg() != that.getBoolArg()) { |
| return false; |
| } |
| if (arguments.containsKey("optionalParcelable") != that.arguments.containsKey("optionalParcelable")) { |
| return false; |
| } |
| if (getOptionalParcelable() != null ? !getOptionalParcelable().equals(that.getOptionalParcelable()) : that.getOptionalParcelable() != null) { |
| return false; |
| } |
| if (arguments.containsKey("enumArg") != that.arguments.containsKey("enumArg")) { |
| return false; |
| } |
| if (getEnumArg() != null ? !getEnumArg().equals(that.getEnumArg()) : that.getEnumArg() != null) { |
| return false; |
| } |
| return true; |
| } |
| |
| @Override |
| public int hashCode() { |
| int result = 1; |
| result = 31 * result + (getMain() != null ? getMain().hashCode() : 0); |
| result = 31 * result + getOptional(); |
| result = 31 * result + getReference(); |
| result = 31 * result + getReferenceZeroDefaultValue(); |
| result = 31 * result + Float.floatToIntBits(getFloatArg()); |
| result = 31 * result + java.util.Arrays.hashCode(getFloatArrayArg()); |
| result = 31 * result + java.util.Arrays.hashCode(getObjectArrayArg()); |
| result = 31 * result + (getBoolArg() ? 1 : 0); |
| result = 31 * result + (getOptionalParcelable() != null ? getOptionalParcelable().hashCode() : 0); |
| result = 31 * result + (getEnumArg() != null ? getEnumArg().hashCode() : 0); |
| return result; |
| } |
| |
| @Override |
| public String toString() { |
| return "MainFragmentArgs{" |
| + "main=" + getMain() |
| + ", optional=" + getOptional() |
| + ", reference=" + getReference() |
| + ", referenceZeroDefaultValue=" + getReferenceZeroDefaultValue() |
| + ", floatArg=" + getFloatArg() |
| + ", floatArrayArg=" + getFloatArrayArg() |
| + ", objectArrayArg=" + getObjectArrayArg() |
| + ", boolArg=" + getBoolArg() |
| + ", optionalParcelable=" + getOptionalParcelable() |
| + ", enumArg=" + getEnumArg() |
| + "}"; |
| } |
| |
| public static final class Builder { |
| private final HashMap arguments = new HashMap(); |
| |
| @SuppressWarnings("unchecked") |
| public Builder(@NonNull MainFragmentArgs original) { |
| this.arguments.putAll(original.arguments); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public Builder(@NonNull String main, @NonNull float[] floatArrayArg, |
| @NonNull ActivityInfo[] objectArrayArg) { |
| if (main == null) { |
| throw new IllegalArgumentException("Argument \"main\" is marked as non-null but was passed a null value."); |
| } |
| this.arguments.put("main", main); |
| if (floatArrayArg == null) { |
| throw new IllegalArgumentException("Argument \"floatArrayArg\" is marked as non-null but was passed a null value."); |
| } |
| this.arguments.put("floatArrayArg", floatArrayArg); |
| if (objectArrayArg == null) { |
| throw new IllegalArgumentException("Argument \"objectArrayArg\" is marked as non-null but was passed a null value."); |
| } |
| this.arguments.put("objectArrayArg", objectArrayArg); |
| } |
| |
| @NonNull |
| public MainFragmentArgs build() { |
| MainFragmentArgs result = new MainFragmentArgs(arguments); |
| return result; |
| } |
| |
| @NonNull |
| @SuppressWarnings("unchecked") |
| public Builder setMain(@NonNull String main) { |
| if (main == null) { |
| throw new IllegalArgumentException("Argument \"main\" is marked as non-null but was passed a null value."); |
| } |
| this.arguments.put("main", main); |
| return this; |
| } |
| |
| @NonNull |
| @SuppressWarnings("unchecked") |
| public Builder setOptional(int optional) { |
| this.arguments.put("optional", optional); |
| return this; |
| } |
| |
| @NonNull |
| @SuppressWarnings("unchecked") |
| public Builder setReference(int reference) { |
| this.arguments.put("reference", reference); |
| return this; |
| } |
| |
| @NonNull |
| @SuppressWarnings("unchecked") |
| public Builder setReferenceZeroDefaultValue(int referenceZeroDefaultValue) { |
| this.arguments.put("referenceZeroDefaultValue", referenceZeroDefaultValue); |
| return this; |
| } |
| |
| @NonNull |
| @SuppressWarnings("unchecked") |
| public Builder setFloatArg(float floatArg) { |
| this.arguments.put("floatArg", floatArg); |
| return this; |
| } |
| |
| @NonNull |
| @SuppressWarnings("unchecked") |
| public Builder setFloatArrayArg(@NonNull float[] floatArrayArg) { |
| if (floatArrayArg == null) { |
| throw new IllegalArgumentException("Argument \"floatArrayArg\" is marked as non-null but was passed a null value."); |
| } |
| this.arguments.put("floatArrayArg", floatArrayArg); |
| return this; |
| } |
| |
| @NonNull |
| @SuppressWarnings("unchecked") |
| public Builder setObjectArrayArg(@NonNull ActivityInfo[] objectArrayArg) { |
| if (objectArrayArg == null) { |
| throw new IllegalArgumentException("Argument \"objectArrayArg\" is marked as non-null but was passed a null value."); |
| } |
| this.arguments.put("objectArrayArg", objectArrayArg); |
| return this; |
| } |
| |
| @NonNull |
| @SuppressWarnings("unchecked") |
| public Builder setBoolArg(boolean boolArg) { |
| this.arguments.put("boolArg", boolArg); |
| return this; |
| } |
| |
| @NonNull |
| @SuppressWarnings("unchecked") |
| public Builder setOptionalParcelable(@Nullable ActivityInfo optionalParcelable) { |
| this.arguments.put("optionalParcelable", optionalParcelable); |
| return this; |
| } |
| |
| @NonNull |
| @SuppressWarnings("unchecked") |
| public Builder setEnumArg(@NonNull AccessMode enumArg) { |
| if (enumArg == null) { |
| throw new IllegalArgumentException("Argument \"enumArg\" is marked as non-null but was passed a null value."); |
| } |
| this.arguments.put("enumArg", enumArg); |
| return this; |
| } |
| |
| @SuppressWarnings({"unchecked","GetterOnBuilder"}) |
| @NonNull |
| public String getMain() { |
| return (String) arguments.get("main"); |
| } |
| |
| @SuppressWarnings({"unchecked","GetterOnBuilder"}) |
| public int getOptional() { |
| return (int) arguments.get("optional"); |
| } |
| |
| @SuppressWarnings({"unchecked","GetterOnBuilder"}) |
| public int getReference() { |
| return (int) arguments.get("reference"); |
| } |
| |
| @SuppressWarnings({"unchecked","GetterOnBuilder"}) |
| public int getReferenceZeroDefaultValue() { |
| return (int) arguments.get("referenceZeroDefaultValue"); |
| } |
| |
| @SuppressWarnings({"unchecked","GetterOnBuilder"}) |
| public float getFloatArg() { |
| return (float) arguments.get("floatArg"); |
| } |
| |
| @SuppressWarnings({"unchecked","GetterOnBuilder"}) |
| @NonNull |
| public float[] getFloatArrayArg() { |
| return (float[]) arguments.get("floatArrayArg"); |
| } |
| |
| @SuppressWarnings({"unchecked","GetterOnBuilder"}) |
| @NonNull |
| public ActivityInfo[] getObjectArrayArg() { |
| return (ActivityInfo[]) arguments.get("objectArrayArg"); |
| } |
| |
| @SuppressWarnings({"unchecked","GetterOnBuilder"}) |
| public boolean getBoolArg() { |
| return (boolean) arguments.get("boolArg"); |
| } |
| |
| @SuppressWarnings({"unchecked","GetterOnBuilder"}) |
| @Nullable |
| public ActivityInfo getOptionalParcelable() { |
| return (ActivityInfo) arguments.get("optionalParcelable"); |
| } |
| |
| @SuppressWarnings({"unchecked","GetterOnBuilder"}) |
| @NonNull |
| public AccessMode getEnumArg() { |
| return (AccessMode) arguments.get("enumArg"); |
| } |
| } |
| } |