Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright [2013] [www.rapidpm.org / Sven Ruppert (sven.ruppert@rapidpm.org)]
   *
   *    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.rapidpm.data.table;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 
 import static com.google.common.base.Preconditions.checkNotNull;

Abstrakte Basisklasse für globale Typ-Registries.

Parameters:
<A> Annototationstyp.
<T> Rückgabetyp der Registry.
Author(s):
Alexander Vos
 
 public abstract class AbstractRegistry<A extends Annotation, T> {
     private static final Logger logger = Logger.getLogger(AbstractRegistry.class);
     private static final PackageClassLoader packageClassLoader = new PackageClassLoader();

    
Klassenmap.
 
     protected final Map<Class<?>, Class<? extends T>> classMap = Maps.newHashMap();
    
Packagenamen zum Suchen nach Klassen.
 
     protected final Set<StringpkgNameSet = Sets.newHashSet();

    
Standardobjekt für die Rückgabe bei einem Fehlerfall.
 
     protected T defaultObject;

    
Erstellt eine Typ-Registry.

Parameters:
annotationClass Annototationstyp.
defaultObject Standardobjekt für die Rückgabe bei einem Fehlerfall (kann null sein).
scanCurrentPackage true, wenn das Package der konkreten Registry rekursiv durchsucht werden soll.
packageNames Weitere Packetnamen zum Suchen nach Klassen.
Throws:
java.lang.NullPointerException Wenn annotationClass null ist.
See also:
AbstractRegistry(java.lang.Class,java.lang.Object)
AbstractRegistry(java.lang.Class)
 
     public AbstractRegistry(final Class<A> annotationClassfinal T defaultObject,
                             final boolean scanCurrentPackagefinal String... packageNames) {
         checkNotNull(annotationClass);
         if (scanCurrentPackage) {
             .add(getClass().getPackage().getName());
         }
         .addAll(Arrays.asList(packageNames));
         init(annotationClass);
         this. = defaultObject;
     }

    
Erstellt eine Typ-Registry und durchsucht das Package der konkreten Registry rekursiv nach Klassen.

Parameters:
annotationClass Annototationstyp.
defaultObject Standardobjekt für die Rückgabe bei einem Fehlerfall (kann null sein).
Throws:
java.lang.NullPointerException Wenn annotationClass null ist.
See also:
AbstractRegistry(java.lang.Class,java.lang.Object,boolean,java.lang.String[])
AbstractRegistry(java.lang.Class)
 
     public AbstractRegistry(final Class<A> annotationClassfinal T defaultObject) {
         this(annotationClassdefaultObjecttrue);
     }

    
Erstellt eine Typ-Registry ohne Standardobjekt und durchsucht das Package der konkreten Registry rekursiv nach Klassen.

    public AbstractRegistry(final Class<A> annotationClass) {
        this(annotationClassnulltrue);
    }

    
Muss die zuständige Klasse der Annotation annotation zurück geben.

Parameters:
annotation Annotation.
Returns:
Zuständige Klasse der Annotation.
    protected abstract Class<?> getClass(A annotation);

    
Initialisiert die Typ-Registry.

Parameters:
annotationClass Annototationstyp.
    public void init(final Class<A> annotationClass) {
        for (final String packageName : ) {
            final List<Classclasses = .getClasses(packageName);
            for (final Class clazz : classes) {
                final Annotation annotation = clazz.getAnnotation(annotationClass);
                if (annotation != null) {
                    .put(getClass(annotationClass.cast(annotation)), clazz);
                } else {
                    if (.isDebugEnabled()) {
                        .debug("Class ohne Annotation " + annotationClass.getSimpleName() + ": " + clazz.getSimpleName());
                    }
                }
            }
        }
    }

    
Gibt die Klassenmap dieser Typ-Registry zurück.

Returns:
Klassenmap dieser Typ-Registry.
See also:
getClasses()
getValues()
getClassFor(java.lang.Class)
    public Map<Class<?>, Class<? extends T>> getClassMap() {
        return ;
    }

    
Gibt die Klassen dieser Typ-Registry zurück.

Returns:
Klassen dieser Typ-Registry.
See also:
getClassMap()
getValues()
getClassFor(java.lang.Class)
    public Set<Class<?>> getClasses() {
        return .keySet();
    }

    
Gibt die Klassen-Instanzen dieser Typ-Registry zurück.

Returns:
Klassenwerte dieser Typ-Registry.
See also:
getClassMap()
getClasses()
getClassFor(java.lang.Class)
    public Collection<Class<? extends T>> getValues() {
        return .values();
    }

    
Gibt das Standardobjekt dieser Typ-Registry zurück.

Returns:
Das Standardobjekt dieser Typ-Registry.
See also:
setDefaultObject(java.lang.Object)
    public T getDefaultObject() {
        return ;
    }

    
Setzt das Standardobjekt dieser Typ-Registry.

Parameters:
defaultObject Das Standardobjekt (kann null sein).
See also:
getDefaultObject()
    public void setDefaultObject(final T defaultObject) {
        this. = defaultObject;
    }

    
Prüft, ob diese Typ-Registry die angegebene Klassen-Instanz besitzt.

Parameters:
clazz Typklasse.
Returns:
true, wenn diese Typ-Registry die angegebene Klasse besitzt, sonst false.
See also:
getClassMap()
getClasses()
getClassFor(java.lang.Class)
    public boolean hasClassFor(final Class<?> clazz) {
        if (.containsKey(clazz)) {
            return true;
        } else if (clazz.isPrimitive()) {
            final Class boxedType = ClassUtils.primitive2boxed(clazz);
            return .containsKey(boxedType);
        }
        return false;
    }

    
Gibt die Klassen-Instanz der angegebenen Klasse dieser Typ-Registry zurück.

Parameters:
clazz Typklasse.
Returns:
Die Klassen-Instanz oder null, wenn die Klasse nicht existiert.
See also:
getClassMap()
getClasses()
hasClassFor(java.lang.Class)
    public T getClassFor(final Class<?> clazz) {
        T result = ;
        Class<? extends T> aClass = .get(clazz);
        if (aClass == null && clazz.isPrimitive()) {
            final Class boxedType = ClassUtils.primitive2boxed(clazz);
            aClass = .get(boxedType);
        }
        if (aClass != null) {
            try {
                result = aClass.newInstance();
            } catch (InstantiationException | IllegalAccessException e) {
                .error(e);
            }
        } else {
            .error("Keine Klasse registriert für: " + clazz);
            if (.isDebugEnabled()) {
                .debug("Rückgabewert: " + );
            }
        }
        return result;
    }
New to GrepCode? Check out our FAQ X