| /* |
| * Copyright (C) 2019 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package com.android.codegentest; |
| |
| import android.annotation.FloatRange; |
| import android.annotation.IntDef; |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.annotation.Size; |
| import android.annotation.StringDef; |
| import android.annotation.StringRes; |
| import android.annotation.UserIdInt; |
| import android.companion.ICompanionDeviceManager; |
| import android.content.pm.PackageManager; |
| import android.net.LinkAddress; |
| import android.os.Binder; |
| import android.os.IBinder; |
| import android.os.Parcel; |
| import android.os.Parcelable; |
| import android.view.accessibility.AccessibilityNodeInfo; |
| |
| import com.android.internal.util.AnnotationValidations; |
| import com.android.internal.util.DataClass; |
| import com.android.internal.util.DataClass.Each; |
| import com.android.internal.util.Parcelling; |
| import com.android.internal.util.Preconditions; |
| |
| import java.io.PrintWriter; |
| import java.util.ArrayList; |
| import java.util.Date; |
| import java.util.List; |
| import java.util.Objects; |
| import java.util.regex.Pattern; |
| |
| /** |
| * Sample data class, showing off various code generation features. |
| * |
| * See javadoc on non-generated code for the explanation of the various features. |
| * |
| * See {@link SampleDataClassTest} for various invariants the generated code is expected to hold. |
| */ |
| @DataClass( |
| // genParcelable = true, // implied by `implements Parcelable` |
| // genAidl = true, // implied by `implements Parcelable` |
| // genGetters = true, // on by default |
| // genConstDefs = true, // implied by presence of constants with common prefix |
| genBuilder = true, // on by default if optional fields present, but suppressed by |
| // genConstructor |
| genConstructor = true, // on by default but normally suppressed by genBuilder |
| genEqualsHashCode = true, |
| genToString = true, |
| genForEachField = true, |
| genSetters = true |
| ) |
| public final class SampleDataClass implements Parcelable { |
| |
| /** |
| * For any group of {@link int} or {@link String} constants like these, a corresponding |
| * {@link IntDef}/{@link StringDef} will get generated, with name based on common prefix |
| * by default. |
| * |
| * When {@link #SampleDataClass constructing} an instance, fields annotated with these |
| * annotations get automatically validated, with only provided constants being a valid value. |
| * |
| * @see StateName, the generated {@link StringDef} |
| * @see #mStateName annotated with {@link StateName} |
| */ |
| public static final String STATE_NAME_UNDEFINED = "?"; |
| public static final String STATE_NAME_ON = "on"; |
| public static final String STATE_NAME_OFF = "off"; |
| |
| /** |
| * Additionally, for any generated {@link IntDef} a corresponding static |
| * *ToString method will be also generated, and used in {@link #toString()}. |
| * |
| * @see #stateToString(int) |
| * @see #toString() |
| * @see State |
| */ |
| public static final int STATE_ON = 1; |
| public static final int STATE_OFF = 0; |
| public static final int STATE_UNDEFINED |
| = PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED; |
| |
| /** |
| * {@link IntDef}s with values specified in hex("0x...") are considered to be |
| * {@link IntDef#flag flags}, while ones specified with regular int literals are considered |
| * not to be flags. |
| * |
| * This affects their string representation, e.g. see the difference in |
| * {@link #requestFlagsToString} vs {@link #stateToString}. |
| * |
| * This also affects the validation logic when {@link #SampleDataClass constructing} |
| * an instance, with any flag combination("|") being valid. |
| * |
| * You can customize the name of the generated {@link IntDef}/{@link StringDef} annotation |
| * by annotating each constant with the desired name before running the generation. |
| * |
| * Here the annotation is named {@link RequestFlags} instead of the default {@code Flags}. |
| */ |
| public static final @RequestFlags int FLAG_MANUAL_REQUEST = 0x1; |
| public static final @RequestFlags int FLAG_COMPATIBILITY_MODE_REQUEST = 0x2; |
| public static final @RequestFlags int FLAG_AUGMENTED_REQUEST = 0x80000000; |
| |
| |
| /** |
| * Any property javadoc should go onto the field, and will be copied where appropriate, |
| * including getters, constructor parameters, builder setters, etc. |
| * |
| * <p> |
| * This allows to avoid the burden of maintaining copies of the same documentation |
| * pieces in multiple places for each field. |
| */ |
| private int mNum; |
| /** |
| * Various javadoc features should work as expected when copied, e.g {@code code}, |
| * {@link #mName links}, <a href="https://google.com">html links</a>, etc. |
| * |
| * @see #mNum2 ..and so should blocks at the bottom, e.g. {@code @see} blocks. |
| */ |
| private int mNum2; |
| /** |
| * {@code @hide} javadoc annotation is also propagated, which can be used to adjust the |
| * desired public API surface. |
| * |
| * @see #getNum4() is hidden |
| * @see Builder#setNum4(int) also hidden |
| * @hide |
| */ |
| private int mNum4; |
| |
| /** |
| * {@link Nullable} or {@link NonNull} annotation is required on all non-primitive fields. |
| */ |
| private @Nullable String mName; |
| /** |
| * Fields with default value expressions ("mFoo = ...") are optional, and are automatically |
| * initialized to the provided default expression, unless explicitly set. |
| * |
| * When using a {@link Builder} optional fields are passed via a {@link Builder#setName2 setter} |
| * while mandatory fields are passed via {@link Builder#Builder constructor}. |
| */ |
| private @NonNull String mName2 = "Bob"; |
| /** |
| * Alternatively, when default value computation is expensive, |
| * {@link #defaultName4 defaultFieldName()} can be defined to compute the default value. |
| */ |
| private @NonNull String mName4; |
| private static String defaultName4() { |
| // Expensive computation |
| return "Bob4"; |
| } |
| |
| /** |
| * For parcelling, any field type supported by {@link Parcel} is supported out of the box. |
| * E.g. {@link Parcelable} subclasses, {@link String}, {@link int}, {@link boolean}, etc. |
| */ |
| private @Nullable AccessibilityNodeInfo mOtherParcelable = null; |
| /** |
| * Additionally, support for parcelling other types can be added by implementing a |
| * {@link Parcelling}, and referencing it in the {@link DataClass.ParcelWith} field annotation. |
| * |
| * @see MyDateParcelling an example {@link Parcelling} implementation |
| */ |
| @DataClass.ParcelWith(MyDateParcelling.class) |
| private @NonNull Date mDate = new Date(42 * 42); |
| /** |
| * If a {@link Parcelling} is fairly common, consider putting it in {@link Parcelling.BuiltIn} |
| * to encourage its reuse. |
| */ |
| @DataClass.ParcelWith(Parcelling.BuiltIn.ForPattern.class) |
| private @NonNull Pattern mPattern = Pattern.compile(""); |
| |
| /** |
| * For lists, when using a {@link Builder}, other than a regular |
| * {@link Builder#setLinkAddresses2(List) setter}, and additional |
| * {@link Builder#addLinkAddresses2(LinkAddress) add} method is generated for convenience. |
| */ |
| private @NonNull List<LinkAddress> mLinkAddresses2 = new ArrayList<>(); |
| /** |
| * For aesthetics, you may want to consider providing a singular version of the plural field |
| * name, which would be used for the {@link #mLinkAddresses2 above mentioned} "add" method. |
| * |
| * @see Builder#addLinkAddress(LinkAddress) |
| */ |
| @DataClass.PluralOf("linkAddress") |
| private @NonNull ArrayList<LinkAddress> mLinkAddresses = new ArrayList<>(); |
| /** |
| * For array fields, when using a {@link Builder}, vararg argument format is used for |
| * convenience. |
| * |
| * @see Builder#setLinkAddresses4(LinkAddress...) |
| */ |
| private @Nullable LinkAddress[] mLinkAddresses4 = null; |
| |
| /** |
| * {@link IntDef}/{@link StringDef}-annotated fields propagate the annotation to |
| * getter/constructor/setter/builder parameters, making for a nicer api. |
| * |
| * @see #getStateName |
| * @see Builder#setStateName |
| */ |
| private @StateName @NonNull String mStateName = STATE_NAME_UNDEFINED; |
| /** |
| * Fields annotated with {@link IntDef} annotations also get a proper {@link #toString()} value. |
| */ |
| private @RequestFlags int mFlags; |
| /** |
| * Above is true for both {@link IntDef#flag flags} and enum-like {@link IntDef}s |
| */ |
| private @State int mState = STATE_UNDEFINED; |
| |
| |
| /** |
| * Making a field public will suppress getter generation in favor of accessing it directly. |
| */ |
| public @NonNull CharSequence charSeq = ""; |
| /** |
| * Final fields suppress generating a setter (when setters are requested). |
| */ |
| private final @Nullable LinkAddress[] mLinkAddresses5; |
| /** |
| * Transient fields are completely ignored and can be used for caching. |
| */ |
| private transient LinkAddress[] mLinkAddresses6; |
| /** |
| * When using transient fields for caching it's often also a good idea to initialize them |
| * lazily. |
| * |
| * You can declare a special method like {@link #lazyInitTmpStorage()}, to let the |
| * {@link #getTmpStorage getter} lazily-initialize the value on demand. |
| */ |
| transient int[] mTmpStorage; |
| private int[] lazyInitTmpStorage() { |
| return new int[100]; |
| } |
| |
| /** |
| * Fields with certain annotations are automatically validated in constructor |
| * |
| * You can see overloads in {@link AnnotationValidations} for a list of currently |
| * supported ones. |
| * |
| * You can also extend support to your custom annotations by creating another corresponding |
| * overloads like |
| * {@link AnnotationValidations#validate(Class, UserIdInt, int)}. |
| * |
| * @see #SampleDataClass |
| */ |
| private @StringRes int mStringRes = 0; |
| /** |
| * Validation annotations may also have parameters. |
| * |
| * Parameter values will be supplied to validation method as name-value pairs. |
| * |
| * @see AnnotationValidations#validate(Class, Size, int, String, int, String, int) |
| */ |
| private @android.annotation.IntRange(from = 0, to = 6) int mDayOfWeek = 3; |
| /** |
| * Unnamed validation annotation parameter gets supplied to the validating method named as |
| * "value". |
| * |
| * Validation annotations following {@link Each} annotation, will be applied for each |
| * array/collection element instead. |
| * |
| * @see AnnotationValidations#validate(Class, Size, int, String, int) |
| */ |
| @Size(2) |
| @NonNull |
| @Each @FloatRange(from = 0f) |
| private float[] mCoords = new float[] {0f, 0f}; |
| |
| |
| /** |
| * Binder types are also supported |
| */ |
| private @NonNull IBinder mToken = new Binder(); |
| /** |
| * AIDL interface types are also supported |
| */ |
| private @Nullable ICompanionDeviceManager mIPCInterface = null; |
| |
| |
| /** |
| * Manually declaring any method that would otherwise be generated suppresses its generation, |
| * allowing for fine-grained overrides of the generated behavior. |
| */ |
| public LinkAddress[] getLinkAddresses4() { |
| //Suppress autogen |
| return null; |
| } |
| |
| /** |
| * Additionally, some methods like {@link #equals}, {@link #hashCode}, {@link #toString}, |
| * {@link #writeToParcel}, {@link Parcelable.Creator#createFromParcel} allow you to define |
| * special methods to override their behavior on a per-field basis. |
| * |
| * See the generateted methods' descriptions for the detailed instructions of what the method |
| * signatures for such methods are expected to be. |
| * |
| * Here we use this to "fix" {@link Pattern} not implementing equals/hashCode. |
| * |
| * @see #equals |
| * @see #hashCode |
| */ |
| private boolean patternEquals(Pattern other) { |
| return Objects.equals(mPattern.pattern(), other.pattern()); |
| } |
| private int patternHashCode() { |
| return Objects.hashCode(mPattern.pattern()); |
| } |
| |
| /** |
| * Similarly, {@link #onConstructed()}, if defined, gets called at the end of constructing an |
| * instance. |
| * |
| * At this point all fields should be in place, so this is the right place to put any custom |
| * validation logic. |
| */ |
| private void onConstructed() { |
| Preconditions.checkState(mNum2 == mNum4); |
| } |
| |
| /** |
| * {@link DataClass#genForEachField} can be used to generate a generic {@link #forEachField} |
| * utility, which can be used for various use-cases not covered out of the box. |
| * Callback passed to {@link #forEachField} will be called once per each property with its name |
| * and value. |
| * |
| * Here for example it's used to implement a typical dump method. |
| * |
| * Note that there are 2 {@link #forEachField} versions provided, one that treats each field |
| * value as an {@link Object}, thus boxing primitives if any, and one that additionally takes |
| * specialized callbacks for particular primitive field types used in given class. |
| * |
| * Some primitives like {@link Boolean}s and {@link Integer}s within [-128, 127] don't allocate |
| * when boxed, so it's up to you to decide which one to use for a given use-case. |
| */ |
| public void dump(PrintWriter pw) { |
| forEachField((self, name, value) -> { |
| pw.append(" ").append(name).append(": ").append(String.valueOf(value)).append('\n'); |
| }); |
| } |
| |
| |
| |
| // Code below generated by codegen v1.0.23. |
| // |
| // DO NOT MODIFY! |
| // CHECKSTYLE:OFF Generated code |
| // |
| // To regenerate run: |
| // $ codegen $ANDROID_BUILD_TOP/frameworks/base/tests/Codegen/src/com/android/codegentest/SampleDataClass.java |
| // |
| // To exclude the generated code from IntelliJ auto-formatting enable (one-time): |
| // Settings > Editor > Code Style > Formatter Control |
| //@formatter:off |
| |
| |
| @IntDef(prefix = "STATE_", value = { |
| STATE_ON, |
| STATE_OFF, |
| STATE_UNDEFINED |
| }) |
| @java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.SOURCE) |
| @DataClass.Generated.Member |
| public @interface State {} |
| |
| @DataClass.Generated.Member |
| public static String stateToString(@State int value) { |
| switch (value) { |
| case STATE_ON: |
| return "STATE_ON"; |
| case STATE_OFF: |
| return "STATE_OFF"; |
| case STATE_UNDEFINED: |
| return "STATE_UNDEFINED"; |
| default: return Integer.toHexString(value); |
| } |
| } |
| |
| @IntDef(flag = true, prefix = "FLAG_", value = { |
| FLAG_MANUAL_REQUEST, |
| FLAG_COMPATIBILITY_MODE_REQUEST, |
| FLAG_AUGMENTED_REQUEST |
| }) |
| @java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.SOURCE) |
| @DataClass.Generated.Member |
| public @interface RequestFlags {} |
| |
| @DataClass.Generated.Member |
| public static String requestFlagsToString(@RequestFlags int value) { |
| return com.android.internal.util.BitUtils.flagsToString( |
| value, SampleDataClass::singleRequestFlagsToString); |
| } |
| |
| @DataClass.Generated.Member |
| static String singleRequestFlagsToString(@RequestFlags int value) { |
| switch (value) { |
| case FLAG_MANUAL_REQUEST: |
| return "FLAG_MANUAL_REQUEST"; |
| case FLAG_COMPATIBILITY_MODE_REQUEST: |
| return "FLAG_COMPATIBILITY_MODE_REQUEST"; |
| case FLAG_AUGMENTED_REQUEST: |
| return "FLAG_AUGMENTED_REQUEST"; |
| default: return Integer.toHexString(value); |
| } |
| } |
| |
| @StringDef(prefix = "STATE_NAME_", value = { |
| STATE_NAME_UNDEFINED, |
| STATE_NAME_ON, |
| STATE_NAME_OFF |
| }) |
| @java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.SOURCE) |
| @DataClass.Generated.Member |
| public @interface StateName {} |
| |
| /** |
| * Creates a new SampleDataClass. |
| * |
| * @param num |
| * Any property javadoc should go onto the field, and will be copied where appropriate, |
| * including getters, constructor parameters, builder setters, etc. |
| * |
| * <p> |
| * This allows to avoid the burden of maintaining copies of the same documentation |
| * pieces in multiple places for each field. |
| * @param num2 |
| * Various javadoc features should work as expected when copied, e.g {@code code}, |
| * {@link #mName links}, <a href="https://google.com">html links</a>, etc. |
| * @param num4 |
| * {@code @hide} javadoc annotation is also propagated, which can be used to adjust the |
| * desired public API surface. |
| * @param name |
| * {@link Nullable} or {@link NonNull} annotation is required on all non-primitive fields. |
| * @param name2 |
| * Fields with default value expressions ("mFoo = ...") are optional, and are automatically |
| * initialized to the provided default expression, unless explicitly set. |
| * |
| * When using a {@link Builder} optional fields are passed via a {@link Builder#setName2 setter} |
| * while mandatory fields are passed via {@link Builder#Builder constructor}. |
| * @param name4 |
| * Alternatively, when default value computation is expensive, |
| * {@link #defaultName4 defaultFieldName()} can be defined to compute the default value. |
| * @param otherParcelable |
| * For parcelling, any field type supported by {@link Parcel} is supported out of the box. |
| * E.g. {@link Parcelable} subclasses, {@link String}, {@link int}, {@link boolean}, etc. |
| * @param date |
| * Additionally, support for parcelling other types can be added by implementing a |
| * {@link Parcelling}, and referencing it in the {@link DataClass.ParcelWith} field annotation. |
| * @param pattern |
| * If a {@link Parcelling} is fairly common, consider putting it in {@link Parcelling.BuiltIn} |
| * to encourage its reuse. |
| * @param linkAddresses2 |
| * For lists, when using a {@link Builder}, other than a regular |
| * {@link Builder#setLinkAddresses2(List) setter}, and additional |
| * {@link Builder#addLinkAddresses2(LinkAddress) add} method is generated for convenience. |
| * @param linkAddresses |
| * For aesthetics, you may want to consider providing a singular version of the plural field |
| * name, which would be used for the {@link #mLinkAddresses2 above mentioned} "add" method. |
| * @param linkAddresses4 |
| * For array fields, when using a {@link Builder}, vararg argument format is used for |
| * convenience. |
| * @param stateName |
| * {@link IntDef}/{@link StringDef}-annotated fields propagate the annotation to |
| * getter/constructor/setter/builder parameters, making for a nicer api. |
| * @param flags |
| * Fields annotated with {@link IntDef} annotations also get a proper {@link #toString()} value. |
| * @param state |
| * Above is true for both {@link IntDef#flag flags} and enum-like {@link IntDef}s |
| * @param charSeq |
| * Making a field public will suppress getter generation in favor of accessing it directly. |
| * @param linkAddresses5 |
| * Final fields suppress generating a setter (when setters are requested). |
| * @param stringRes |
| * Fields with certain annotations are automatically validated in constructor |
| * |
| * You can see overloads in {@link AnnotationValidations} for a list of currently |
| * supported ones. |
| * |
| * You can also extend support to your custom annotations by creating another corresponding |
| * overloads like |
| * {@link AnnotationValidations#validate(Class, UserIdInt, int)}. |
| * @param dayOfWeek |
| * Validation annotations may also have parameters. |
| * |
| * Parameter values will be supplied to validation method as name-value pairs. |
| * @param coords |
| * Unnamed validation annotation parameter gets supplied to the validating method named as |
| * "value". |
| * |
| * Validation annotations following {@link Each} annotation, will be applied for each |
| * array/collection element instead. |
| * @param token |
| * Binder types are also supported |
| * @param iPCInterface |
| * AIDL interface types are also supported |
| */ |
| @DataClass.Generated.Member |
| public SampleDataClass( |
| int num, |
| int num2, |
| int num4, |
| @Nullable String name, |
| @NonNull String name2, |
| @NonNull String name4, |
| @Nullable AccessibilityNodeInfo otherParcelable, |
| @NonNull Date date, |
| @NonNull Pattern pattern, |
| @NonNull List<LinkAddress> linkAddresses2, |
| @NonNull ArrayList<LinkAddress> linkAddresses, |
| @Nullable LinkAddress[] linkAddresses4, |
| @StateName @NonNull String stateName, |
| @RequestFlags int flags, |
| @State int state, |
| @NonNull CharSequence charSeq, |
| @Nullable LinkAddress[] linkAddresses5, |
| @StringRes int stringRes, |
| @android.annotation.IntRange(from = 0, to = 6) int dayOfWeek, |
| @Size(2) @NonNull @FloatRange(from = 0f) float[] coords, |
| @NonNull IBinder token, |
| @Nullable ICompanionDeviceManager iPCInterface) { |
| this.mNum = num; |
| this.mNum2 = num2; |
| this.mNum4 = num4; |
| this.mName = name; |
| this.mName2 = name2; |
| AnnotationValidations.validate( |
| NonNull.class, null, mName2); |
| this.mName4 = name4; |
| AnnotationValidations.validate( |
| NonNull.class, null, mName4); |
| this.mOtherParcelable = otherParcelable; |
| this.mDate = date; |
| AnnotationValidations.validate( |
| NonNull.class, null, mDate); |
| this.mPattern = pattern; |
| AnnotationValidations.validate( |
| NonNull.class, null, mPattern); |
| this.mLinkAddresses2 = linkAddresses2; |
| AnnotationValidations.validate( |
| NonNull.class, null, mLinkAddresses2); |
| this.mLinkAddresses = linkAddresses; |
| AnnotationValidations.validate( |
| NonNull.class, null, mLinkAddresses); |
| this.mLinkAddresses4 = linkAddresses4; |
| this.mStateName = stateName; |
| |
| if (!(Objects.equals(mStateName, STATE_NAME_UNDEFINED)) |
| && !(Objects.equals(mStateName, STATE_NAME_ON)) |
| && !(Objects.equals(mStateName, STATE_NAME_OFF))) { |
| throw new java.lang.IllegalArgumentException( |
| "stateName was " + mStateName + " but must be one of: " |
| + "STATE_NAME_UNDEFINED(" + STATE_NAME_UNDEFINED + "), " |
| + "STATE_NAME_ON(" + STATE_NAME_ON + "), " |
| + "STATE_NAME_OFF(" + STATE_NAME_OFF + ")"); |
| } |
| |
| AnnotationValidations.validate( |
| NonNull.class, null, mStateName); |
| this.mFlags = flags; |
| |
| Preconditions.checkFlagsArgument( |
| mFlags, |
| FLAG_MANUAL_REQUEST |
| | FLAG_COMPATIBILITY_MODE_REQUEST |
| | FLAG_AUGMENTED_REQUEST); |
| this.mState = state; |
| |
| if (!(mState == STATE_ON) |
| && !(mState == STATE_OFF) |
| && !(mState == STATE_UNDEFINED)) { |
| throw new java.lang.IllegalArgumentException( |
| "state was " + mState + " but must be one of: " |
| + "STATE_ON(" + STATE_ON + "), " |
| + "STATE_OFF(" + STATE_OFF + "), " |
| + "STATE_UNDEFINED(" + STATE_UNDEFINED + ")"); |
| } |
| |
| this.charSeq = charSeq; |
| AnnotationValidations.validate( |
| NonNull.class, null, charSeq); |
| this.mLinkAddresses5 = linkAddresses5; |
| this.mStringRes = stringRes; |
| AnnotationValidations.validate( |
| StringRes.class, null, mStringRes); |
| this.mDayOfWeek = dayOfWeek; |
| AnnotationValidations.validate( |
| android.annotation.IntRange.class, null, mDayOfWeek, |
| "from", 0, |
| "to", 6); |
| this.mCoords = coords; |
| AnnotationValidations.validate( |
| Size.class, null, mCoords.length, |
| "value", 2); |
| AnnotationValidations.validate( |
| NonNull.class, null, mCoords); |
| int coordsSize = mCoords.length; |
| for (int i = 0; i < coordsSize; i++) { |
| AnnotationValidations.validate( |
| FloatRange.class, null, mCoords[i], |
| "from", 0f); |
| } |
| |
| this.mToken = token; |
| AnnotationValidations.validate( |
| NonNull.class, null, mToken); |
| this.mIPCInterface = iPCInterface; |
| |
| onConstructed(); |
| } |
| |
| /** |
| * Any property javadoc should go onto the field, and will be copied where appropriate, |
| * including getters, constructor parameters, builder setters, etc. |
| * |
| * <p> |
| * This allows to avoid the burden of maintaining copies of the same documentation |
| * pieces in multiple places for each field. |
| */ |
| @DataClass.Generated.Member |
| public int getNum() { |
| return mNum; |
| } |
| |
| /** |
| * Various javadoc features should work as expected when copied, e.g {@code code}, |
| * {@link #mName links}, <a href="https://google.com">html links</a>, etc. |
| * |
| * @see #mNum2 ..and so should blocks at the bottom, e.g. {@code @see} blocks. |
| */ |
| @DataClass.Generated.Member |
| public int getNum2() { |
| return mNum2; |
| } |
| |
| /** |
| * {@code @hide} javadoc annotation is also propagated, which can be used to adjust the |
| * desired public API surface. |
| * |
| * @see #getNum4() is hidden |
| * @see Builder#setNum4(int) also hidden |
| * @hide |
| */ |
| @DataClass.Generated.Member |
| public int getNum4() { |
| return mNum4; |
| } |
| |
| /** |
| * {@link Nullable} or {@link NonNull} annotation is required on all non-primitive fields. |
| */ |
| @DataClass.Generated.Member |
| public @Nullable String getName() { |
| return mName; |
| } |
| |
| /** |
| * Fields with default value expressions ("mFoo = ...") are optional, and are automatically |
| * initialized to the provided default expression, unless explicitly set. |
| * |
| * When using a {@link Builder} optional fields are passed via a {@link Builder#setName2 setter} |
| * while mandatory fields are passed via {@link Builder#Builder constructor}. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull String getName2() { |
| return mName2; |
| } |
| |
| /** |
| * Alternatively, when default value computation is expensive, |
| * {@link #defaultName4 defaultFieldName()} can be defined to compute the default value. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull String getName4() { |
| return mName4; |
| } |
| |
| /** |
| * For parcelling, any field type supported by {@link Parcel} is supported out of the box. |
| * E.g. {@link Parcelable} subclasses, {@link String}, {@link int}, {@link boolean}, etc. |
| */ |
| @DataClass.Generated.Member |
| public @Nullable AccessibilityNodeInfo getOtherParcelable() { |
| return mOtherParcelable; |
| } |
| |
| /** |
| * Additionally, support for parcelling other types can be added by implementing a |
| * {@link Parcelling}, and referencing it in the {@link DataClass.ParcelWith} field annotation. |
| * |
| * @see MyDateParcelling an example {@link Parcelling} implementation |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Date getDate() { |
| return mDate; |
| } |
| |
| /** |
| * If a {@link Parcelling} is fairly common, consider putting it in {@link Parcelling.BuiltIn} |
| * to encourage its reuse. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Pattern getPattern() { |
| return mPattern; |
| } |
| |
| /** |
| * For lists, when using a {@link Builder}, other than a regular |
| * {@link Builder#setLinkAddresses2(List) setter}, and additional |
| * {@link Builder#addLinkAddresses2(LinkAddress) add} method is generated for convenience. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull List<LinkAddress> getLinkAddresses2() { |
| return mLinkAddresses2; |
| } |
| |
| /** |
| * For aesthetics, you may want to consider providing a singular version of the plural field |
| * name, which would be used for the {@link #mLinkAddresses2 above mentioned} "add" method. |
| * |
| * @see Builder#addLinkAddress(LinkAddress) |
| */ |
| @DataClass.Generated.Member |
| public @NonNull ArrayList<LinkAddress> getLinkAddresses() { |
| return mLinkAddresses; |
| } |
| |
| /** |
| * {@link IntDef}/{@link StringDef}-annotated fields propagate the annotation to |
| * getter/constructor/setter/builder parameters, making for a nicer api. |
| * |
| * @see #getStateName |
| * @see Builder#setStateName |
| */ |
| @DataClass.Generated.Member |
| public @StateName @NonNull String getStateName() { |
| return mStateName; |
| } |
| |
| /** |
| * Fields annotated with {@link IntDef} annotations also get a proper {@link #toString()} value. |
| */ |
| @DataClass.Generated.Member |
| public @RequestFlags int getFlags() { |
| return mFlags; |
| } |
| |
| /** |
| * Above is true for both {@link IntDef#flag flags} and enum-like {@link IntDef}s |
| */ |
| @DataClass.Generated.Member |
| public @State int getState() { |
| return mState; |
| } |
| |
| /** |
| * Final fields suppress generating a setter (when setters are requested). |
| */ |
| @DataClass.Generated.Member |
| public @Nullable LinkAddress[] getLinkAddresses5() { |
| return mLinkAddresses5; |
| } |
| |
| /** |
| * Fields with certain annotations are automatically validated in constructor |
| * |
| * You can see overloads in {@link AnnotationValidations} for a list of currently |
| * supported ones. |
| * |
| * You can also extend support to your custom annotations by creating another corresponding |
| * overloads like |
| * {@link AnnotationValidations#validate(Class, UserIdInt, int)}. |
| * |
| * @see #SampleDataClass |
| */ |
| @DataClass.Generated.Member |
| public @StringRes int getStringRes() { |
| return mStringRes; |
| } |
| |
| /** |
| * Validation annotations may also have parameters. |
| * |
| * Parameter values will be supplied to validation method as name-value pairs. |
| * |
| * @see AnnotationValidations#validate(Class, Size, int, String, int, String, int) |
| */ |
| @DataClass.Generated.Member |
| public @android.annotation.IntRange(from = 0, to = 6) int getDayOfWeek() { |
| return mDayOfWeek; |
| } |
| |
| /** |
| * Unnamed validation annotation parameter gets supplied to the validating method named as |
| * "value". |
| * |
| * Validation annotations following {@link Each} annotation, will be applied for each |
| * array/collection element instead. |
| * |
| * @see AnnotationValidations#validate(Class, Size, int, String, int) |
| */ |
| @DataClass.Generated.Member |
| public @Size(2) @NonNull @FloatRange(from = 0f) float[] getCoords() { |
| return mCoords; |
| } |
| |
| /** |
| * Binder types are also supported |
| */ |
| @DataClass.Generated.Member |
| public @NonNull IBinder getToken() { |
| return mToken; |
| } |
| |
| /** |
| * AIDL interface types are also supported |
| */ |
| @DataClass.Generated.Member |
| public @Nullable ICompanionDeviceManager getIPCInterface() { |
| return mIPCInterface; |
| } |
| |
| /** |
| * When using transient fields for caching it's often also a good idea to initialize them |
| * lazily. |
| * |
| * You can declare a special method like {@link #lazyInitTmpStorage()}, to let the |
| * {@link #getTmpStorage getter} lazily-initialize the value on demand. |
| */ |
| @DataClass.Generated.Member |
| public int[] getTmpStorage() { |
| int[] tmpStorage = mTmpStorage; |
| if (tmpStorage == null) { |
| // You can mark field as volatile for thread-safe double-check init |
| tmpStorage = mTmpStorage = lazyInitTmpStorage(); |
| } |
| return tmpStorage; |
| } |
| |
| /** |
| * Any property javadoc should go onto the field, and will be copied where appropriate, |
| * including getters, constructor parameters, builder setters, etc. |
| * |
| * <p> |
| * This allows to avoid the burden of maintaining copies of the same documentation |
| * pieces in multiple places for each field. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull SampleDataClass setNum( int value) { |
| mNum = value; |
| return this; |
| } |
| |
| /** |
| * Various javadoc features should work as expected when copied, e.g {@code code}, |
| * {@link #mName links}, <a href="https://google.com">html links</a>, etc. |
| * |
| * @see #mNum2 ..and so should blocks at the bottom, e.g. {@code @see} blocks. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull SampleDataClass setNum2( int value) { |
| mNum2 = value; |
| return this; |
| } |
| |
| /** |
| * {@code @hide} javadoc annotation is also propagated, which can be used to adjust the |
| * desired public API surface. |
| * |
| * @see #getNum4() is hidden |
| * @see Builder#setNum4(int) also hidden |
| * @hide |
| */ |
| @DataClass.Generated.Member |
| public @NonNull SampleDataClass setNum4( int value) { |
| mNum4 = value; |
| return this; |
| } |
| |
| /** |
| * {@link Nullable} or {@link NonNull} annotation is required on all non-primitive fields. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull SampleDataClass setName(@NonNull String value) { |
| mName = value; |
| return this; |
| } |
| |
| /** |
| * Fields with default value expressions ("mFoo = ...") are optional, and are automatically |
| * initialized to the provided default expression, unless explicitly set. |
| * |
| * When using a {@link Builder} optional fields are passed via a {@link Builder#setName2 setter} |
| * while mandatory fields are passed via {@link Builder#Builder constructor}. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull SampleDataClass setName2(@NonNull String value) { |
| mName2 = value; |
| AnnotationValidations.validate( |
| NonNull.class, null, mName2); |
| return this; |
| } |
| |
| /** |
| * Alternatively, when default value computation is expensive, |
| * {@link #defaultName4 defaultFieldName()} can be defined to compute the default value. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull SampleDataClass setName4(@NonNull String value) { |
| mName4 = value; |
| AnnotationValidations.validate( |
| NonNull.class, null, mName4); |
| return this; |
| } |
| |
| /** |
| * For parcelling, any field type supported by {@link Parcel} is supported out of the box. |
| * E.g. {@link Parcelable} subclasses, {@link String}, {@link int}, {@link boolean}, etc. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull SampleDataClass setOtherParcelable(@NonNull AccessibilityNodeInfo value) { |
| mOtherParcelable = value; |
| return this; |
| } |
| |
| /** |
| * Additionally, support for parcelling other types can be added by implementing a |
| * {@link Parcelling}, and referencing it in the {@link DataClass.ParcelWith} field annotation. |
| * |
| * @see MyDateParcelling an example {@link Parcelling} implementation |
| */ |
| @DataClass.Generated.Member |
| public @NonNull SampleDataClass setDate(@NonNull Date value) { |
| mDate = value; |
| AnnotationValidations.validate( |
| NonNull.class, null, mDate); |
| return this; |
| } |
| |
| /** |
| * If a {@link Parcelling} is fairly common, consider putting it in {@link Parcelling.BuiltIn} |
| * to encourage its reuse. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull SampleDataClass setPattern(@NonNull Pattern value) { |
| mPattern = value; |
| AnnotationValidations.validate( |
| NonNull.class, null, mPattern); |
| return this; |
| } |
| |
| /** |
| * For lists, when using a {@link Builder}, other than a regular |
| * {@link Builder#setLinkAddresses2(List) setter}, and additional |
| * {@link Builder#addLinkAddresses2(LinkAddress) add} method is generated for convenience. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull SampleDataClass setLinkAddresses2(@NonNull List<LinkAddress> value) { |
| mLinkAddresses2 = value; |
| AnnotationValidations.validate( |
| NonNull.class, null, mLinkAddresses2); |
| return this; |
| } |
| |
| /** |
| * For aesthetics, you may want to consider providing a singular version of the plural field |
| * name, which would be used for the {@link #mLinkAddresses2 above mentioned} "add" method. |
| * |
| * @see Builder#addLinkAddress(LinkAddress) |
| */ |
| @DataClass.Generated.Member |
| public @NonNull SampleDataClass setLinkAddresses(@NonNull ArrayList<LinkAddress> value) { |
| mLinkAddresses = value; |
| AnnotationValidations.validate( |
| NonNull.class, null, mLinkAddresses); |
| return this; |
| } |
| |
| /** |
| * For array fields, when using a {@link Builder}, vararg argument format is used for |
| * convenience. |
| * |
| * @see Builder#setLinkAddresses4(LinkAddress...) |
| */ |
| @DataClass.Generated.Member |
| public @NonNull SampleDataClass setLinkAddresses4(@NonNull LinkAddress... value) { |
| mLinkAddresses4 = value; |
| return this; |
| } |
| |
| /** |
| * {@link IntDef}/{@link StringDef}-annotated fields propagate the annotation to |
| * getter/constructor/setter/builder parameters, making for a nicer api. |
| * |
| * @see #getStateName |
| * @see Builder#setStateName |
| */ |
| @DataClass.Generated.Member |
| public @NonNull SampleDataClass setStateName(@StateName @NonNull String value) { |
| mStateName = value; |
| |
| if (!(Objects.equals(mStateName, STATE_NAME_UNDEFINED)) |
| && !(Objects.equals(mStateName, STATE_NAME_ON)) |
| && !(Objects.equals(mStateName, STATE_NAME_OFF))) { |
| throw new java.lang.IllegalArgumentException( |
| "stateName was " + mStateName + " but must be one of: " |
| + "STATE_NAME_UNDEFINED(" + STATE_NAME_UNDEFINED + "), " |
| + "STATE_NAME_ON(" + STATE_NAME_ON + "), " |
| + "STATE_NAME_OFF(" + STATE_NAME_OFF + ")"); |
| } |
| |
| AnnotationValidations.validate( |
| NonNull.class, null, mStateName); |
| return this; |
| } |
| |
| /** |
| * Fields annotated with {@link IntDef} annotations also get a proper {@link #toString()} value. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull SampleDataClass setFlags(@RequestFlags int value) { |
| mFlags = value; |
| |
| Preconditions.checkFlagsArgument( |
| mFlags, |
| FLAG_MANUAL_REQUEST |
| | FLAG_COMPATIBILITY_MODE_REQUEST |
| | FLAG_AUGMENTED_REQUEST); |
| return this; |
| } |
| |
| /** |
| * Above is true for both {@link IntDef#flag flags} and enum-like {@link IntDef}s |
| */ |
| @DataClass.Generated.Member |
| public @NonNull SampleDataClass setState(@State int value) { |
| mState = value; |
| |
| if (!(mState == STATE_ON) |
| && !(mState == STATE_OFF) |
| && !(mState == STATE_UNDEFINED)) { |
| throw new java.lang.IllegalArgumentException( |
| "state was " + mState + " but must be one of: " |
| + "STATE_ON(" + STATE_ON + "), " |
| + "STATE_OFF(" + STATE_OFF + "), " |
| + "STATE_UNDEFINED(" + STATE_UNDEFINED + ")"); |
| } |
| |
| return this; |
| } |
| |
| /** |
| * Fields with certain annotations are automatically validated in constructor |
| * |
| * You can see overloads in {@link AnnotationValidations} for a list of currently |
| * supported ones. |
| * |
| * You can also extend support to your custom annotations by creating another corresponding |
| * overloads like |
| * {@link AnnotationValidations#validate(Class, UserIdInt, int)}. |
| * |
| * @see #SampleDataClass |
| */ |
| @DataClass.Generated.Member |
| public @NonNull SampleDataClass setStringRes(@StringRes int value) { |
| mStringRes = value; |
| AnnotationValidations.validate( |
| StringRes.class, null, mStringRes); |
| return this; |
| } |
| |
| /** |
| * Validation annotations may also have parameters. |
| * |
| * Parameter values will be supplied to validation method as name-value pairs. |
| * |
| * @see AnnotationValidations#validate(Class, Size, int, String, int, String, int) |
| */ |
| @DataClass.Generated.Member |
| public @NonNull SampleDataClass setDayOfWeek(@android.annotation.IntRange(from = 0, to = 6) int value) { |
| mDayOfWeek = value; |
| AnnotationValidations.validate( |
| android.annotation.IntRange.class, null, mDayOfWeek, |
| "from", 0, |
| "to", 6); |
| return this; |
| } |
| |
| /** |
| * Unnamed validation annotation parameter gets supplied to the validating method named as |
| * "value". |
| * |
| * Validation annotations following {@link Each} annotation, will be applied for each |
| * array/collection element instead. |
| * |
| * @see AnnotationValidations#validate(Class, Size, int, String, int) |
| */ |
| @DataClass.Generated.Member |
| public @NonNull SampleDataClass setCoords(@Size(2) @NonNull @FloatRange(from = 0f) float... value) { |
| mCoords = value; |
| AnnotationValidations.validate( |
| Size.class, null, mCoords.length, |
| "value", 2); |
| AnnotationValidations.validate( |
| NonNull.class, null, mCoords); |
| int coordsSize = mCoords.length; |
| for (int i = 0; i < coordsSize; i++) { |
| AnnotationValidations.validate( |
| FloatRange.class, null, mCoords[i], |
| "from", 0f); |
| } |
| |
| return this; |
| } |
| |
| /** |
| * Binder types are also supported |
| */ |
| @DataClass.Generated.Member |
| public @NonNull SampleDataClass setToken(@NonNull IBinder value) { |
| mToken = value; |
| AnnotationValidations.validate( |
| NonNull.class, null, mToken); |
| return this; |
| } |
| |
| /** |
| * AIDL interface types are also supported |
| */ |
| @DataClass.Generated.Member |
| public @NonNull SampleDataClass setIPCInterface(@NonNull ICompanionDeviceManager value) { |
| mIPCInterface = value; |
| return this; |
| } |
| |
| @Override |
| @DataClass.Generated.Member |
| public String toString() { |
| // You can override field toString logic by defining methods like: |
| // String fieldNameToString() { ... } |
| |
| return "SampleDataClass { " + |
| "num = " + mNum + ", " + |
| "num2 = " + mNum2 + ", " + |
| "num4 = " + mNum4 + ", " + |
| "name = " + mName + ", " + |
| "name2 = " + mName2 + ", " + |
| "name4 = " + mName4 + ", " + |
| "otherParcelable = " + mOtherParcelable + ", " + |
| "date = " + mDate + ", " + |
| "pattern = " + mPattern + ", " + |
| "linkAddresses2 = " + mLinkAddresses2 + ", " + |
| "linkAddresses = " + mLinkAddresses + ", " + |
| "linkAddresses4 = " + java.util.Arrays.toString(mLinkAddresses4) + ", " + |
| "stateName = " + mStateName + ", " + |
| "flags = " + requestFlagsToString(mFlags) + ", " + |
| "state = " + stateToString(mState) + ", " + |
| "charSeq = " + charSeq + ", " + |
| "linkAddresses5 = " + java.util.Arrays.toString(mLinkAddresses5) + ", " + |
| "stringRes = " + mStringRes + ", " + |
| "dayOfWeek = " + mDayOfWeek + ", " + |
| "coords = " + java.util.Arrays.toString(mCoords) + ", " + |
| "token = " + mToken + ", " + |
| "iPCInterface = " + mIPCInterface + |
| " }"; |
| } |
| |
| @Override |
| @DataClass.Generated.Member |
| public boolean equals(@Nullable Object o) { |
| // You can override field equality logic by defining either of the methods like: |
| // boolean fieldNameEquals(SampleDataClass other) { ... } |
| // boolean fieldNameEquals(FieldType otherValue) { ... } |
| |
| if (this == o) return true; |
| if (o == null || getClass() != o.getClass()) return false; |
| @SuppressWarnings("unchecked") |
| SampleDataClass that = (SampleDataClass) o; |
| //noinspection PointlessBooleanExpression |
| return true |
| && mNum == that.mNum |
| && mNum2 == that.mNum2 |
| && mNum4 == that.mNum4 |
| && Objects.equals(mName, that.mName) |
| && Objects.equals(mName2, that.mName2) |
| && Objects.equals(mName4, that.mName4) |
| && Objects.equals(mOtherParcelable, that.mOtherParcelable) |
| && Objects.equals(mDate, that.mDate) |
| && patternEquals(that.mPattern) |
| && Objects.equals(mLinkAddresses2, that.mLinkAddresses2) |
| && Objects.equals(mLinkAddresses, that.mLinkAddresses) |
| && java.util.Arrays.equals(mLinkAddresses4, that.mLinkAddresses4) |
| && Objects.equals(mStateName, that.mStateName) |
| && mFlags == that.mFlags |
| && mState == that.mState |
| && Objects.equals(charSeq, that.charSeq) |
| && java.util.Arrays.equals(mLinkAddresses5, that.mLinkAddresses5) |
| && mStringRes == that.mStringRes |
| && mDayOfWeek == that.mDayOfWeek |
| && java.util.Arrays.equals(mCoords, that.mCoords) |
| && Objects.equals(mToken, that.mToken) |
| && Objects.equals(mIPCInterface, that.mIPCInterface); |
| } |
| |
| @Override |
| @DataClass.Generated.Member |
| public int hashCode() { |
| // You can override field hashCode logic by defining methods like: |
| // int fieldNameHashCode() { ... } |
| |
| int _hash = 1; |
| _hash = 31 * _hash + mNum; |
| _hash = 31 * _hash + mNum2; |
| _hash = 31 * _hash + mNum4; |
| _hash = 31 * _hash + Objects.hashCode(mName); |
| _hash = 31 * _hash + Objects.hashCode(mName2); |
| _hash = 31 * _hash + Objects.hashCode(mName4); |
| _hash = 31 * _hash + Objects.hashCode(mOtherParcelable); |
| _hash = 31 * _hash + Objects.hashCode(mDate); |
| _hash = 31 * _hash + patternHashCode(); |
| _hash = 31 * _hash + Objects.hashCode(mLinkAddresses2); |
| _hash = 31 * _hash + Objects.hashCode(mLinkAddresses); |
| _hash = 31 * _hash + java.util.Arrays.hashCode(mLinkAddresses4); |
| _hash = 31 * _hash + Objects.hashCode(mStateName); |
| _hash = 31 * _hash + mFlags; |
| _hash = 31 * _hash + mState; |
| _hash = 31 * _hash + Objects.hashCode(charSeq); |
| _hash = 31 * _hash + java.util.Arrays.hashCode(mLinkAddresses5); |
| _hash = 31 * _hash + mStringRes; |
| _hash = 31 * _hash + mDayOfWeek; |
| _hash = 31 * _hash + java.util.Arrays.hashCode(mCoords); |
| _hash = 31 * _hash + Objects.hashCode(mToken); |
| _hash = 31 * _hash + Objects.hashCode(mIPCInterface); |
| return _hash; |
| } |
| |
| @DataClass.Generated.Member |
| void forEachField( |
| @NonNull DataClass.PerIntFieldAction<SampleDataClass> actionInt, |
| @NonNull DataClass.PerObjectFieldAction<SampleDataClass> actionObject) { |
| actionInt.acceptInt(this, "num", mNum); |
| actionInt.acceptInt(this, "num2", mNum2); |
| actionInt.acceptInt(this, "num4", mNum4); |
| actionObject.acceptObject(this, "name", mName); |
| actionObject.acceptObject(this, "name2", mName2); |
| actionObject.acceptObject(this, "name4", mName4); |
| actionObject.acceptObject(this, "otherParcelable", mOtherParcelable); |
| actionObject.acceptObject(this, "date", mDate); |
| actionObject.acceptObject(this, "pattern", mPattern); |
| actionObject.acceptObject(this, "linkAddresses2", mLinkAddresses2); |
| actionObject.acceptObject(this, "linkAddresses", mLinkAddresses); |
| actionObject.acceptObject(this, "linkAddresses4", mLinkAddresses4); |
| actionObject.acceptObject(this, "stateName", mStateName); |
| actionInt.acceptInt(this, "flags", mFlags); |
| actionInt.acceptInt(this, "state", mState); |
| actionObject.acceptObject(this, "charSeq", charSeq); |
| actionObject.acceptObject(this, "linkAddresses5", mLinkAddresses5); |
| actionInt.acceptInt(this, "stringRes", mStringRes); |
| actionInt.acceptInt(this, "dayOfWeek", mDayOfWeek); |
| actionObject.acceptObject(this, "coords", mCoords); |
| actionObject.acceptObject(this, "token", mToken); |
| actionObject.acceptObject(this, "iPCInterface", mIPCInterface); |
| } |
| |
| /** @deprecated May cause boxing allocations - use with caution! */ |
| @Deprecated |
| @DataClass.Generated.Member |
| void forEachField(@NonNull DataClass.PerObjectFieldAction<SampleDataClass> action) { |
| action.acceptObject(this, "num", mNum); |
| action.acceptObject(this, "num2", mNum2); |
| action.acceptObject(this, "num4", mNum4); |
| action.acceptObject(this, "name", mName); |
| action.acceptObject(this, "name2", mName2); |
| action.acceptObject(this, "name4", mName4); |
| action.acceptObject(this, "otherParcelable", mOtherParcelable); |
| action.acceptObject(this, "date", mDate); |
| action.acceptObject(this, "pattern", mPattern); |
| action.acceptObject(this, "linkAddresses2", mLinkAddresses2); |
| action.acceptObject(this, "linkAddresses", mLinkAddresses); |
| action.acceptObject(this, "linkAddresses4", mLinkAddresses4); |
| action.acceptObject(this, "stateName", mStateName); |
| action.acceptObject(this, "flags", mFlags); |
| action.acceptObject(this, "state", mState); |
| action.acceptObject(this, "charSeq", charSeq); |
| action.acceptObject(this, "linkAddresses5", mLinkAddresses5); |
| action.acceptObject(this, "stringRes", mStringRes); |
| action.acceptObject(this, "dayOfWeek", mDayOfWeek); |
| action.acceptObject(this, "coords", mCoords); |
| action.acceptObject(this, "token", mToken); |
| action.acceptObject(this, "iPCInterface", mIPCInterface); |
| } |
| |
| @DataClass.Generated.Member |
| static Parcelling<Date> sParcellingForDate = |
| Parcelling.Cache.get( |
| MyDateParcelling.class); |
| static { |
| if (sParcellingForDate == null) { |
| sParcellingForDate = Parcelling.Cache.put( |
| new MyDateParcelling()); |
| } |
| } |
| |
| @DataClass.Generated.Member |
| static Parcelling<Pattern> sParcellingForPattern = |
| Parcelling.Cache.get( |
| Parcelling.BuiltIn.ForPattern.class); |
| static { |
| if (sParcellingForPattern == null) { |
| sParcellingForPattern = Parcelling.Cache.put( |
| new Parcelling.BuiltIn.ForPattern()); |
| } |
| } |
| |
| @Override |
| @DataClass.Generated.Member |
| public void writeToParcel(@NonNull Parcel dest, int flags) { |
| // You can override field parcelling by defining methods like: |
| // void parcelFieldName(Parcel dest, int flags) { ... } |
| |
| long flg = 0; |
| if (mName != null) flg |= 0x8; |
| if (mOtherParcelable != null) flg |= 0x40; |
| if (mLinkAddresses4 != null) flg |= 0x800; |
| if (mLinkAddresses5 != null) flg |= 0x10000; |
| if (mIPCInterface != null) flg |= 0x200000; |
| dest.writeLong(flg); |
| dest.writeInt(mNum); |
| dest.writeInt(mNum2); |
| dest.writeInt(mNum4); |
| if (mName != null) dest.writeString(mName); |
| dest.writeString(mName2); |
| dest.writeString(mName4); |
| if (mOtherParcelable != null) dest.writeTypedObject(mOtherParcelable, flags); |
| sParcellingForDate.parcel(mDate, dest, flags); |
| sParcellingForPattern.parcel(mPattern, dest, flags); |
| dest.writeParcelableList(mLinkAddresses2, flags); |
| dest.writeParcelableList(mLinkAddresses, flags); |
| if (mLinkAddresses4 != null) dest.writeTypedArray(mLinkAddresses4, flags); |
| dest.writeString(mStateName); |
| dest.writeInt(mFlags); |
| dest.writeInt(mState); |
| dest.writeCharSequence(charSeq); |
| if (mLinkAddresses5 != null) dest.writeTypedArray(mLinkAddresses5, flags); |
| dest.writeInt(mStringRes); |
| dest.writeInt(mDayOfWeek); |
| dest.writeFloatArray(mCoords); |
| dest.writeStrongBinder(mToken); |
| if (mIPCInterface != null) dest.writeStrongInterface(mIPCInterface); |
| } |
| |
| @Override |
| @DataClass.Generated.Member |
| public int describeContents() { return 0; } |
| |
| /** @hide */ |
| @SuppressWarnings({"unchecked", "RedundantCast"}) |
| @DataClass.Generated.Member |
| /* package-private */ SampleDataClass(@NonNull Parcel in) { |
| // You can override field unparcelling by defining methods like: |
| // static FieldType unparcelFieldName(Parcel in) { ... } |
| |
| long flg = in.readLong(); |
| int num = in.readInt(); |
| int num2 = in.readInt(); |
| int num4 = in.readInt(); |
| String name = (flg & 0x8) == 0 ? null : in.readString(); |
| String name2 = in.readString(); |
| String name4 = in.readString(); |
| AccessibilityNodeInfo otherParcelable = (flg & 0x40) == 0 ? null : (AccessibilityNodeInfo) in.readTypedObject(AccessibilityNodeInfo.CREATOR); |
| Date date = sParcellingForDate.unparcel(in); |
| Pattern pattern = sParcellingForPattern.unparcel(in); |
| List<LinkAddress> linkAddresses2 = new ArrayList<>(); |
| in.readParcelableList(linkAddresses2, LinkAddress.class.getClassLoader()); |
| ArrayList<LinkAddress> linkAddresses = new ArrayList<>(); |
| in.readParcelableList(linkAddresses, LinkAddress.class.getClassLoader()); |
| LinkAddress[] linkAddresses4 = (flg & 0x800) == 0 ? null : (LinkAddress[]) in.createTypedArray(LinkAddress.CREATOR); |
| String stateName = in.readString(); |
| int flags = in.readInt(); |
| int state = in.readInt(); |
| CharSequence _charSeq = (CharSequence) in.readCharSequence(); |
| LinkAddress[] linkAddresses5 = (flg & 0x10000) == 0 ? null : (LinkAddress[]) in.createTypedArray(LinkAddress.CREATOR); |
| int stringRes = in.readInt(); |
| int dayOfWeek = in.readInt(); |
| float[] coords = in.createFloatArray(); |
| IBinder token = (IBinder) in.readStrongBinder(); |
| ICompanionDeviceManager iPCInterface = (flg & 0x200000) == 0 ? null : ICompanionDeviceManager.Stub.asInterface(in.readStrongBinder()); |
| |
| this.mNum = num; |
| this.mNum2 = num2; |
| this.mNum4 = num4; |
| this.mName = name; |
| this.mName2 = name2; |
| AnnotationValidations.validate( |
| NonNull.class, null, mName2); |
| this.mName4 = name4; |
| AnnotationValidations.validate( |
| NonNull.class, null, mName4); |
| this.mOtherParcelable = otherParcelable; |
| this.mDate = date; |
| AnnotationValidations.validate( |
| NonNull.class, null, mDate); |
| this.mPattern = pattern; |
| AnnotationValidations.validate( |
| NonNull.class, null, mPattern); |
| this.mLinkAddresses2 = linkAddresses2; |
| AnnotationValidations.validate( |
| NonNull.class, null, mLinkAddresses2); |
| this.mLinkAddresses = linkAddresses; |
| AnnotationValidations.validate( |
| NonNull.class, null, mLinkAddresses); |
| this.mLinkAddresses4 = linkAddresses4; |
| this.mStateName = stateName; |
| |
| if (!(Objects.equals(mStateName, STATE_NAME_UNDEFINED)) |
| && !(Objects.equals(mStateName, STATE_NAME_ON)) |
| && !(Objects.equals(mStateName, STATE_NAME_OFF))) { |
| throw new java.lang.IllegalArgumentException( |
| "stateName was " + mStateName + " but must be one of: " |
| + "STATE_NAME_UNDEFINED(" + STATE_NAME_UNDEFINED + "), " |
| + "STATE_NAME_ON(" + STATE_NAME_ON + "), " |
| + "STATE_NAME_OFF(" + STATE_NAME_OFF + ")"); |
| } |
| |
| AnnotationValidations.validate( |
| NonNull.class, null, mStateName); |
| this.mFlags = flags; |
| |
| Preconditions.checkFlagsArgument( |
| mFlags, |
| FLAG_MANUAL_REQUEST |
| | FLAG_COMPATIBILITY_MODE_REQUEST |
| | FLAG_AUGMENTED_REQUEST); |
| this.mState = state; |
| |
| if (!(mState == STATE_ON) |
| && !(mState == STATE_OFF) |
| && !(mState == STATE_UNDEFINED)) { |
| throw new java.lang.IllegalArgumentException( |
| "state was " + mState + " but must be one of: " |
| + "STATE_ON(" + STATE_ON + "), " |
| + "STATE_OFF(" + STATE_OFF + "), " |
| + "STATE_UNDEFINED(" + STATE_UNDEFINED + ")"); |
| } |
| |
| this.charSeq = _charSeq; |
| AnnotationValidations.validate( |
| NonNull.class, null, charSeq); |
| this.mLinkAddresses5 = linkAddresses5; |
| this.mStringRes = stringRes; |
| AnnotationValidations.validate( |
| StringRes.class, null, mStringRes); |
| this.mDayOfWeek = dayOfWeek; |
| AnnotationValidations.validate( |
| android.annotation.IntRange.class, null, mDayOfWeek, |
| "from", 0, |
| "to", 6); |
| this.mCoords = coords; |
| AnnotationValidations.validate( |
| Size.class, null, mCoords.length, |
| "value", 2); |
| AnnotationValidations.validate( |
| NonNull.class, null, mCoords); |
| int coordsSize = mCoords.length; |
| for (int i = 0; i < coordsSize; i++) { |
| AnnotationValidations.validate( |
| FloatRange.class, null, mCoords[i], |
| "from", 0f); |
| } |
| |
| this.mToken = token; |
| AnnotationValidations.validate( |
| NonNull.class, null, mToken); |
| this.mIPCInterface = iPCInterface; |
| |
| onConstructed(); |
| } |
| |
| @DataClass.Generated.Member |
| public static final @NonNull Parcelable.Creator<SampleDataClass> CREATOR |
| = new Parcelable.Creator<SampleDataClass>() { |
| @Override |
| public SampleDataClass[] newArray(int size) { |
| return new SampleDataClass[size]; |
| } |
| |
| @Override |
| public SampleDataClass createFromParcel(@NonNull Parcel in) { |
| return new SampleDataClass(in); |
| } |
| }; |
| |
| /** |
| * A builder for {@link SampleDataClass} |
| */ |
| @SuppressWarnings("WeakerAccess") |
| @DataClass.Generated.Member |
| public static final class Builder { |
| |
| private int mNum; |
| private int mNum2; |
| private int mNum4; |
| private @Nullable String mName; |
| private @NonNull String mName2; |
| private @NonNull String mName4; |
| private @Nullable AccessibilityNodeInfo mOtherParcelable; |
| private @NonNull Date mDate; |
| private @NonNull Pattern mPattern; |
| private @NonNull List<LinkAddress> mLinkAddresses2; |
| private @NonNull ArrayList<LinkAddress> mLinkAddresses; |
| private @Nullable LinkAddress[] mLinkAddresses4; |
| private @StateName @NonNull String mStateName; |
| private @RequestFlags int mFlags; |
| private @State int mState; |
| private @NonNull CharSequence charSeq; |
| private @Nullable LinkAddress[] mLinkAddresses5; |
| private @StringRes int mStringRes; |
| private @android.annotation.IntRange(from = 0, to = 6) int mDayOfWeek; |
| private @Size(2) @NonNull @FloatRange(from = 0f) float[] mCoords; |
| private @NonNull IBinder mToken; |
| private @Nullable ICompanionDeviceManager mIPCInterface; |
| |
| private long mBuilderFieldsSet = 0L; |
| |
| /** |
| * Creates a new Builder. |
| * |
| * @param num |
| * Any property javadoc should go onto the field, and will be copied where appropriate, |
| * including getters, constructor parameters, builder setters, etc. |
| * |
| * <p> |
| * This allows to avoid the burden of maintaining copies of the same documentation |
| * pieces in multiple places for each field. |
| * @param num2 |
| * Various javadoc features should work as expected when copied, e.g {@code code}, |
| * {@link #mName links}, <a href="https://google.com">html links</a>, etc. |
| * @param num4 |
| * {@code @hide} javadoc annotation is also propagated, which can be used to adjust the |
| * desired public API surface. |
| * @param name |
| * {@link Nullable} or {@link NonNull} annotation is required on all non-primitive fields. |
| * @param flags |
| * Fields annotated with {@link IntDef} annotations also get a proper {@link #toString()} value. |
| * @param linkAddresses5 |
| * Final fields suppress generating a setter (when setters are requested). |
| */ |
| public Builder( |
| int num, |
| int num2, |
| int num4, |
| @Nullable String name, |
| @RequestFlags int flags, |
| @Nullable LinkAddress[] linkAddresses5) { |
| mNum = num; |
| mNum2 = num2; |
| mNum4 = num4; |
| mName = name; |
| mFlags = flags; |
| |
| Preconditions.checkFlagsArgument( |
| mFlags, |
| FLAG_MANUAL_REQUEST |
| | FLAG_COMPATIBILITY_MODE_REQUEST |
| | FLAG_AUGMENTED_REQUEST); |
| mLinkAddresses5 = linkAddresses5; |
| } |
| |
| /** |
| * Any property javadoc should go onto the field, and will be copied where appropriate, |
| * including getters, constructor parameters, builder setters, etc. |
| * |
| * <p> |
| * This allows to avoid the burden of maintaining copies of the same documentation |
| * pieces in multiple places for each field. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Builder setNum(int value) { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x1; |
| mNum = value; |
| return this; |
| } |
| |
| /** |
| * Various javadoc features should work as expected when copied, e.g {@code code}, |
| * {@link #mName links}, <a href="https://google.com">html links</a>, etc. |
| * |
| * @see #mNum2 ..and so should blocks at the bottom, e.g. {@code @see} blocks. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Builder setNum2(int value) { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x2; |
| mNum2 = value; |
| return this; |
| } |
| |
| /** |
| * {@code @hide} javadoc annotation is also propagated, which can be used to adjust the |
| * desired public API surface. |
| * |
| * @see #getNum4() is hidden |
| * @see Builder#setNum4(int) also hidden |
| * @hide |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Builder setNum4(int value) { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x4; |
| mNum4 = value; |
| return this; |
| } |
| |
| /** |
| * {@link Nullable} or {@link NonNull} annotation is required on all non-primitive fields. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Builder setName(@NonNull String value) { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x8; |
| mName = value; |
| return this; |
| } |
| |
| /** |
| * Fields with default value expressions ("mFoo = ...") are optional, and are automatically |
| * initialized to the provided default expression, unless explicitly set. |
| * |
| * When using a {@link Builder} optional fields are passed via a {@link Builder#setName2 setter} |
| * while mandatory fields are passed via {@link Builder#Builder constructor}. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Builder setName2(@NonNull String value) { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x10; |
| mName2 = value; |
| return this; |
| } |
| |
| /** |
| * Alternatively, when default value computation is expensive, |
| * {@link #defaultName4 defaultFieldName()} can be defined to compute the default value. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Builder setName4(@NonNull String value) { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x20; |
| mName4 = value; |
| return this; |
| } |
| |
| /** |
| * For parcelling, any field type supported by {@link Parcel} is supported out of the box. |
| * E.g. {@link Parcelable} subclasses, {@link String}, {@link int}, {@link boolean}, etc. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Builder setOtherParcelable(@NonNull AccessibilityNodeInfo value) { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x40; |
| mOtherParcelable = value; |
| return this; |
| } |
| |
| /** |
| * Additionally, support for parcelling other types can be added by implementing a |
| * {@link Parcelling}, and referencing it in the {@link DataClass.ParcelWith} field annotation. |
| * |
| * @see MyDateParcelling an example {@link Parcelling} implementation |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Builder setDate(@NonNull Date value) { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x80; |
| mDate = value; |
| return this; |
| } |
| |
| /** |
| * If a {@link Parcelling} is fairly common, consider putting it in {@link Parcelling.BuiltIn} |
| * to encourage its reuse. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Builder setPattern(@NonNull Pattern value) { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x100; |
| mPattern = value; |
| return this; |
| } |
| |
| /** |
| * For lists, when using a {@link Builder}, other than a regular |
| * {@link Builder#setLinkAddresses2(List) setter}, and additional |
| * {@link Builder#addLinkAddresses2(LinkAddress) add} method is generated for convenience. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Builder setLinkAddresses2(@NonNull List<LinkAddress> value) { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x200; |
| mLinkAddresses2 = value; |
| return this; |
| } |
| |
| /** @see #setLinkAddresses2 */ |
| @DataClass.Generated.Member |
| public @NonNull Builder addLinkAddresses2(@NonNull LinkAddress value) { |
| // You can refine this method's name by providing item's singular name, e.g.: |
| // @DataClass.PluralOf("item")) mItems = ... |
| |
| if (mLinkAddresses2 == null) setLinkAddresses2(new ArrayList<>()); |
| mLinkAddresses2.add(value); |
| return this; |
| } |
| |
| /** |
| * For aesthetics, you may want to consider providing a singular version of the plural field |
| * name, which would be used for the {@link #mLinkAddresses2 above mentioned} "add" method. |
| * |
| * @see Builder#addLinkAddress(LinkAddress) |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Builder setLinkAddresses(@NonNull ArrayList<LinkAddress> value) { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x400; |
| mLinkAddresses = value; |
| return this; |
| } |
| |
| /** @see #setLinkAddresses */ |
| @DataClass.Generated.Member |
| public @NonNull Builder addLinkAddress(@NonNull LinkAddress value) { |
| if (mLinkAddresses == null) setLinkAddresses(new ArrayList<>()); |
| mLinkAddresses.add(value); |
| return this; |
| } |
| |
| /** |
| * For array fields, when using a {@link Builder}, vararg argument format is used for |
| * convenience. |
| * |
| * @see Builder#setLinkAddresses4(LinkAddress...) |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Builder setLinkAddresses4(@NonNull LinkAddress... value) { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x800; |
| mLinkAddresses4 = value; |
| return this; |
| } |
| |
| /** |
| * {@link IntDef}/{@link StringDef}-annotated fields propagate the annotation to |
| * getter/constructor/setter/builder parameters, making for a nicer api. |
| * |
| * @see #getStateName |
| * @see Builder#setStateName |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Builder setStateName(@StateName @NonNull String value) { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x1000; |
| mStateName = value; |
| return this; |
| } |
| |
| /** |
| * Fields annotated with {@link IntDef} annotations also get a proper {@link #toString()} value. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Builder setFlags(@RequestFlags int value) { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x2000; |
| mFlags = value; |
| return this; |
| } |
| |
| /** |
| * Above is true for both {@link IntDef#flag flags} and enum-like {@link IntDef}s |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Builder setState(@State int value) { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x4000; |
| mState = value; |
| return this; |
| } |
| |
| /** |
| * Making a field public will suppress getter generation in favor of accessing it directly. |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Builder setCharSeq(@NonNull CharSequence value) { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x8000; |
| charSeq = value; |
| return this; |
| } |
| |
| /** |
| * Final fields suppress generating a setter (when setters are requested). |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Builder setLinkAddresses5(@NonNull LinkAddress... value) { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x10000; |
| mLinkAddresses5 = value; |
| return this; |
| } |
| |
| /** |
| * Fields with certain annotations are automatically validated in constructor |
| * |
| * You can see overloads in {@link AnnotationValidations} for a list of currently |
| * supported ones. |
| * |
| * You can also extend support to your custom annotations by creating another corresponding |
| * overloads like |
| * {@link AnnotationValidations#validate(Class, UserIdInt, int)}. |
| * |
| * @see #SampleDataClass |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Builder setStringRes(@StringRes int value) { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x20000; |
| mStringRes = value; |
| return this; |
| } |
| |
| /** |
| * Validation annotations may also have parameters. |
| * |
| * Parameter values will be supplied to validation method as name-value pairs. |
| * |
| * @see AnnotationValidations#validate(Class, Size, int, String, int, String, int) |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Builder setDayOfWeek(@android.annotation.IntRange(from = 0, to = 6) int value) { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x40000; |
| mDayOfWeek = value; |
| return this; |
| } |
| |
| /** |
| * Unnamed validation annotation parameter gets supplied to the validating method named as |
| * "value". |
| * |
| * Validation annotations following {@link Each} annotation, will be applied for each |
| * array/collection element instead. |
| * |
| * @see AnnotationValidations#validate(Class, Size, int, String, int) |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Builder setCoords(@Size(2) @NonNull @FloatRange(from = 0f) float... value) { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x80000; |
| mCoords = value; |
| return this; |
| } |
| |
| /** |
| * Binder types are also supported |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Builder setToken(@NonNull IBinder value) { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x100000; |
| mToken = value; |
| return this; |
| } |
| |
| /** |
| * AIDL interface types are also supported |
| */ |
| @DataClass.Generated.Member |
| public @NonNull Builder setIPCInterface(@NonNull ICompanionDeviceManager value) { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x200000; |
| mIPCInterface = value; |
| return this; |
| } |
| |
| /** Builds the instance. This builder should not be touched after calling this! */ |
| public @NonNull SampleDataClass build() { |
| checkNotUsed(); |
| mBuilderFieldsSet |= 0x400000; // Mark builder used |
| |
| if ((mBuilderFieldsSet & 0x10) == 0) { |
| mName2 = "Bob"; |
| } |
| if ((mBuilderFieldsSet & 0x20) == 0) { |
| mName4 = defaultName4(); |
| } |
| if ((mBuilderFieldsSet & 0x40) == 0) { |
| mOtherParcelable = null; |
| } |
| if ((mBuilderFieldsSet & 0x80) == 0) { |
| mDate = new Date(42 * 42); |
| } |
| if ((mBuilderFieldsSet & 0x100) == 0) { |
| mPattern = Pattern.compile(""); |
| } |
| if ((mBuilderFieldsSet & 0x200) == 0) { |
| mLinkAddresses2 = new ArrayList<>(); |
| } |
| if ((mBuilderFieldsSet & 0x400) == 0) { |
| mLinkAddresses = new ArrayList<>(); |
| } |
| if ((mBuilderFieldsSet & 0x800) == 0) { |
| mLinkAddresses4 = null; |
| } |
| if ((mBuilderFieldsSet & 0x1000) == 0) { |
| mStateName = STATE_NAME_UNDEFINED; |
| } |
| if ((mBuilderFieldsSet & 0x4000) == 0) { |
| mState = STATE_UNDEFINED; |
| } |
| if ((mBuilderFieldsSet & 0x8000) == 0) { |
| charSeq = ""; |
| } |
| if ((mBuilderFieldsSet & 0x20000) == 0) { |
| mStringRes = 0; |
| } |
| if ((mBuilderFieldsSet & 0x40000) == 0) { |
| mDayOfWeek = 3; |
| } |
| if ((mBuilderFieldsSet & 0x80000) == 0) { |
| mCoords = new float[] { 0f, 0f }; |
| } |
| if ((mBuilderFieldsSet & 0x100000) == 0) { |
| mToken = new Binder(); |
| } |
| if ((mBuilderFieldsSet & 0x200000) == 0) { |
| mIPCInterface = null; |
| } |
| SampleDataClass o = new SampleDataClass( |
| mNum, |
| mNum2, |
| mNum4, |
| mName, |
| mName2, |
| mName4, |
| mOtherParcelable, |
| mDate, |
| mPattern, |
| mLinkAddresses2, |
| mLinkAddresses, |
| mLinkAddresses4, |
| mStateName, |
| mFlags, |
| mState, |
| charSeq, |
| mLinkAddresses5, |
| mStringRes, |
| mDayOfWeek, |
| mCoords, |
| mToken, |
| mIPCInterface); |
| return o; |
| } |
| |
| private void checkNotUsed() { |
| if ((mBuilderFieldsSet & 0x400000) != 0) { |
| throw new IllegalStateException( |
| "This Builder should not be reused. Use a new Builder instance instead"); |
| } |
| } |
| } |
| |
| @DataClass.Generated( |
| time = 1616541539978L, |
| codegenVersion = "1.0.23", |
| sourceFile = "frameworks/base/tests/Codegen/src/com/android/codegentest/SampleDataClass.java", |
| inputSignatures = "public static final java.lang.String STATE_NAME_UNDEFINED\npublic static final java.lang.String STATE_NAME_ON\npublic static final java.lang.String STATE_NAME_OFF\npublic static final int STATE_ON\npublic static final int STATE_OFF\npublic static final int STATE_UNDEFINED\npublic static final @com.android.codegentest.SampleDataClass.RequestFlags int FLAG_MANUAL_REQUEST\npublic static final @com.android.codegentest.SampleDataClass.RequestFlags int FLAG_COMPATIBILITY_MODE_REQUEST\npublic static final @com.android.codegentest.SampleDataClass.RequestFlags int FLAG_AUGMENTED_REQUEST\nprivate int mNum\nprivate int mNum2\nprivate int mNum4\nprivate @android.annotation.Nullable java.lang.String mName\nprivate @android.annotation.NonNull java.lang.String mName2\nprivate @android.annotation.NonNull java.lang.String mName4\nprivate @android.annotation.Nullable android.view.accessibility.AccessibilityNodeInfo mOtherParcelable\nprivate @com.android.internal.util.DataClass.ParcelWith(com.android.codegentest.MyDateParcelling.class) @android.annotation.NonNull java.util.Date mDate\nprivate @com.android.internal.util.DataClass.ParcelWith(com.android.internal.util.Parcelling.BuiltIn.ForPattern.class) @android.annotation.NonNull java.util.regex.Pattern mPattern\nprivate @android.annotation.NonNull java.util.List<android.net.LinkAddress> mLinkAddresses2\nprivate @com.android.internal.util.DataClass.PluralOf(\"linkAddress\") @android.annotation.NonNull java.util.ArrayList<android.net.LinkAddress> mLinkAddresses\nprivate @android.annotation.Nullable android.net.LinkAddress[] mLinkAddresses4\nprivate @com.android.codegentest.SampleDataClass.StateName @android.annotation.NonNull java.lang.String mStateName\nprivate @com.android.codegentest.SampleDataClass.RequestFlags int mFlags\nprivate @com.android.codegentest.SampleDataClass.State int mState\npublic @android.annotation.NonNull java.lang.CharSequence charSeq\nprivate final @android.annotation.Nullable android.net.LinkAddress[] mLinkAddresses5\nprivate transient android.net.LinkAddress[] mLinkAddresses6\ntransient int[] mTmpStorage\nprivate @android.annotation.StringRes int mStringRes\nprivate @android.annotation.IntRange int mDayOfWeek\nprivate @android.annotation.Size @android.annotation.NonNull @com.android.internal.util.DataClass.Each @android.annotation.FloatRange float[] mCoords\nprivate @android.annotation.NonNull android.os.IBinder mToken\nprivate @android.annotation.Nullable android.companion.ICompanionDeviceManager mIPCInterface\nprivate static java.lang.String defaultName4()\nprivate int[] lazyInitTmpStorage()\npublic android.net.LinkAddress[] getLinkAddresses4()\nprivate boolean patternEquals(java.util.regex.Pattern)\nprivate int patternHashCode()\nprivate void onConstructed()\npublic void dump(java.io.PrintWriter)\nclass SampleDataClass extends java.lang.Object implements [android.os.Parcelable]\n@com.android.internal.util.DataClass(genBuilder=true, genConstructor=true, genEqualsHashCode=true, genToString=true, genForEachField=true, genSetters=true)") |
| @Deprecated |
| private void __metadata() {} |
| |
| |
| //@formatter:on |
| // End of generated code |
| |
| } |