1 /* 2 * Copyright (c) 2022, 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 package java.lang.classfile; 26 27 import java.lang.classfile.AttributeMapper.AttributeStability; 28 import java.lang.classfile.attribute.*; 29 import jdk.internal.classfile.impl.AbstractAttributeMapper.*; 30 import jdk.internal.javac.PreviewFeature; 31 32 /** 33 * Attribute mappers for standard classfile attributes. 34 * <p> 35 * Unless otherwise specified, mappers returned by each method 36 * do not permit multiple attribute instances in a given location. 37 * <p> 38 * The most stable {@link AttributeStability#STATELESS STATELESS} mappers are: 39 * <ul> 40 * <li>{@link #deprecated()} 41 * <li>{@link #moduleResolution()} 42 * <li>{@link #sourceDebugExtension()} 43 * <li>{@link #synthetic()} 44 * </ul> 45 * 46 * The mappers with {@link AttributeStability#CP_REFS CP_REFS} stability are: 47 * <ul> 48 * <li>{@link #annotationDefault()} 49 * <li>{@link #bootstrapMethods()} 50 * <li>{@link #code()} 51 * <li>{@link #compilationId()} 52 * <li>{@link #constantValue()} 53 * <li>{@link #enclosingMethod()} 54 * <li>{@link #exceptions()} 55 * <li>{@link #innerClasses()} 56 * <li>{@link #methodParameters()} 57 * <li>{@link #module()} 58 * <li>{@link #moduleHashes()} 59 * <li>{@link #moduleMainClass()} 60 * <li>{@link #modulePackages()} 61 * <li>{@link #moduleTarget()} 62 * <li>{@link #nestHost()} 63 * <li>{@link #nestMembers()} 64 * <li>{@link #permittedSubclasses()} 65 * <li>{@link #record()} 66 * <li>{@link #runtimeInvisibleAnnotations()} 67 * <li>{@link #runtimeInvisibleParameterAnnotations()} 68 * <li>{@link #runtimeVisibleAnnotations()} 69 * <li>{@link #runtimeVisibleParameterAnnotations()} 70 * <li>{@link #signature()} 71 * <li>{@link #sourceFile()} 72 * <li>{@link #sourceId()} 73 * </ul> 74 * 75 * The mappers with {@link AttributeStability#LABELS LABELS} stability are: 76 * <ul> 77 * <li>{@link #characterRangeTable()} 78 * <li>{@link #lineNumberTable()} 79 * <li>{@link #localVariableTable()} 80 * <li>{@link #localVariableTypeTable()} 81 * </ul> 82 * 83 * The {@link AttributeStability#UNSTABLE UNSTABLE} mappers are: 84 * <ul> 85 * <li>{@link #runtimeInvisibleTypeAnnotations()} 86 * <li>{@link #runtimeVisibleTypeAnnotations()} 87 * </ul> 88 * 89 * @see AttributeMapper 90 * 91 * @since 22 92 */ 93 @PreviewFeature(feature = PreviewFeature.Feature.CLASSFILE_API) 94 public final class Attributes { 95 96 /** AnnotationDefault */ 97 public static final String NAME_ANNOTATION_DEFAULT = "AnnotationDefault"; 98 99 /** BootstrapMethods */ 100 public static final String NAME_BOOTSTRAP_METHODS = "BootstrapMethods"; 101 102 /** CharacterRangeTable */ 103 public static final String NAME_CHARACTER_RANGE_TABLE = "CharacterRangeTable"; 104 105 /** Code */ 106 public static final String NAME_CODE = "Code"; 107 108 /** CompilationID */ 109 public static final String NAME_COMPILATION_ID = "CompilationID"; 110 111 /** ConstantValue */ 112 public static final String NAME_CONSTANT_VALUE = "ConstantValue"; 113 114 /** Deprecated */ 115 public static final String NAME_DEPRECATED = "Deprecated"; 116 117 /** EnclosingMethod */ 118 public static final String NAME_ENCLOSING_METHOD = "EnclosingMethod"; 119 120 /** Exceptions */ 121 public static final String NAME_EXCEPTIONS = "Exceptions"; 122 123 /** InnerClasses */ 124 public static final String NAME_INNER_CLASSES = "InnerClasses"; 125 126 /** LineNumberTable */ 127 public static final String NAME_LINE_NUMBER_TABLE = "LineNumberTable"; 128 129 /** LocalVariableTable */ 130 public static final String NAME_LOCAL_VARIABLE_TABLE = "LocalVariableTable"; 131 132 /** LocalVariableTypeTable */ 133 public static final String NAME_LOCAL_VARIABLE_TYPE_TABLE = "LocalVariableTypeTable"; 134 135 /** MethodParameters */ 136 public static final String NAME_METHOD_PARAMETERS = "MethodParameters"; 137 138 /** Module */ 139 public static final String NAME_MODULE = "Module"; 140 141 /** ModuleHashes */ 142 public static final String NAME_MODULE_HASHES = "ModuleHashes"; 143 144 /** ModuleMainClass */ 145 public static final String NAME_MODULE_MAIN_CLASS = "ModuleMainClass"; 146 147 /** ModulePackages */ 148 public static final String NAME_MODULE_PACKAGES = "ModulePackages"; 149 150 /** ModuleResolution */ 151 public static final String NAME_MODULE_RESOLUTION = "ModuleResolution"; 152 153 /** ModuleTarget */ 154 public static final String NAME_MODULE_TARGET = "ModuleTarget"; 155 156 /** NestHost */ 157 public static final String NAME_NEST_HOST = "NestHost"; 158 159 /** NestMembers */ 160 public static final String NAME_NEST_MEMBERS = "NestMembers"; 161 162 /** PermittedSubclasses */ 163 public static final String NAME_PERMITTED_SUBCLASSES = "PermittedSubclasses"; 164 165 /** Record */ 166 public static final String NAME_RECORD = "Record"; 167 168 /** RuntimeInvisibleAnnotations */ 169 public static final String NAME_RUNTIME_INVISIBLE_ANNOTATIONS = "RuntimeInvisibleAnnotations"; 170 171 /** RuntimeInvisibleParameterAnnotations */ 172 public static final String NAME_RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS = "RuntimeInvisibleParameterAnnotations"; 173 174 /** RuntimeInvisibleTypeAnnotations */ 175 public static final String NAME_RUNTIME_INVISIBLE_TYPE_ANNOTATIONS = "RuntimeInvisibleTypeAnnotations"; 176 177 /** RuntimeVisibleAnnotations */ 178 public static final String NAME_RUNTIME_VISIBLE_ANNOTATIONS = "RuntimeVisibleAnnotations"; 179 180 /** RuntimeVisibleParameterAnnotations */ 181 public static final String NAME_RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS = "RuntimeVisibleParameterAnnotations"; 182 183 /** RuntimeVisibleTypeAnnotations */ 184 public static final String NAME_RUNTIME_VISIBLE_TYPE_ANNOTATIONS = "RuntimeVisibleTypeAnnotations"; 185 186 /** Signature */ 187 public static final String NAME_SIGNATURE = "Signature"; 188 189 /** SourceDebugExtension */ 190 public static final String NAME_SOURCE_DEBUG_EXTENSION = "SourceDebugExtension"; 191 192 /** SourceFile */ 193 public static final String NAME_SOURCE_FILE = "SourceFile"; 194 195 /** SourceID */ 196 public static final String NAME_SOURCE_ID = "SourceID"; 197 198 /** StackMapTable */ 199 public static final String NAME_STACK_MAP_TABLE = "StackMapTable"; 200 201 /** Synthetic */ 202 public static final String NAME_SYNTHETIC = "Synthetic"; 203 204 private Attributes() { 205 } 206 207 /** 208 * {@return Attribute mapper for the {@code AnnotationDefault} attribute} 209 * @since 23 210 */ 211 public static AttributeMapper<AnnotationDefaultAttribute> annotationDefault() { 212 return AnnotationDefaultMapper.INSTANCE; 213 } 214 215 /** 216 * {@return Attribute mapper for the {@code BootstrapMethods} attribute} 217 * @since 23 218 */ 219 public static AttributeMapper<BootstrapMethodsAttribute> bootstrapMethods() { 220 return BootstrapMethodsMapper.INSTANCE; 221 } 222 223 /** 224 * {@return Attribute mapper for the {@code CharacterRangeTable} attribute} 225 * The mapper permits multiple instances in a given location. 226 * @since 23 227 */ 228 public static AttributeMapper<CharacterRangeTableAttribute> characterRangeTable() { 229 return CharacterRangeTableMapper.INSTANCE; 230 } 231 232 /** 233 * {@return Attribute mapper for the {@code Code} attribute} 234 * @since 23 235 */ 236 public static AttributeMapper<CodeAttribute> code() { 237 return CodeMapper.INSTANCE; 238 } 239 240 /** 241 * {@return Attribute mapper for the {@code CompilationID} attribute} 242 * @since 23 243 */ 244 public static AttributeMapper<CompilationIDAttribute> compilationId() { 245 return CompilationIDMapper.INSTANCE; 246 } 247 248 /** 249 * {@return Attribute mapper for the {@code ConstantValue} attribute} 250 * @since 23 251 */ 252 public static AttributeMapper<ConstantValueAttribute> constantValue() { 253 return ConstantValueMapper.INSTANCE; 254 } 255 256 /** 257 * {@return Attribute mapper for the {@code Deprecated} attribute} 258 * The mapper permits multiple instances in a given location. 259 * @since 23 260 */ 261 public static AttributeMapper<DeprecatedAttribute> deprecated() { 262 return DeprecatedMapper.INSTANCE; 263 } 264 265 /** 266 * {@return Attribute mapper for the {@code EnclosingMethod} attribute} 267 * @since 23 268 */ 269 public static AttributeMapper<EnclosingMethodAttribute> enclosingMethod() { 270 return EnclosingMethodMapper.INSTANCE; 271 } 272 273 /** 274 * {@return Attribute mapper for the {@code Exceptions} attribute} 275 * @since 23 276 */ 277 public static AttributeMapper<ExceptionsAttribute> exceptions() { 278 return ExceptionsMapper.INSTANCE; 279 } 280 281 /** 282 * {@return Attribute mapper for the {@code InnerClasses} attribute} 283 * @since 23 284 */ 285 public static AttributeMapper<InnerClassesAttribute> innerClasses() { 286 return InnerClassesMapper.INSTANCE; 287 } 288 289 /** 290 * {@return Attribute mapper for the {@code LineNumberTable} attribute} 291 * The mapper permits multiple instances in a given location. 292 * @since 23 293 */ 294 public static AttributeMapper<LineNumberTableAttribute> lineNumberTable() { 295 return LineNumberTableMapper.INSTANCE; 296 } 297 298 /** 299 * {@return Attribute mapper for the {@code LocalVariableTable} attribute} 300 * The mapper permits multiple instances in a given location. 301 * @since 23 302 */ 303 public static AttributeMapper<LocalVariableTableAttribute> localVariableTable() { 304 return LocalVariableTableMapper.INSTANCE; 305 } 306 307 /** 308 * {@return Attribute mapper for the {@code LocalVariableTypeTable} attribute} 309 * The mapper permits multiple instances in a given location. 310 * @since 23 311 */ 312 public static AttributeMapper<LocalVariableTypeTableAttribute> localVariableTypeTable() { 313 return LocalVariableTypeTableMapper.INSTANCE; 314 } 315 316 /** 317 * {@return Attribute mapper for the {@code MethodParameters} attribute} 318 * @since 23 319 */ 320 public static AttributeMapper<MethodParametersAttribute> methodParameters() { 321 return MethodParametersMapper.INSTANCE; 322 } 323 324 /** 325 * {@return Attribute mapper for the {@code Module} attribute} 326 * @since 23 327 */ 328 public static AttributeMapper<ModuleAttribute> module() { 329 return ModuleMapper.INSTANCE; 330 } 331 332 /** 333 * {@return Attribute mapper for the {@code ModuleHashes} attribute} 334 * @since 23 335 */ 336 public static AttributeMapper<ModuleHashesAttribute> moduleHashes() { 337 return ModuleHashesMapper.INSTANCE; 338 } 339 340 /** 341 * {@return Attribute mapper for the {@code ModuleMainClass} attribute} 342 * @since 23 343 */ 344 public static AttributeMapper<ModuleMainClassAttribute> moduleMainClass() { 345 return ModuleMainClassMapper.INSTANCE; 346 } 347 348 /** 349 * {@return Attribute mapper for the {@code ModulePackages} attribute} 350 * @since 23 351 */ 352 public static AttributeMapper<ModulePackagesAttribute> modulePackages() { 353 return ModulePackagesMapper.INSTANCE; 354 } 355 356 /** 357 * {@return Attribute mapper for the {@code ModuleResolution} attribute} 358 * @since 23 359 */ 360 public static AttributeMapper<ModuleResolutionAttribute> moduleResolution() { 361 return ModuleResolutionMapper.INSTANCE; 362 } 363 364 /** 365 * {@return Attribute mapper for the {@code ModuleTarget} attribute} 366 * @since 23 367 */ 368 public static AttributeMapper<ModuleTargetAttribute> moduleTarget() { 369 return ModuleTargetMapper.INSTANCE; 370 } 371 372 /** 373 * {@return Attribute mapper for the {@code NestHost} attribute} 374 * @since 23 375 */ 376 public static AttributeMapper<NestHostAttribute> nestHost() { 377 return NestHostMapper.INSTANCE; 378 } 379 380 /** 381 * {@return Attribute mapper for the {@code NestMembers} attribute} 382 * @since 23 383 */ 384 public static AttributeMapper<NestMembersAttribute> nestMembers() { 385 return NestMembersMapper.INSTANCE; 386 } 387 388 /** 389 * {@return Attribute mapper for the {@code PermittedSubclasses} attribute} 390 * @since 23 391 */ 392 public static AttributeMapper<PermittedSubclassesAttribute> permittedSubclasses() { 393 return PermittedSubclassesMapper.INSTANCE; 394 } 395 396 /** 397 * {@return Attribute mapper for the {@code Record} attribute} 398 * @since 23 399 */ 400 public static AttributeMapper<RecordAttribute> record() { 401 return RecordMapper.INSTANCE; 402 } 403 404 /** 405 * {@return Attribute mapper for the {@code RuntimeInvisibleAnnotations} attribute} 406 * @since 23 407 */ 408 public static AttributeMapper<RuntimeInvisibleAnnotationsAttribute> runtimeInvisibleAnnotations() { 409 return RuntimeInvisibleAnnotationsMapper.INSTANCE; 410 } 411 412 /** 413 * {@return Attribute mapper for the {@code RuntimeInvisibleParameterAnnotations} attribute} 414 * @since 23 415 */ 416 public static AttributeMapper<RuntimeInvisibleParameterAnnotationsAttribute> runtimeInvisibleParameterAnnotations() { 417 return RuntimeInvisibleParameterAnnotationsMapper.INSTANCE; 418 } 419 420 /** 421 * {@return Attribute mapper for the {@code RuntimeInvisibleTypeAnnotations} attribute} 422 * @since 23 423 */ 424 public static AttributeMapper<RuntimeInvisibleTypeAnnotationsAttribute> runtimeInvisibleTypeAnnotations() { 425 return RuntimeInvisibleTypeAnnotationsMapper.INSTANCE; 426 } 427 428 /** 429 * {@return Attribute mapper for the {@code RuntimeVisibleAnnotations} attribute} 430 * @since 23 431 */ 432 public static AttributeMapper<RuntimeVisibleAnnotationsAttribute> runtimeVisibleAnnotations() { 433 return RuntimeVisibleAnnotationsMapper.INSTANCE; 434 } 435 436 /** 437 * {@return Attribute mapper for the {@code RuntimeVisibleParameterAnnotations} attribute} 438 * @since 23 439 */ 440 public static AttributeMapper<RuntimeVisibleParameterAnnotationsAttribute> runtimeVisibleParameterAnnotations() { 441 return RuntimeVisibleParameterAnnotationsMapper.INSTANCE; 442 } 443 444 /** 445 * {@return Attribute mapper for the {@code RuntimeVisibleTypeAnnotations} attribute} 446 * @since 23 447 */ 448 public static AttributeMapper<RuntimeVisibleTypeAnnotationsAttribute> runtimeVisibleTypeAnnotations() { 449 return RuntimeVisibleTypeAnnotationsMapper.INSTANCE; 450 } 451 452 /** 453 * {@return Attribute mapper for the {@code Signature} attribute} 454 * @since 23 455 */ 456 public static AttributeMapper<SignatureAttribute> signature() { 457 return SignatureMapper.INSTANCE; 458 } 459 460 /** 461 * {@return Attribute mapper for the {@code SourceDebugExtension} attribute} 462 * @since 23 463 */ 464 public static AttributeMapper<SourceDebugExtensionAttribute> sourceDebugExtension() { 465 return SourceDebugExtensionMapper.INSTANCE; 466 } 467 468 /** 469 * {@return Attribute mapper for the {@code SourceFile} attribute} 470 * @since 23 471 */ 472 public static AttributeMapper<SourceFileAttribute> sourceFile() { 473 return SourceFileMapper.INSTANCE; 474 } 475 476 /** 477 * {@return Attribute mapper for the {@code SourceID} attribute} 478 * @since 23 479 */ 480 public static AttributeMapper<SourceIDAttribute> sourceId() { 481 return SourceIDMapper.INSTANCE; 482 } 483 484 /** 485 * {@return Attribute mapper for the {@code StackMapTable} attribute} 486 * @since 23 487 */ 488 public static AttributeMapper<StackMapTableAttribute> stackMapTable() { 489 return StackMapTableMapper.INSTANCE; 490 } 491 492 /** 493 * {@return Attribute mapper for the {@code Synthetic} attribute} 494 * The mapper permits multiple instances in a given location. 495 * @since 23 496 */ 497 public static AttributeMapper<SyntheticAttribute> synthetic() { 498 return SyntheticMapper.INSTANCE; 499 } 500 }