ClassMetaData.java

/*
 * Copyright 2004-2009 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.compass.core.config.binding.metadata;

import java.util.Map;
import java.util.Set;

/**
 * A class meta data interface allowing to access the actual class metadata.
 *
 * @author kimchy
 */
public interface ClassMetaData {

    /**
     * Return the name of the underlying class.
     */
    String getClassName();

    /**
     * Return whether the underlying class represents an interface.
     */
    boolean isInterface();

    /**
     * Return whether the underlying class is marked as abstract.
     */
    boolean isAbstract();

    /**
     * Return whether the underlying class represents a concrete class,
     * i.e. neither an interface nor an abstract class.
     */
    boolean isConcrete();

    /**
     * Determine whether the underlying class is independent,
     * i.e. whether it is a top-level class or a nested class
     * (static inner class) that can be constructed independent
     * from an enclosing class.
     */
    boolean isIndependent();

    /**
     * Return whether the underlying class has an enclosing class
     * (i.e. the underlying class is an inner/nested class or
     * a local class within a method).
     * <p>If this method returns <code>false</code>, then the
     * underlying class is a top-level class.
     */
    boolean hasEnclosingClass();

    /**
     * Return the name of the enclosing class of the underlying class,
     * or <code>null</code> if the underlying class is a top-level class.
     */
    String getEnclosingClassName();

    /**
     * Return whether the underlying class has a super class.
     */
    boolean hasSuperClass();

    /**
     * Return the name of the super class of the underlying class,
     * or <code>null</code> if there is no super class defined.
     */
    String getSuperClassName();

    /**
     * Return the name of all interfaces that the underlying class
     * implements, or an empty array if there are none.
     */
    String[] getInterfaceNames();

    /**
     * Return the names of all annotation types defined on the underlying class.
     * @return the annotation type names
     */
    Set<String> getAnnotationTypes();

    /**
     * Determine whether the underlying class has an annotation of the given
     * type defined.
     * @param annotationType the annotation type to look for
     * @return whether a matching annotation is defined
     */
    boolean hasAnnotation(String annotationType);

    /**
     * Return the names of all meta-annotation types defined on the
     * given annotation type of the underlying class.
     * @return the meta-annotation type names
     */
    Set<String> getMetaAnnotationTypes(String annotationType);

    /**
     * Determine whether the underlying class has an annotation that
     * is itself annotated with the meta-annotation of the given type.
     * @param metaAnnotationType the meta-annotation type to look for
     * @return whether a matching meta-annotation is defined
     */
    boolean hasMetaAnnotation(String metaAnnotationType);

    /**
     * Retrieve the attributes of the annotation of the given type,
     * if any (i.e. if defined on the underlying class).
     * @param annotationType the annotation type to look for
     * @return a Map of attributes, with the attribute name as key
     * (e.g. "value") and the defined attribute value as Map value.
     * This return value will be <code>null</code> if no matching
     * annotation is defined.
     */
    Map<String, Object> getAnnotationAttributes(String annotationType);
}