/*
* Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package jdk.jfr;
import java.lang.annotation.Annotation;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import jdk.jfr.internal.JVMSupport;
import jdk.jfr.internal.MetadataRepository;
import jdk.jfr.internal.PlatformEventType;
import jdk.jfr.internal.Type;
import jdk.jfr.internal.Utils;
/**
* Describes an event, its fields, settings and annotations.
*
* @since 9
*/
public final class EventType {
private final PlatformEventType platformEventType;
private final List<String> UNCATEGORIZED = Collections.singletonList("Uncategorized");
private Map<String, ValueDescriptor> cache; // create lazy to avoid memory overhead
// helper constructor
EventType(PlatformEventType platformEventType) {
this.platformEventType = platformEventType;
}
/**
* Returns an immutable list of descriptors that describe the event fields of
* this event type.
*
* @return the list of field descriptors, not {@code null}
*/
public List<ValueDescriptor> getFields() {
return platformEventType.getFields();
}
/**
* Returns the field with the specified name, or {@code null} if it doesn't
* exist.
*
* @return a value descriptor that describes the field, or <code>null</code> if
* the field with the specified name doesn't exist
*
* @return a value descriptor, or <code>null</code> if it doesn't exist
*/
public ValueDescriptor getField(String name) {
Objects.requireNonNull(name);
if (cache == null) {
List<ValueDescriptor> fields = getFields();
Map<String, ValueDescriptor> newCache = new LinkedHashMap<String, ValueDescriptor>(fields.size());
for (ValueDescriptor v :fields) {
newCache.put(v.getName(), v);
}
cache = newCache;
}
return cache.get(name);
}
/**
* Returns an identifier for the event (for example,
* {@code "jdk.CPULoad"}).
* <p>
* The identifier is the fully qualified name of the event class, if not set using
* the {@link Name} annotation.
*
* @return the name, not {@code null}
*
* @see Name
*/
public String getName() {
return platformEventType.getName();
}
/**
* Returns a human-readable name (for example, {@code "CPU Load"}).
* <p>
* The label of an event class can be set with {@link Label}.
*
* @return the label, or {@code null} if a label is not set
*
* @see Label
*/
public String getLabel() {
return platformEventType.getLabel();
}
/**
* Returns a unique ID for this event type in the Java Virtual Machine (JVM).
*
* @return the ID that is used in the JVM
*/
public long getId() {
return platformEventType.getId();
}
/**
* Returns an immutable list of annotation elements for this event type.
*
* @return an immutable list of annotations or an empty list if no
* annotations exists, not {@code null}
*/
public List<AnnotationElement> getAnnotationElements() {
return platformEventType.getAnnotationElements();
}
/**
* Returns {@code true} if the event is enabled and at least one recording is
* running, {@code false} otherwise.
* <p>
* By default, the event is enabled. The event can be enabled or disabled by
* setting the enabled setting to {@code true} or {@code false}, programmatically or by using a
* configuration file. The event can also be disabled by annotating event with
* the {@code @Enabled(false)} annotation.
*
* @return true if event is enabled, false otherwise
*
* @see Enabled
* @see Recording#enable(Class)
*/
public boolean isEnabled() {
return platformEventType.isEnabled();
}
/**
* Returns a short sentence that describes the event class.
* <p>
* The description of an event class can be set with {@link Description}.
*
* @return the description, or {@code null} if no description exists
*
* @see Description
*/
public String getDescription() {
return platformEventType.getDescription();
}
/**
* Returns the first annotation for the specified type if an annotation
* element with the same name is directly present, otherwise {@code null}.
*
* @param <A> the type of the annotation to query for and return if present
* @param annotationClass the {@code Class} object that corresponds to the
* annotation type, not {@code null}
* @return this element's annotation for the specified annotation type if
* directly present, else {@code null}
*/
public <A extends Annotation> A getAnnotation(Class<A> annotationClass) {
Objects.requireNonNull(annotationClass);
return platformEventType.getAnnotation(annotationClass);
}
/**
* Returns the event type for an event class, or {@code null} if it doesn't
* exist.
*
* @param eventClass the event class, not {@code null}
* @return the event class, or null if class doesn't exist
*
* @throws IllegalArgumentException if {@code eventClass} is an abstract class
*
* @throws IllegalStateException if the class is annotated with
* {@code Registered(false)}, but not manually registered
*/
public static EventType getEventType(Class<? extends Event> eventClass) {
Objects.requireNonNull(eventClass);
Utils.ensureValidEventSubclass(eventClass);
JVMSupport.ensureWithInternalError();
return MetadataRepository.getInstance().getEventType(eventClass);
}
/**
* Returns an immutable list of the setting descriptors that describe the available
* event settings for this event type.
*
* @return the list of setting descriptors for this event type, not
* {@code null}
*/
public List<SettingDescriptor> getSettingDescriptors() {
return Collections.unmodifiableList(platformEventType.getSettings());
/**代码未完, 请加载全部代码(NowJava.com).**/