Class PlatformDependent

java.lang.Object
io.netty.util.internal.PlatformDependent
public final class PlatformDependent extends Object
Utility that detects various properties specific to the current runtime environment, such as Java version and the availability of the sun.misc.Unsafe object.

You can disable the use of sun.misc.Unsafe if you specify the system property io.netty.noUnsafe.

  • Field Details

    • logger

      private static final InternalLogger logger

    • MAX_DIRECT_MEMORY_SIZE_ARG_PATTERN

      private static Pattern MAX_DIRECT_MEMORY_SIZE_ARG_PATTERN

    • MAYBE_SUPER_USER

      private static final boolean MAYBE_SUPER_USER

    • CAN_ENABLE_TCP_NODELAY_BY_DEFAULT

      private static final boolean CAN_ENABLE_TCP_NODELAY_BY_DEFAULT

    • UNSAFE_UNAVAILABILITY_CAUSE

      private static final Throwable UNSAFE_UNAVAILABILITY_CAUSE

    • DIRECT_BUFFER_PREFERRED

      private static final boolean DIRECT_BUFFER_PREFERRED

    • EXPLICIT_NO_PREFER_DIRECT

      private static final boolean EXPLICIT_NO_PREFER_DIRECT

    • MAX_DIRECT_MEMORY

      private static final long MAX_DIRECT_MEMORY

    • MPSC_CHUNK_SIZE

      private static final int MPSC_CHUNK_SIZE
      See Also:

    • MIN_MAX_MPSC_CAPACITY

      private static final int MIN_MAX_MPSC_CAPACITY
      See Also:

    • MAX_ALLOWED_MPSC_CAPACITY

      private static final int MAX_ALLOWED_MPSC_CAPACITY
      See Also:

    • BYTE_ARRAY_BASE_OFFSET

      private static final long BYTE_ARRAY_BASE_OFFSET

    • TMPDIR

      private static final File TMPDIR

    • BIT_MODE

      private static final int BIT_MODE

    • NORMALIZED_ARCH

      private static final String NORMALIZED_ARCH

    • NORMALIZED_OS

      private static final String NORMALIZED_OS

    • LINUX_OS_CLASSIFIERS

      private static final Set<String> LINUX_OS_CLASSIFIERS

    • IS_WINDOWS

      private static final boolean IS_WINDOWS

    • IS_OSX

      private static final boolean IS_OSX

    • IS_J9_JVM

      private static final boolean IS_J9_JVM

    • IS_IVKVM_DOT_NET

      private static final boolean IS_IVKVM_DOT_NET

    • ADDRESS_SIZE

      private static final int ADDRESS_SIZE

    • DIRECT_MEMORY_COUNTER

      private static final AtomicLong DIRECT_MEMORY_COUNTER

    • DIRECT_MEMORY_LIMIT

      private static final long DIRECT_MEMORY_LIMIT

    • CLEANER

      private static final Cleaner CLEANER

    • LEGACY_CLEANER

      private static final Cleaner LEGACY_CLEANER

    • HAS_ALLOCATE_UNINIT_ARRAY

      private static final boolean HAS_ALLOCATE_UNINIT_ARRAY

    • LINUX_ID_PREFIX

      private static final String LINUX_ID_PREFIX
      See Also:

    • LINUX_ID_LIKE_PREFIX

      private static final String LINUX_ID_LIKE_PREFIX
      See Also:

    • BIG_ENDIAN_NATIVE_ORDER

      public static final boolean BIG_ENDIAN_NATIVE_ORDER

    • IGNORE_EXPENSIVE_CLEAN

      private static final boolean IGNORE_EXPENSIVE_CLEAN

    • JFR

      private static final boolean JFR

    • VAR_HANDLE

      private static final boolean VAR_HANDLE

    • NOOP

      private static final Cleaner NOOP

  • Constructor Details

    • PlatformDependent

      private PlatformDependent()

  • Method Details

    • initializeVarHandle

      private static boolean initializeVarHandle()

    • addFilesystemOsClassifiers

      static void addFilesystemOsClassifiers(Set<String> availableClassifiers)

    • processOsReleaseFile

      private static boolean processOsReleaseFile(String osReleaseFileName, Set<String> availableClassifiers)

    • addPropertyOsClassifiers

      static boolean addPropertyOsClassifiers(Set<String> availableClassifiers)

    • byteArrayBaseOffset

      public static long byteArrayBaseOffset()

    • hasDirectBufferNoCleanerConstructor

      public static boolean hasDirectBufferNoCleanerConstructor()

    • allocateUninitializedArray

      public static byte[] allocateUninitializedArray(int size)

    • isAndroid

      public static boolean isAndroid()
      Returns true if and only if the current platform is Android

    • isWindows

      public static boolean isWindows()
      Return true if the JVM is running on Windows

    • isOsx

      public static boolean isOsx()
      Return true if the JVM is running on OSX / MacOS

    • maybeSuperUser

      public static boolean maybeSuperUser()
      Return true if the current user may be a super-user. Be aware that this is just an hint and so it may return false-positives.

    • javaVersion

      public static int javaVersion()
      Return the version of Java under which this library is used.

    • isVirtualThread

      public static boolean isVirtualThread(Thread thread)
      Parameters:
      thread - The thread to be checked.
      Returns:
      true if this Thread is a virtual thread, false otherwise.

    • canEnableTcpNoDelayByDefault

      public static boolean canEnableTcpNoDelayByDefault()
      Returns true if and only if it is fine to enable TCP_NODELAY socket option by default.

    • hasUnsafe

      public static boolean hasUnsafe()
      Return true if sun.misc.Unsafe was found on the classpath and can be used for accelerated direct memory access.

    • getUnsafeUnavailabilityCause

      public static Throwable getUnsafeUnavailabilityCause()
      Return the reason (if any) why sun.misc.Unsafe was not available.

    • isUnaligned

      public static boolean isUnaligned()
      true if and only if the platform supports unaligned access.
      See Also:

    • directBufferPreferred

      public static boolean directBufferPreferred()
      Returns true if the platform has reliable low-level direct buffer access API and a user has not specified -Dio.netty.noPreferDirect option.

    • isExplicitNoPreferDirect

      public static boolean isExplicitNoPreferDirect()
      Returns true if user has specified -Dio.netty.noPreferDirect=true option.

    • canReliabilyFreeDirectBuffers

      public static boolean canReliabilyFreeDirectBuffers()
      Return true if the selected cleaner can free direct buffers in a controlled way. This guarantee only applies for buffers allocated via allocateDirect(int) and when using the clean method of the returned CleanableDirectBuffer.

    • maxDirectMemory

      public static long maxDirectMemory()
      Returns the maximum memory reserved for direct buffer allocation.

    • usedDirectMemory

      public static long usedDirectMemory()
      Returns the current memory reserved for direct buffer allocation. This method returns -1 in case that a value is not available.
      See Also:

    • tmpdir

      public static File tmpdir()
      Returns the temporary directory.

    • bitMode

      public static int bitMode()
      Returns the bit mode of the current VM (usually 32 or 64.)

    • addressSize

      public static int addressSize()
      Return the address size of the OS. 4 (for 32 bits systems ) and 8 (for 64 bits systems).

    • allocateMemory

      public static long allocateMemory(long size)

    • freeMemory

      public static void freeMemory(long address)

    • reallocateMemory

      public static long reallocateMemory(long address, long newSize)

    • throwException

      public static void throwException(Throwable t)
      Raises an exception bypassing compiler checks for checked exceptions.

    • newConcurrentHashMap

      @Deprecated public static <K,V> ConcurrentMap<K,V> newConcurrentHashMap()
      Deprecated.
      please use new ConcurrentHashMapinvalid input: '<'K, V>() directly.
      Creates a new fastest ConcurrentMap implementation for the current platform.

    • newLongCounter

      @Deprecated public static LongCounter newLongCounter()
      Deprecated.
      please use LongAdder instead.
      Creates a new fastest LongCounter implementation for the current platform.

    • newConcurrentHashMap

      @Deprecated public static <K,V> ConcurrentMap<K,V> newConcurrentHashMap(int initialCapacity)
      Deprecated.
      please use new ConcurrentHashMapinvalid input: '<'K, V>() directly.
      Creates a new fastest ConcurrentMap implementation for the current platform.

    • newConcurrentHashMap

      @Deprecated public static <K,V> ConcurrentMap<K,V> newConcurrentHashMap(int initialCapacity, float loadFactor)
      Deprecated.
      please use new ConcurrentHashMapinvalid input: '<'K, V>() directly.
      Creates a new fastest ConcurrentMap implementation for the current platform.

    • newConcurrentHashMap

      @Deprecated public static <K,V> ConcurrentMap<K,V> newConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel)
      Deprecated.
      please use new ConcurrentHashMapinvalid input: '<'K, V>() directly.
      Creates a new fastest ConcurrentMap implementation for the current platform.

    • newConcurrentHashMap

      @Deprecated public static <K,V> ConcurrentMap<K,V> newConcurrentHashMap(Map<? extends K, ? extends V> map)
      Deprecated.
      please use new ConcurrentHashMapinvalid input: '<'K, V>() directly.
      Creates a new fastest ConcurrentMap implementation for the current platform.

    • allocateDirect

      public static CleanableDirectBuffer allocateDirect(int capacity)
      Allocate a direct ByteBuffer of the given capacity, and return it alongside its deallocation mechanism.
      Parameters:
      capacity - The desired capacity of the direct byte buffer.
      Returns:
      The CleanableDirectBuffer instance that contain the buffer and its deallocation mechanism.

    • allocateDirect

      public static CleanableDirectBuffer allocateDirect(int capacity, boolean permitExpensiveClean)
      Allocate a direct ByteBuffer of the given capacity, and return it alongside its deallocation mechanism.
      Parameters:
      capacity - The desired capacity of the direct byte buffer.
      permitExpensiveClean - Whether to allow expensive clean operations or not. If expensive clean operations are not permitted (false), then the buffer cleaning may instead be delegated to the GC and reference processing. Pooling allocators would typically permit expensive clean operations, while unpooled buffers would not.
      Returns:
      The CleanableDirectBuffer instance that contain the buffer and its deallocation mechanism.

    • reallocateDirect

      public static CleanableDirectBuffer reallocateDirect(CleanableDirectBuffer buffer, int newCapacity)
      Reallocate a direct buffer with the given new capacity. The old buffer is invalidated and must not be used after this call.
      Parameters:
      buffer - The old buffer to reallocate.
      newCapacity - The desired new capacity.
      Returns:
      The new CleanableDirectBuffer with the given capacity.

    • freeDirectBuffer

      @Deprecated public static void freeDirectBuffer(ByteBuffer buffer)
      Deprecated.
      Use the CleanableDirectBuffer.clean() from allocateDirect(int) instead.
      Try to deallocate the specified direct ByteBuffer. Please note this method does nothing if the current platform does not support this operation or the specified buffer is not a direct buffer.

    • hasDirectByteBufferAddress

      public static boolean hasDirectByteBufferAddress(ByteBuffer buffer)
      Check if it is possible to call directBufferAddress(ByteBuffer) on the given buffer.
      Parameters:
      buffer - The specific buffer instance to check for.
      Returns:
      true if directBufferAddress(ByteBuffer) can be called on the given buffer, otherwise false.

    • directBufferAddress

      public static long directBufferAddress(ByteBuffer buffer)
      Obtain the native memory address of the given direct byte buffer, or throw an exception if it's not possible.
      Parameters:
      buffer - The buffer to get the native memory address for.
      Returns:
      The native memory address of the give buffer.

    • directBuffer

      public static ByteBuffer directBuffer(long memoryAddress, int size)

    • hasVarHandle

      public static boolean hasVarHandle()

    • hasJctoolsVarHandle

      static boolean hasJctoolsVarHandle()

    • useVarHandleForMultiByteAccess

      public static boolean useVarHandleForMultiByteAccess()
      true if VarHandle should be used for multi-byte access. The multi-byte access strategy is determined as follows: 1) If the platform supports unaligned access natively, use Unsafe as the fastest option. 2) Otherwise, if VarHandle is available, use it as a fallback. 3) Otherwise, fall back to manual byte-by-byte access.

    • canUnalignedAccess

      public static boolean canUnalignedAccess()
      true if multi-byte access at arbitrary offsets is possible, either natively through Unsafe or via VarHandle where the JVM handles alignment and byte ordering internally.

    • findVarHandleOfIntField

      public static VarHandle findVarHandleOfIntField(MethodHandles.Lookup lookup, Class<?> type, String fieldName)

    • intBeArrayView

      public static VarHandle intBeArrayView()

    • intLeArrayView

      public static VarHandle intLeArrayView()

    • longBeArrayView

      public static VarHandle longBeArrayView()

    • longLeArrayView

      public static VarHandle longLeArrayView()

    • shortBeArrayView

      public static VarHandle shortBeArrayView()

    • shortLeArrayView

      public static VarHandle shortLeArrayView()

    • longBeByteBufferView

      public static VarHandle longBeByteBufferView()

    • longLeByteBufferView

      public static VarHandle longLeByteBufferView()

    • intBeByteBufferView

      public static VarHandle intBeByteBufferView()

    • intLeByteBufferView

      public static VarHandle intLeByteBufferView()

    • shortBeByteBufferView

      public static VarHandle shortBeByteBufferView()

    • shortLeByteBufferView

      public static VarHandle shortLeByteBufferView()

    • getObject

      public static Object getObject(Object object, long fieldOffset)

    • getVolatileInt

      public static int getVolatileInt(Object object, long fieldOffset)

    • getInt

      public static int getInt(Object object, long fieldOffset)

    • putOrderedInt

      public static void putOrderedInt(Object object, long fieldOffset, int value)

    • getAndAddInt

      public static int getAndAddInt(Object object, long fieldOffset, int delta)

    • compareAndSwapInt

      public static boolean compareAndSwapInt(Object object, long fieldOffset, int expected, int value)

    • safeConstructPutInt

      static void safeConstructPutInt(Object object, long fieldOffset, int value)

    • getByte

      public static byte getByte(long address)

    • getShort

      public static short getShort(long address)

    • getInt

      public static int getInt(long address)

    • getLong

      public static long getLong(long address)

    • getByte

      public static byte getByte(byte[] data, int index)

    • getByte

      public static byte getByte(byte[] data, long index)

    • getShort

      public static short getShort(byte[] data, int index)

    • getInt

      public static int getInt(byte[] data, int index)

    • getInt

      public static int getInt(int[] data, long index)

    • getLong

      public static long getLong(byte[] data, int index)

    • getLong

      public static long getLong(long[] data, long index)

    • toIntExact

      private static int toIntExact(long value)

    • getLongSafe

      private static long getLongSafe(byte[] bytes, int offset)

    • getIntSafe

      private static int getIntSafe(byte[] bytes, int offset)

    • getShortSafe

      private static short getShortSafe(byte[] bytes, int offset)

    • hashCodeAsciiCompute

      private static int hashCodeAsciiCompute(CharSequence value, int offset, int hash)
      Identical to PlatformDependent0.hashCodeAsciiCompute(long, int) but for CharSequence.

    • hashCodeAsciiSanitizeInt

      private static int hashCodeAsciiSanitizeInt(CharSequence value, int offset)
      Identical to PlatformDependent0.hashCodeAsciiSanitize(int) but for CharSequence.

    • hashCodeAsciiSanitizeShort

      private static int hashCodeAsciiSanitizeShort(CharSequence value, int offset)
      Identical to PlatformDependent0.hashCodeAsciiSanitize(short) but for CharSequence.

    • hashCodeAsciiSanitizeByte

      private static int hashCodeAsciiSanitizeByte(char value)
      Identical to PlatformDependent0.hashCodeAsciiSanitize(byte) but for CharSequence.

    • putByte

      public static void putByte(long address, byte value)

    • putShort

      public static void putShort(long address, short value)

    • putInt

      public static void putInt(long address, int value)

    • putLong

      public static void putLong(long address, long value)

    • putByte

      public static void putByte(byte[] data, int index, byte value)

    • putByte

      public static void putByte(Object data, long offset, byte value)

    • putShort

      public static void putShort(byte[] data, int index, short value)

    • putInt

      public static void putInt(byte[] data, int index, int value)

    • putLong

      public static void putLong(byte[] data, int index, long value)

    • putObject

      public static void putObject(Object o, long offset, Object x)

    • objectFieldOffset

      public static long objectFieldOffset(Field field)

    • copyMemory

      public static void copyMemory(long srcAddr, long dstAddr, long length)

    • copyMemory

      public static void copyMemory(byte[] src, int srcIndex, long dstAddr, long length)

    • copyMemory

      public static void copyMemory(byte[] src, int srcIndex, byte[] dst, int dstIndex, long length)

    • copyMemory

      public static void copyMemory(long srcAddr, byte[] dst, int dstIndex, long length)

    • setMemory

      public static void setMemory(byte[] dst, int dstIndex, long bytes, byte value)

    • setMemory

      public static void setMemory(long address, long bytes, byte value)

    • hasAlignDirectByteBuffer

      public static boolean hasAlignDirectByteBuffer()

    • alignDirectBuffer

      public static ByteBuffer alignDirectBuffer(ByteBuffer buffer, int alignment)

    • align

      public static long align(long value, int alignment)

    • offsetSlice

      public static ByteBuffer offsetSlice(ByteBuffer buffer, int index, int length)

    • absolutePut

      public static ByteBuffer absolutePut(ByteBuffer dst, int dstOffset, byte[] src, int srcOffset, int length)

    • absolutePut

      public static ByteBuffer absolutePut(ByteBuffer dst, int dstOffset, ByteBuffer src, int srcOffset, int length)

    • incrementMemoryCounter

      static void incrementMemoryCounter(int capacity)

    • decrementMemoryCounter

      static void decrementMemoryCounter(int capacity)

    • useDirectBufferNoCleaner

      public static boolean useDirectBufferNoCleaner()

    • equals

      public static boolean equals(byte[] bytes1, int startPos1, byte[] bytes2, int startPos2, int length)
      Compare two byte arrays for equality. For performance reasons no bounds checking on the parameters is performed.
      Parameters:
      bytes1 - the first byte array.
      startPos1 - the position (inclusive) to start comparing in bytes1.
      bytes2 - the second byte array.
      startPos2 - the position (inclusive) to start comparing in bytes2.
      length - the amount of bytes to compare. This is assumed to be validated as not going out of bounds by the caller.

    • isZero

      public static boolean isZero(byte[] bytes, int startPos, int length)
      Determine if a subsection of an array is zero.
      Parameters:
      bytes - The byte array.
      startPos - The starting index (inclusive) in bytes.
      length - The amount of bytes to check for zero.
      Returns:
      false if bytes[startPos:startsPos+length) contains a value other than zero.

    • equalsConstantTime

      public static int equalsConstantTime(byte[] bytes1, int startPos1, byte[] bytes2, int startPos2, int length)
      Compare two byte arrays for equality without leaking timing information. For performance reasons no bounds checking on the parameters is performed.

      The int return type is intentional and is designed to allow cascading of constant time operations: 

          byte[] s1 = new {1, 2, 3};
    byte[] s2 = new {1, 2, 3};
    byte[] s3 = new {1, 2, 3};
    byte[] s4 = new {4, 5, 6};
    boolean equals = (equalsConstantTime(s1, 0, s2, 0, s1.length) invalid input: '&'
                      equalsConstantTime(s3, 0, s4, 0, s3.length)) != 0;
      Parameters:
      bytes1 - the first byte array.
      startPos1 - the position (inclusive) to start comparing in bytes1.
      bytes2 - the second byte array.
      startPos2 - the position (inclusive) to start comparing in bytes2.
      length - the amount of bytes to compare. This is assumed to be validated as not going out of bounds by the caller.
      Returns:
      0 if not equal. 1 if equal.

    • hashCodeAscii

      public static int hashCodeAscii(byte[] bytes, int startPos, int length)
      Calculate a hash code of a byte array assuming ASCII character encoding. The resulting hash code will be case insensitive.
      Parameters:
      bytes - The array which contains the data to hash.
      startPos - What index to start generating a hash code in bytes
      length - The amount of bytes that should be accounted for in the computation.
      Returns:
      The hash code of bytes assuming ASCII character encoding. The resulting hash code will be case insensitive.

    • hashCodeAscii

      public static int hashCodeAscii(CharSequence bytes)
      Calculate a hash code of a byte array assuming ASCII character encoding. The resulting hash code will be case insensitive.

      This method assumes that bytes is equivalent to a byte[] but just using CharSequence for storage. The upper most byte of each char from bytes is ignored.

      Parameters:
      bytes - The array which contains the data to hash (assumed to be equivalent to a byte[]).
      Returns:
      The hash code of bytes assuming ASCII character encoding. The resulting hash code will be case insensitive.

    • newMpscQueue

      public static <T> Queue<T> newMpscQueue()
      Create a new Queue which is safe to use for multiple producers (different threads) and a single consumer (one thread!).
      Returns:
      A MPSC queue which may be unbounded.

    • newMpscQueue

      public static <T> Queue<T> newMpscQueue(int maxCapacity)
      Create a new Queue which is safe to use for multiple producers (different threads) and a single consumer (one thread!).

    • newMpscQueue

      public static <T> Queue<T> newMpscQueue(int chunkSize, int maxCapacity)
      Create a new Queue which is safe to use for multiple producers (different threads) and a single consumer (one thread!). The queue will grow and shrink its capacity in units of the given chunk size.

    • newSpscQueue

      public static <T> Queue<T> newSpscQueue()
      Create a new Queue which is safe to use for single producer (one thread!) and a single consumer (one thread!).

    • newFixedMpscQueue

      public static <T> Queue<T> newFixedMpscQueue(int capacity)
      Create a new Queue which is safe to use for multiple producers (different threads) and a single consumer (one thread!) with the given fixes capacity.

    • newFixedMpscUnpaddedQueue

      public static <T> Queue<T> newFixedMpscUnpaddedQueue(int capacity)
      Create a new un-padded Queue which is safe to use for multiple producers (different threads) and a single consumer (one thread!) with the given fixes capacity.
      This should be preferred to newFixedMpscQueue(int) when the queue is not to be heavily contended.

    • newFixedMpmcQueue

      public static <T> Queue<T> newFixedMpmcQueue(int capacity)
      Create a new Queue which is safe to use for multiple producers (different threads) and multiple consumers with the given fixes capacity.

    • getClassLoader

      public static ClassLoader getClassLoader(Class<?> clazz)
      Return the ClassLoader for the given Class.

    • getContextClassLoader

      public static ClassLoader getContextClassLoader()
      Return the context ClassLoader for the current Thread.

    • getSystemClassLoader

      public static ClassLoader getSystemClassLoader()
      Return the system ClassLoader.

    • newConcurrentDeque

      public static <C> Deque<C> newConcurrentDeque()
      Returns a new concurrent Deque.

    • threadLocalRandom

      @Deprecated public static Random threadLocalRandom()
      Deprecated.
      Use ThreadLocalRandom.current() instead.
      Return a Random which is not-threadsafe and so can only be used from the same thread.

    • splittableRandomNextBytes

      public static void splittableRandomNextBytes(SplittableRandom rng, byte[] data)

    • isWindows0

      private static boolean isWindows0()

    • isOsx0

      private static boolean isOsx0()

    • maybeSuperUser0

      private static boolean maybeSuperUser0()

    • unsafeUnavailabilityCause0

      private static Throwable unsafeUnavailabilityCause0()

    • isJ9Jvm

      public static boolean isJ9Jvm()
      Returns true if the running JVM is either IBM J9 or Eclipse OpenJ9, false otherwise.

    • isJ9Jvm0

      private static boolean isJ9Jvm0()

    • isIkvmDotNet

      public static boolean isIkvmDotNet()
      Returns true if the running JVM is IKVM.NET, false otherwise.

    • isIkvmDotNet0

      private static boolean isIkvmDotNet0()

    • getMaxDirectMemorySizeArgPattern

      private static Pattern getMaxDirectMemorySizeArgPattern()

    • estimateMaxDirectMemory

      public static long estimateMaxDirectMemory()
      Compute an estimate of the maximum amount of direct memory available to this JVM.

      The computation is not cached, so you probably want to use maxDirectMemory() instead.

      This will produce debug log output when called.

      Returns:
      The estimated max direct memory, in bytes.

    • tmpdir0

      private static File tmpdir0()

    • toDirectory

      private static File toDirectory(String path)

    • bitMode0

      private static int bitMode0()

    • addressSize0

      private static int addressSize0()

    • byteArrayBaseOffset0

      private static long byteArrayBaseOffset0()

    • equalsSafe

      private static boolean equalsSafe(byte[] bytes1, int startPos1, byte[] bytes2, int startPos2, int length)

    • isZeroSafe

      private static boolean isZeroSafe(byte[] bytes, int startPos, int length)

    • hashCodeAsciiSafe

      static int hashCodeAsciiSafe(byte[] bytes, int startPos, int length)
      Package private for testing purposes only!

    • normalizedArch

      public static String normalizedArch()

    • normalizedOs

      public static String normalizedOs()

    • normalizedLinuxClassifiers

      public static Set<String> normalizedLinuxClassifiers()

    • createTempFile

      public static File createTempFile(String prefix, String suffix, File directory) throws IOException
      Throws:
      IOException

    • addClassifier

      private static void addClassifier(Set<String> dest, String... maybeClassifiers)
      Adds only those classifier strings to dest which are present in allowed.
      Parameters:
      dest - destination set
      maybeClassifiers - potential classifiers to add

    • isAllowedClassifier

      private static boolean isAllowedClassifier(String classifier)

    • normalizeOsReleaseVariableValue

      private static String normalizeOsReleaseVariableValue(String value)

    • normalize

      private static String normalize(String value)

    • normalizeArch

      private static String normalizeArch(String value)

    • normalizeOs

      private static String normalizeOs(String value)

    • isJfrEnabled

      public static boolean isJfrEnabled()
      Check if JFR events are supported on this platform.