1 /*
  2  * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.  Oracle designates this
  8  * particular file as subject to the "Classpath" exception as provided
  9  * by Oracle in the LICENSE file that accompanied this code.
 10  *
 11  * This code is distributed in the hope that it will be useful, but WITHOUT
 12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 14  * version 2 for more details (a copy is included in the LICENSE file that
 15  * accompanied this code).
 16  *
 17  * You should have received a copy of the GNU General Public License version
 18  * 2 along with this work; if not, write to the Free Software Foundation,
 19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 20  *
 21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 22  * or visit www.oracle.com if you need additional information or have any
 23  * questions.
 24  */
 25 
 26 package jdk.internal.value;
 27 
 28 import jdk.internal.access.JavaLangReflectAccess;
 29 import jdk.internal.access.SharedSecrets;
 30 import jdk.internal.misc.PreviewFeatures;
 31 import jdk.internal.vm.annotation.IntrinsicCandidate;
 32 
 33 import java.lang.reflect.Field;
 34 import java.lang.reflect.Modifier;
 35 
 36 /**
 37  * Utilities to access package private methods of java.lang.Class and related reflection classes.
 38  */
 39 public final class ValueClass {
 40     private static final JavaLangReflectAccess JLRA = SharedSecrets.getJavaLangReflectAccess();
 41 
 42     /// {@return whether this field type may store value objects}
 43     /// This excludes primitives and includes Object.
 44     public static boolean isValueObjectCompatible(Class<?> fieldType) {
 45         return PreviewFeatures.isEnabled()
 46                 && !fieldType.isPrimitive() // non-primitive
 47                 && (!fieldType.isIdentity() || fieldType == Object.class); // AVC or Object
 48     }
 49 
 50     /// {@return whether an object of this exact class is a value object}
 51     /// This excludes abstract value classes and primitives.
 52     public static boolean isConcreteValueClass(Class<?> clazz) {
 53         return clazz.isValue() && !Modifier.isAbstract(clazz.getModifiers());
 54     }
 55 
 56     /**
 57      * {@return {@code true} if the field is NullRestricted}
 58      */
 59     public static boolean isNullRestrictedField(Field f) {
 60         return JLRA.isNullRestrictedField(f);
 61     }
 62 
 63     /**
 64      * Allocate an array of a value class type with components that behave in
 65      * the same way as a {@link jdk.internal.vm.annotation.NullRestricted}
 66      * field.
 67      * <p>
 68      * Because these behaviors are not specified by Java SE, arrays created with
 69      * this method should only be used by internal JDK code for experimental
 70      * purposes and should not affect user-observable outcomes.
 71      *
 72      * @throws IllegalArgumentException if {@code componentType} is not a
 73      *                                  value class type.
 74      */
 75     @IntrinsicCandidate
 76     public static native Object[] newNullRestrictedAtomicArray(Class<?> componentType,
 77                                                                int length, Object initVal);
 78 
 79     @IntrinsicCandidate
 80     public static native Object[] newNullRestrictedNonAtomicArray(Class<?> componentType,
 81                                                                   int length, Object initVal);
 82 
 83     @IntrinsicCandidate
 84     public static native Object[] newNullableAtomicArray(Class<?> componentType,
 85                                                          int length);
 86 
 87     /**
 88      * {@return true if the given array is a flat array}
 89      */
 90     @IntrinsicCandidate
 91     public static native boolean isFlatArray(Object array);
 92 
 93     public static Object[] copyOfSpecialArray(Object[] array, int from, int to) {
 94         return copyOfSpecialArray0(array, from, to);
 95     }
 96 
 97     private static native Object[] copyOfSpecialArray0(Object[] array, int from, int to);
 98 
 99     /**
100      * {@return true if the given array is a null-restricted array}
101      */
102     @IntrinsicCandidate
103     public static native boolean isNullRestrictedArray(Object array);
104 
105     /**
106      * {@return true if the given array uses a layout designed for atomic accesses }
107      */
108     @IntrinsicCandidate
109     public static native boolean isAtomicArray(Object array);
110 }