Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source
   * Copyright 2008, Red Hat, Inc., and individual contributors
   * by the @authors tag. See the copyright.txt in the distribution for a
   * full listing of individual contributors.
   *
   * 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.jboss.weld.util.annotated;
 
 import java.util.Set;
 
 
 
 public abstract class ForwardingWeldClass<T> extends ForwardingWeldAnnotated<T, Class<T>> implements EnhancedAnnotatedType<T> {
 
     @Override
     protected abstract EnhancedAnnotatedType<T> delegate();
 
     public Collection<EnhancedAnnotatedMethod<?, ? super T>> getDeclaredEnhancedMethods() {
         return delegate().getDeclaredEnhancedMethods();
     }
 
     public <M> EnhancedAnnotatedMethod<M, ?> getDeclaredEnhancedMethod(MethodSignature signature) {
         return delegate().getDeclaredEnhancedMethod(signature);
     }
 
     public Set<AnnotatedConstructor<T>> getConstructors() {
         return delegate().getConstructors();
     }
 
     public Set<AnnotatedMethod<? super T>> getMethods() {
         return delegate().getMethods();
     }
 
     public Set<AnnotatedField<? super T>> getFields() {
         return delegate().getFields();
     }
 
     public Collection<EnhancedAnnotatedConstructor<T>> getEnhancedConstructors(Class<? extends AnnotationannotationType) {
         return delegate().getEnhancedConstructors(annotationType);
     }
 
         return delegate().getEnhancedConstructors();
     }
 
     public Collection<EnhancedAnnotatedField<?, ?>> getEnhancedFields(Class<? extends AnnotationannotationType) {
         return delegate().getEnhancedFields(annotationType);
     }
 
     public Collection<EnhancedAnnotatedMethod<?, ? super T>> getEnhancedMethods(Class<? extends AnnotationannotationType) {
         return delegate().getEnhancedMethods(annotationType);
     }
 
         return delegate().getNoArgsEnhancedConstructor();
     }
 
     public Collection<EnhancedAnnotatedMethod<?, ? super T>> getEnhancedMethods() {
         return delegate().getEnhancedMethods();
     }
 
     public Collection<EnhancedAnnotatedField<?, ? super T>> getDeclaredEnhancedFields(Class<? extends AnnotationannotationType) {
         return delegate().getDeclaredEnhancedFields(annotationType);
     }
 
     public Collection<EnhancedAnnotatedField<?, ? super T>> getDeclaredEnhancedFields() {
         return delegate().getDeclaredEnhancedFields();
     }
 
     public Collection<EnhancedAnnotatedMethod<?, ? super T>> getDeclaredEnhancedMethods(Class<? extends AnnotationannotationType) {
         return delegate().getDeclaredEnhancedMethods(annotationType);
     }
 
     public Collection<EnhancedAnnotatedMethod<?, ? super T>> getDeclaredEnhancedMethodsWithAnnotatedParameters(Class<? extends AnnotationannotationType) {
         return delegate().getDeclaredEnhancedMethodsWithAnnotatedParameters(annotationType);
     }
    public Collection<EnhancedAnnotatedField<?, ? super T>> getEnhancedFields() {
        return delegate().getEnhancedFields();
    }
    @Deprecated
    public EnhancedAnnotatedMethod<?, ?> getEnhancedMethod(Method method) {
        return delegate().getEnhancedMethod(method);
    }
    public <M> EnhancedAnnotatedMethod<M, ?> getEnhancedMethod(MethodSignature signature) {
        return delegate().getEnhancedMethod(signature);
    }
    public EnhancedAnnotatedType<? super T> getEnhancedSuperclass() {
        return delegate().getEnhancedSuperclass();
    }
    public boolean isLocalClass() {
        return delegate().isLocalClass();
    }
    public boolean isMemberClass() {
        return delegate().isMemberClass();
    }
    public boolean isAnonymousClass() {
        return delegate().isAnonymousClass();
    }
    @Override
    public boolean isParameterizedType() {
        return delegate().isParameterizedType();
    }
    public boolean isAbstract() {
        return delegate().isAbstract();
    }
    public boolean isEnum() {
        return delegate().isEnum();
    }
    public boolean isSerializable() {
        return delegate().isSerializable();
    }
    @Deprecated
    public EnhancedAnnotatedMethod<?, ?> getDeclaredEnhancedMethod(Method method) {
        return delegate().getDeclaredEnhancedMethod(method);
    }
    public <F> EnhancedAnnotatedField<F, ?> getDeclaredEnhancedField(String fieldName) {
        return delegate().getDeclaredEnhancedField(fieldName);
    }
    public <M> EnhancedAnnotatedMethod<M, ?> getDeclaredEnhancedMethod(MethodSignature signatureEnhancedAnnotatedType<M> expectedReturnType) {
        return delegate().getDeclaredEnhancedMethod(signature);
    }
        return delegate().getDeclaredEnhancedConstructor(signature);
    }
    public <U> EnhancedAnnotatedType<? extends U> asEnhancedSubclass(EnhancedAnnotatedType<U> clazz) {
        return delegate().asEnhancedSubclass(clazz);
    }
    public <S> S cast(Object object) {
        return delegate().<S>cast(object);
    }
    public boolean isEquivalent(Class<?> clazz) {
        return delegate().isEquivalent(clazz);
    }
    public String getSimpleName() {
        return delegate().getSimpleName();
    }
    public Collection<AnnotationgetDeclaredMetaAnnotations(Class<? extends AnnotationmetaAnnotationType) {
        return delegate().getDeclaredMetaAnnotations(metaAnnotationType);
    }
    public boolean isDiscovered() {
        return delegate().isDiscovered();
    }
    @Override
    public SlimAnnotatedType<T> slim() {
        return delegate().slim();
    }
    @Override
    public Collection<EnhancedAnnotatedMethod<?, ? super T>> getEnhancedMethodsWithAnnotatedParameters(Class<? extends AnnotationannotationType) {
        return delegate().getEnhancedMethodsWithAnnotatedParameters(annotationType);
    }
New to GrepCode? Check out our FAQ X