when using stream api, we often need collectors such as:

EnumMap/EnumSet:

• toEnumMap(Class<E extends Enum, Function<? super T, ? extends E> keyMapper, Function<? super T, ? extends U> valueMapper) + all overloaded variants without valueMapper/KeyMapper
• toEnumSet(Class<E extends Enum)
  If it's possible, add method variants without Class argument by resolving class instance from first element of stream or returning empty set in case of empty stream.

List:

• sized toList: toList(int size) == toCollection(() -> new ArrayList<>(size))

Other useful collectors or "shortcuts" are a topic for discussion.

Description

Currently this method uses Class<?> which can be enhanced by using generic T parameter, i.e. Class<? super T> on parameter and Class<? extends T> as the returned type.

Broken in #101, deployment should be fixed

The valueSupplier and value fields of Lazy.DoubleCheckedLazy are volatile. Volatile reading is much more expensive than plain, so it's better to store local references to values rather than read them again.

Make ClassNamingStrategy CLASS_NAMING_STRATEGY fields protected in JavassistTextModelFactory and AsmTextModelFactory

Current implementation of Placholders benchmark is implemented in the wrong way:

• Iterations get benchmarked, although they have nothing to do with logic and there is no need to over-complicate benchmarks
• Multithreading is enabled which is not needed and causes even more inexact results
• Ineffective regex pattern (and maybe algorithm) is used
• States have random part which varies between benchmarks (even data length differs)
• This benchmark is written by me

The project could not be analyzed because of build errors. Please review the error messages here. Another build will be scheduled within 24 hours. If the build is successful this issue will be closed, otherwise the error message will be updated.

_{This is an automated GitHub Issue created by Sonatype DepShield. GitHub Apps, including DepShield, can be managed from the Developer settings of the repository administrators.}

This is a continuation of #83

Description

All Contributors should be configured for this repository to make it more contributor-friendly.

Description

Most probably, due to a typo, an incorrect recursive call is used here:

where call to write(..) should appear.

Reporters

This bug was reported by @xxDark

Since ASM 9.3, BOM artifact is provided which should be used.

Description

Currently GitHub workflows contain redundant comments (such as on on) and invalid job names (such as Build with Maven when actually testing).

This should be resolved.

Description

Implement @EnumHelpers annotation and the corresponsing annotation processor to generate boilerplate enum methods.

Problem

While Java's enum is a powerful mechanism for describing varios constructions, it has a number of negative aspects which make it not that helpful.

The biggest problem is static E @NotNull [] values() method which is required to always return a fresh copy of the array due to array mutability although it's usually needed for iteration.

Another serious design problem (especially considering padla's philosophy) is inability to do try-match operation, i.e. to try to find an enum constant by a string name alternatively fallin back to null or default value etc.

This PR addresses this by provifing a @EnumHelpers annotation causing the generation of ES utility class for enum E.

Goals

• Add @EnumHelper allowing generation of:
  • @NotNull Stream<@NotNull E> stream()
  • @NotNull @Unmodifiable List<@NotNull E> values()
  • @Nullable E match(final @NotNull String name) and similar ones
• implement annotation-processor to generate the helper class

Example

Given

@EnumHelpers
public enum Foo {
    A, B, C
}

the following should be generated:

@Generated
public final class Foos {

    private static final @NotNull Foo @NotNull [] VALUES_ARRAY
            = Foo.values(); // may be used for faster iterations
    private static final @NotNull List<@NotNull Foo> VALUE_LIST
            = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY));

    private Foos() {
        throw new AssertionError("Foos is an utility class and thus should never be instantiated");
    }

    public static @NotNull Stream<@NotNull Foo> stream() {
        return Arrays.stream(VALUES_ARRAY);
    }

    public static @NotNull @Unmodifiable List<@NotNull Foo> values() {
        return VALUES_LIST;
    }

    public static @Nullable Foo match(final @NotNull String name) {
        if (name == null) throw new NullPointerException("name is null");

        switch (name) {
            case "A": return A;
            case "B": return B;
            case "C": return C;
            default: return null;
        }
    }

    public static Foo match(final @NotNull String name, final Foo defaultValue) {
        if (name == null) throw new NullPointerException("name is null");

        switch (name) {
            case "A": return A;
            case "B": return B;
            case "C": return C;
            default: return defaultValue;
        }
    }

    // note: possibly worth specialized lambda
    public static @Nullable Foo match(final @NotNull String name, final @NotNull Supplier<Foo> defaultValueSupplier) {
        if (name == null) throw new NullPointerException("name is null");
        if (defaultValueSupplier== null) throw new NullPointerException("defaultValueSupplieris null");

        switch (foo) {
            case "A": return A;
            case "B": return B;
            case "C": return C;
            default: return defaultValueSupplier.get();
        }
    }

    // ...
}

Notes

Generated class should net rely on Lombok as it may be not used by annotation users.

Subjects to discuss:

• Documenting annotation should be generated if possible(?) but it is not clear whether some eaxct one (org.jetbrains) should be used or custom (via an annotation parameter).

Currently, Java (1.)8 is the minimal supported version of padla and there are no plans for changing it.
However, while a lot of new helpful features has come with newer Java versions, padla currently only provides backwards-compatibility for these (such as switching between Unsafe implementations) but does not utilize its new features.
This issue is for tracking of bringing this support to padla. There is no guarantees yet if this will happen, however this is a priority task.

Lombok generates unmodifiable Map via its @Builder, this should be replaced with custom behaviour.

Relates to: #19

Description

While callers are expetected to use vararg parameters in order to resolve types, TypeHints#resolve(..) should only be called with an already formed array, thus it should not consume vararg parameters.

References

Reporters

This issue was reported by @AbstractCoderX

Currently, UnsafeClassDefiner tries to get sun.misc.Unsafe directly, ignoring the version of Java.

As a solution, you can just replace Class.forName("sun.misc.Unsafe") with your own UnsafeInternals.UNSAFE_CLASS.

Vulnerabilities

DepShield reports that this application's usage of commons-collections:commons-collections:3.2.1 results in the following vulnerability(s):

• (CVSS 9.8) [CVE-2017-15708] In Apache Synapse, by default no authentication is required for Java Remote Meth...
• (CVSS 7.5) [CVE-2015-6420] Serialized-object interfaces in certain Cisco Collaboration and Social Media; En...

Occurrences

commons-collections:commons-collections:3.2.1 is a transitive dependency introduced by the following direct dependency(s):

• org.apache.velocity:velocity:1.7
        └─ commons-collections:commons-collections:3.2.1

_{This is an automated GitHub Issue created by Sonatype DepShield. Details on managing GitHub Apps, including DepShield, are available for personal and organization accounts. Please submit questions or feedback about DepShield to the Sonatype DepShield Community.}

Need to create a utility class that allows you to combine futures into one large Consumer and Function. I think this will get rid of callback hell in some places. An example is shown in the screenshot

Vulnerabilities

DepShield reports that this application's usage of com.google.guava:guava:18.0 results in the following vulnerability(s):

• (CVSS 5.9) [CVE-2018-10237] Deserialization of Untrusted Data

_{This is an automated GitHub Issue created by Sonatype DepShield. Details on managing GitHub Apps, including DepShield, are available for personal and organization accounts. Please submit questions or feedback about DepShield to the Sonatype DepShield Community.}

Description

LockingWeakLazy does not check the value under write-lock which may lead to duplicate writes.

Reference

Credits

Reported by @Xdelsy

This wrappers have nothing specific to do with Minecraft and so can be moved to padla.
Moreover, there are major issues with them (such as wrong access-qualifiers on their methods) so this issue also covers fixing them.
Moreover, wrappers for all primitive types should be created, not only for int.