This annotation implies the same "nullness" as no annotation. However, it is different
21 | * than having no annotation, as it is inherited and it can override a ParametersAreNonnullByDefault
22 | * annotation at an outer scope.
23 | *
24 | */
25 | @Documented
26 | @Nullable
27 | @TypeQualifierDefault(ElementType.PARAMETER)
28 | @Retention(RetentionPolicy.RUNTIME)
29 | public @interface ParametersAreNullableByDefault {
30 | }
31 |
--------------------------------------------------------------------------------
/app/src/main/java/javax/annotation/PropertyKey.java:
--------------------------------------------------------------------------------
1 | package javax.annotation;
2 |
3 | import java.lang.annotation.Documented;
4 | import java.lang.annotation.Retention;
5 | import java.lang.annotation.RetentionPolicy;
6 |
7 | import javax.annotation.meta.TypeQualifier;
8 | import javax.annotation.meta.When;
9 |
10 | @Documented
11 | @TypeQualifier
12 | @Retention(RetentionPolicy.RUNTIME)
13 | public @interface PropertyKey {
14 | When when() default When.ALWAYS;
15 | }
16 |
--------------------------------------------------------------------------------
/app/src/main/java/javax/annotation/RegEx.java:
--------------------------------------------------------------------------------
1 | package javax.annotation;
2 |
3 | import java.lang.annotation.Documented;
4 | import java.lang.annotation.Retention;
5 | import java.lang.annotation.RetentionPolicy;
6 | import java.util.regex.Pattern;
7 | import java.util.regex.PatternSyntaxException;
8 |
9 | import javax.annotation.meta.TypeQualifierNickname;
10 | import javax.annotation.meta.TypeQualifierValidator;
11 | import javax.annotation.meta.When;
12 |
13 | /**
14 | * This qualifier is used to denote String values that should be a Regular
15 | * expression.
16 | *
17 | */
18 | @Documented
19 | @Syntax("RegEx")
20 | @TypeQualifierNickname
21 | @Retention(RetentionPolicy.RUNTIME)
22 | public @interface RegEx {
23 | When when() default When.ALWAYS;
24 |
25 | static class Checker implements TypeQualifierValidator
15 | * Thus, you might define a qualifier SocialSecurityNumber as follows:
16 | *
28 | *
36 | *
37 | * Syntax names can be followed by a colon and a list of key value pairs,
38 | * separated by commas. For example, "SQL:dialect=Oracle,version=2.3". Tools
39 | * should ignore any keys they don't recognize.
40 | */
41 | String value();
42 |
43 | When when() default When.ALWAYS;
44 | }
45 |
--------------------------------------------------------------------------------
/app/src/main/java/javax/annotation/Tainted.java:
--------------------------------------------------------------------------------
1 | package javax.annotation;
2 |
3 | import java.lang.annotation.Documented;
4 | import java.lang.annotation.Retention;
5 | import java.lang.annotation.RetentionPolicy;
6 |
7 | import javax.annotation.meta.TypeQualifierNickname;
8 | import javax.annotation.meta.When;
9 |
10 | @Documented
11 | @TypeQualifierNickname
12 | @Untainted(when = When.MAYBE)
13 | @Retention(RetentionPolicy.RUNTIME)
14 | public @interface Tainted {
15 |
16 | }
17 |
--------------------------------------------------------------------------------
/app/src/main/java/javax/annotation/Untainted.java:
--------------------------------------------------------------------------------
1 | package javax.annotation;
2 |
3 | import java.lang.annotation.Documented;
4 | import java.lang.annotation.Retention;
5 | import java.lang.annotation.RetentionPolicy;
6 |
7 | import javax.annotation.meta.TypeQualifier;
8 | import javax.annotation.meta.When;
9 |
10 | @Documented
11 | @TypeQualifier
12 | @Retention(RetentionPolicy.RUNTIME)
13 | public @interface Untainted {
14 | When when() default When.ALWAYS;
15 | }
16 |
--------------------------------------------------------------------------------
/app/src/main/java/javax/annotation/WillClose.java:
--------------------------------------------------------------------------------
1 | package javax.annotation;
2 |
3 | import java.lang.annotation.Documented;
4 | import java.lang.annotation.Retention;
5 | import java.lang.annotation.RetentionPolicy;
6 |
7 | @Documented
8 | @Retention(RetentionPolicy.RUNTIME)
9 | /**
10 | * Used to annotate a method parameter to indicate that this method will close
11 | * the resource.
12 | */
13 | public @interface WillClose {
14 |
15 | }
16 |
--------------------------------------------------------------------------------
/app/src/main/java/javax/annotation/WillCloseWhenClosed.java:
--------------------------------------------------------------------------------
1 | package javax.annotation;
2 |
3 | import java.lang.annotation.Documented;
4 | import java.lang.annotation.Retention;
5 | import java.lang.annotation.RetentionPolicy;
6 |
7 | @Documented
8 | @Retention(RetentionPolicy.RUNTIME)
9 | /**
10 | * Used to annotate a constructor/factory parameter to indicate that returned
11 | * object (X) will close the resource when X is closed.
12 | */
13 | public @interface WillCloseWhenClosed {
14 |
15 | }
16 |
--------------------------------------------------------------------------------
/app/src/main/java/javax/annotation/WillNotClose.java:
--------------------------------------------------------------------------------
1 | package javax.annotation;
2 |
3 | import java.lang.annotation.Documented;
4 | import java.lang.annotation.Retention;
5 | import java.lang.annotation.RetentionPolicy;
6 |
7 | @Documented
8 | @Retention(RetentionPolicy.RUNTIME)
9 | /**
10 | * Used to annotate a method parameter to indicate that this method will not
11 | * close the resource.
12 | */
13 | public @interface WillNotClose {
14 |
15 | }
16 |
--------------------------------------------------------------------------------
/app/src/main/java/javax/annotation/concurrent/GuardedBy.java:
--------------------------------------------------------------------------------
1 | package javax.annotation.concurrent;
2 |
3 | import java.lang.annotation.ElementType;
4 | import java.lang.annotation.Retention;
5 | import java.lang.annotation.RetentionPolicy;
6 | import java.lang.annotation.Target;
7 |
8 | /*
9 | * Copyright (c) 2005 Brian Goetz
10 | * Released under the Creative Commons Attribution License
11 | * (http://creativecommons.org/licenses/by/2.5)
12 | * Official home: http://www.jcip.net
13 | */
14 |
15 | /**
16 | * GuardedBy
17 | *
18 | * The field or method to which this annotation is applied can only be accessed
19 | * when holding a particular lock, which may be a built-in (synchronization)
20 | * lock, or may be an explicit java.util.concurrent.Lock.
21 | *
22 | * The argument determines which lock guards the annotated field or method: this :
23 | * The string literal "this" means that this field is guarded by the class in
24 | * which it is defined. class-name.this : For inner classes, it may be necessary
25 | * to disambiguate 'this'; the class-name.this designation allows you to specify
26 | * which 'this' reference is intended itself : For reference fields only; the
27 | * object to which the field refers. field-name : The lock object is referenced
28 | * by the (instance or static) field specified by field-name.
29 | * class-name.field-name : The lock object is reference by the static field
30 | * specified by class-name.field-name. method-name() : The lock object is
31 | * returned by calling the named nil-ary method. class-name.class : The Class
32 | * object for the specified class should be used as the lock object.
33 | */
34 | @Target( { ElementType.FIELD, ElementType.METHOD })
35 | @Retention(RetentionPolicy.CLASS)
36 | public @interface GuardedBy {
37 | String value();
38 | }
39 |
--------------------------------------------------------------------------------
/app/src/main/java/javax/annotation/concurrent/Immutable.java:
--------------------------------------------------------------------------------
1 | package javax.annotation.concurrent;
2 |
3 | import java.lang.annotation.Documented;
4 | import java.lang.annotation.ElementType;
5 | import java.lang.annotation.Retention;
6 | import java.lang.annotation.RetentionPolicy;
7 | import java.lang.annotation.Target;
8 |
9 | /*
10 | * Copyright (c) 2005 Brian Goetz
11 | * Released under the Creative Commons Attribution License
12 | * (http://creativecommons.org/licenses/by/2.5)
13 | * Official home: http://www.jcip.net
14 | */
15 |
16 | /**
17 | * Immutable
18 | *
19 | * The class to which this annotation is applied is immutable. This means that
20 | * its state cannot be seen to change by callers. Of necessity this means that
21 | * all public fields are final, and that all public final reference fields refer
22 | * to other immutable objects, and that methods do not publish references to any
23 | * internal state which is mutable by implementation even if not by design.
24 | * Immutable objects may still have internal mutable state for purposes of
25 | * performance optimization; some state variables may be lazily computed, so
26 | * long as they are computed from immutable state and that callers cannot tell
27 | * the difference.
28 | *
29 | * Immutable objects are inherently thread-safe; they may be passed between
30 | * threads or published without synchronization.
31 | */
32 | @Documented
33 | @Target(ElementType.TYPE)
34 | @Retention(RetentionPolicy.CLASS)
35 | public @interface Immutable {
36 | }
37 |
--------------------------------------------------------------------------------
/app/src/main/java/javax/annotation/concurrent/NotThreadSafe.java:
--------------------------------------------------------------------------------
1 | package javax.annotation.concurrent;
2 |
3 | import java.lang.annotation.Documented;
4 | import java.lang.annotation.ElementType;
5 | import java.lang.annotation.Retention;
6 | import java.lang.annotation.RetentionPolicy;
7 | import java.lang.annotation.Target;
8 |
9 | /*
10 | * Copyright (c) 2005 Brian Goetz
11 | * Released under the Creative Commons Attribution License
12 | * (http://creativecommons.org/licenses/by/2.5)
13 | * Official home: http://www.jcip.net
14 | */
15 |
16 | /**
17 | * NotThreadSafe
18 | *
19 | * The class to which this annotation is applied is not thread-safe. This
20 | * annotation primarily exists for clarifying the non-thread-safety of a class
21 | * that might otherwise be assumed to be thread-safe, despite the fact that it
22 | * is a bad idea to assume a class is thread-safe without good reason.
23 | *
24 | * @see ThreadSafe
25 | */
26 | @Documented
27 | @Target(ElementType.TYPE)
28 | @Retention(RetentionPolicy.CLASS)
29 | public @interface NotThreadSafe {
30 | }
31 |
--------------------------------------------------------------------------------
/app/src/main/java/javax/annotation/concurrent/ThreadSafe.java:
--------------------------------------------------------------------------------
1 | package javax.annotation.concurrent;
2 |
3 | import java.lang.annotation.Documented;
4 | import java.lang.annotation.ElementType;
5 | import java.lang.annotation.Retention;
6 | import java.lang.annotation.RetentionPolicy;
7 | import java.lang.annotation.Target;
8 |
9 | /**
10 | * ThreadSafe
11 | *
12 | * The class to which this annotation is applied is thread-safe. This means that
13 | * no sequences of accesses (reads and writes to public fields, calls to public
14 | * methods) may put the object into an invalid state, regardless of the
15 | * interleaving of those actions by the runtime, and without requiring any
16 | * additional synchronization or coordination on the part of the caller.
17 | */
18 | @Documented
19 | @Target(ElementType.TYPE)
20 | @Retention(RetentionPolicy.CLASS)
21 | public @interface ThreadSafe {
22 | }
23 |
--------------------------------------------------------------------------------
/app/src/main/java/javax/annotation/meta/Exclusive.java:
--------------------------------------------------------------------------------
1 | package javax.annotation.meta;
2 |
3 | import java.lang.annotation.Documented;
4 | import java.lang.annotation.Retention;
5 | import java.lang.annotation.RetentionPolicy;
6 |
7 | /**
8 | * This annotation can be applied to the value() element of an annotation that
9 | * is annotated as a TypeQualifier.
10 | *
11 | * For example, the following defines a type qualifier such that if you know a
12 | * value is {@literal @Foo(1)}, then the value cannot be {@literal @Foo(2)} or {{@literal @Foo(3)}.
13 | *
14 | *
15 | * @TypeQualifier @interface Foo {
16 | * @Exclusive int value();
17 | * }
18 | *
19 | *
20 | */
21 |
22 | @Documented
23 | @Retention(RetentionPolicy.RUNTIME)
24 | public @interface Exclusive {
25 |
26 | }
27 |
--------------------------------------------------------------------------------
/app/src/main/java/javax/annotation/meta/Exhaustive.java:
--------------------------------------------------------------------------------
1 | package javax.annotation.meta;
2 |
3 | import java.lang.annotation.Documented;
4 | import java.lang.annotation.Retention;
5 | import java.lang.annotation.RetentionPolicy;
6 |
7 | /**
8 | * This annotation can be applied to the value() element of an annotation that
9 | * is annotated as a TypeQualifier. This is only appropriate if the value field
10 | * returns a value that is an Enumeration.
11 | *
12 | * Applications of the type qualifier with different values are exclusive, and
13 | * the enumeration is an exhaustive list of the possible values.
14 | *
15 | * For example, the following defines a type qualifier such that if you know a
16 | * value is neither {@literal @Foo(Color.Red)} or {@literal @Foo(Color.Blue)},
17 | * then the value must be {@literal @Foo(Color.Green)}. And if you know it is
18 | * {@literal @Foo(Color.Green)}, you know it cannot be
19 | * {@literal @Foo(Color.Red)} or {@literal @Foo(Color.Blue)}
20 | *
21 | *
22 | * @TypeQualifier @interface Foo {
23 | * enum Color {RED, BLUE, GREEN};
24 | * @Exhaustive Color value();
25 | * }
26 | *
27 | */
28 |
29 | @Documented
30 | @Retention(RetentionPolicy.RUNTIME)
31 | public @interface Exhaustive {
32 |
33 | }
34 |
--------------------------------------------------------------------------------
/app/src/main/java/javax/annotation/meta/TypeQualifier.java:
--------------------------------------------------------------------------------
1 | package javax.annotation.meta;
2 |
3 | import java.lang.annotation.Documented;
4 | import java.lang.annotation.ElementType;
5 | import java.lang.annotation.Retention;
6 | import java.lang.annotation.RetentionPolicy;
7 | import java.lang.annotation.Target;
8 |
9 | /**
10 | * This qualifier is applied to an annotation to denote that the annotation
11 | * should be treated as a type qualifier.
12 | */
13 |
14 | @Documented
15 | @Target(ElementType.ANNOTATION_TYPE)
16 | @Retention(RetentionPolicy.RUNTIME)
17 | public @interface TypeQualifier {
18 |
19 | /**
20 | * Describes the kinds of values the qualifier can be applied to. If a
21 | * numeric class is provided (e.g., Number.class or Integer.class) then the
22 | * annotation can also be applied to the corresponding primitive numeric
23 | * types.
24 | */
25 | Class applicableTo() default Object.class;
26 |
27 | }
28 |
--------------------------------------------------------------------------------
/app/src/main/java/javax/annotation/meta/TypeQualifierDefault.java:
--------------------------------------------------------------------------------
1 | package javax.annotation.meta;
2 |
3 | import java.lang.annotation.Documented;
4 | import java.lang.annotation.ElementType;
5 | import java.lang.annotation.Retention;
6 | import java.lang.annotation.RetentionPolicy;
7 | import java.lang.annotation.Target;
8 |
9 | /**
10 | * This qualifier is applied to an annotation to denote that the annotation
11 | * defines a default type qualifier that is visible within the scope of the
12 | * element it is applied to.
13 | */
14 |
15 | @Documented
16 | @Target(ElementType.ANNOTATION_TYPE)
17 | @Retention(RetentionPolicy.RUNTIME)
18 | public @interface TypeQualifierDefault {
19 | ElementType[] value() default {};
20 | }
21 |
--------------------------------------------------------------------------------
/app/src/main/java/javax/annotation/meta/TypeQualifierNickname.java:
--------------------------------------------------------------------------------
1 | package javax.annotation.meta;
2 |
3 | import java.lang.annotation.Documented;
4 | import java.lang.annotation.ElementType;
5 | import java.lang.annotation.Target;
6 |
7 | /**
8 | *
9 | * This annotation is applied to a annotation, and marks the annotation as being
10 | * a qualifier nickname. Applying a nickname annotation X to a element Y should
11 | * be interpreted as having the same meaning as applying all of annotations of X
12 | * (other than QualifierNickname) to Y.
13 | *
14 | *
20 | @Documented
21 | @TypeQualifierNickname @Pattern("[0-9]{3}-[0-9]{2}-[0-9]{4}")
22 | @Retention(RetentionPolicy.RUNTIME)
23 | public @interface SocialSecurityNumber {
24 | }
25 |
26 | *
27 | *
28 | */
29 | @Documented
30 | @Target(ElementType.ANNOTATION_TYPE)
31 | public @interface TypeQualifierNickname {
32 |
33 | }
34 |
--------------------------------------------------------------------------------
/app/src/main/java/javax/annotation/meta/TypeQualifierValidator.java:
--------------------------------------------------------------------------------
1 | package javax.annotation.meta;
2 |
3 | import java.lang.annotation.Annotation;
4 |
5 | import javax.annotation.Nonnull;
6 |
7 | public interface TypeQualifierValidator {
8 | /**
9 | * Given a type qualifier, check to see if a known specific constant value
10 | * is an instance of the set of values denoted by the qualifier.
11 | *
12 | * @param annotation
13 | * the type qualifier
14 | * @param value
15 | * the value to check
16 | * @return a value indicating whether or not the value is an member of the
17 | * values denoted by the type qualifier
18 | */
19 | public @Nonnull
20 | When forConstantValue(@Nonnull A annotation, Object value);
21 | }
22 |
--------------------------------------------------------------------------------
/app/src/main/java/javax/annotation/meta/When.java:
--------------------------------------------------------------------------------
1 | package javax.annotation.meta;
2 |
3 | /**
4 | * Used to describe the relationship between a qualifier T and the set of values
5 | * S possible on an annotated element.
6 | *
7 | * In particular, an issues should be reported if an ALWAYS or MAYBE value is
8 | * used where a NEVER value is required, or if a NEVER or MAYBE value is used
9 | * where an ALWAYS value is required.
10 | *
11 | *
12 | */
13 | public enum When {
14 | /** S is a subset of T */
15 | ALWAYS,
16 | /** nothing definitive is known about the relation between S and T */
17 | UNKNOWN,
18 | /** S intersection T is non empty and S - T is nonempty */
19 | MAYBE,
20 | /** S intersection T is empty */
21 | NEVER;
22 |
23 | }
24 |
--------------------------------------------------------------------------------
/app/src/main/java/org/cc/dexlib2/builder/instruction/BuilderSwitchElement.java:
--------------------------------------------------------------------------------
1 | package org.cc.dexlib2.builder.instruction;
2 |
3 | import org.cc.dexlib2.builder.BuilderSwitchPayload;
4 | import org.cc.dexlib2.builder.Label;
5 | import org.cc.dexlib2.iface.instruction.SwitchElement;
6 |
7 | import javax.annotation.Nonnull;
8 |
9 | public class BuilderSwitchElement implements SwitchElement {
10 | @Nonnull BuilderSwitchPayload parent;
11 | private final int key;
12 | @Nonnull private final Label target;
13 |
14 | public BuilderSwitchElement(@Nonnull BuilderSwitchPayload parent,
15 | int key,
16 | @Nonnull Label target) {
17 | this.parent = parent;
18 | this.key = key;
19 | this.target = target;
20 | }
21 |
22 | @Override public int getKey() {
23 | return key;
24 | }
25 |
26 | @Override public int getOffset() {
27 | return target.getCodeAddress() - parent.getReferrer().getCodeAddress();
28 | }
29 |
30 | @Nonnull
31 | public Label getTarget() {
32 | return target;
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/app/src/main/java/org/cc/dexlib2/dexbacked/DexBackedExceptionHandler.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2012, Google Inc.
3 | * All rights reserved.
4 | *
5 | * Redistribution and use in source and binary forms, with or without
6 | * modification, are permitted provided that the following conditions are
7 | * met:
8 | *
9 | * * Redistributions of source code must retain the above copyright
10 | * notice, this list of conditions and the following disclaimer.
11 | * * Redistributions in binary form must reproduce the above
12 | * copyright notice, this list of conditions and the following disclaimer
13 | * in the documentation and/or other materials provided with the
14 | * distribution.
15 | * * Neither the name of Google Inc. nor the names of its
16 | * contributors may be used to endorse or promote products derived from
17 | * this software without specific prior written permission.
18 | *
19 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 | */
31 |
32 | package org.cc.dexlib2.dexbacked;
33 |
34 | import org.cc.dexlib2.base.BaseExceptionHandler;
35 |
36 | public abstract class DexBackedExceptionHandler extends BaseExceptionHandler {
37 | }
38 |
--------------------------------------------------------------------------------
/app/src/main/java/org/cc/dexlib2/dexbacked/DexReader.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2012, Google Inc.
3 | * All rights reserved.
4 | *
5 | * Redistribution and use in source and binary forms, with or without
6 | * modification, are permitted provided that the following conditions are
7 | * met:
8 | *
9 | * * Redistributions of source code must retain the above copyright
10 | * notice, this list of conditions and the following disclaimer.
11 | * * Redistributions in binary form must reproduce the above
12 | * copyright notice, this list of conditions and the following disclaimer
13 | * in the documentation and/or other materials provided with the
14 | * distribution.
15 | * * Neither the name of Google Inc. nor the names of its
16 | * contributors may be used to endorse or promote products derived from
17 | * this software without specific prior written permission.
18 | *
19 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 | */
31 |
32 | package org.cc.dexlib2.dexbacked;
33 |
34 | import javax.annotation.Nonnull;
35 |
36 | public class DexReader extends BaseDexReader