Correspondance par rapport à la hiérarchie de type

Question

Supposons que nous ayons une hiérarchie de type fixe, par ex. comme représenté ci-dessous. C'est un arbre bien défini, où chaque nœud a un parent (à l'exception de la racine).

Chaque type a une action qui lui est associée, qui doit être effectuée lors de l'appariement avec succès. Cela ne pas signifie qu'une action correspond à une méthode sur ledit type. C'est juste une association arbitraire.

Quels sont les moyens intelligents de faire correspondre les objets à une hiérarchie de types? Chaque objet doit être comparé au type le plus spécifique possible. Les objets sont déjà créés.

Answer 1

Utilisez la recherche récursive depuis la racine. Une fois qu'aucune correspondance ne peut être trouvée chez les enfants, rappelez-vous l'objet correspondant si son niveau est plus profond que la dernière correspondance.

pseudocode:

class MatchContext { 
     public int level; 
     public Node result; 
    } 

    public boolean match(Node object, int level, MatchContext ctx) { 
     if (no match) 
      return false; 
     boolean found = false; 
     for (all children in object) { 
      if (match(child, level + 1, ctx)) 
       found = true; 
     } 
     if (!found && level > ctx.level) { 
      ctx.level = level; 
      ctx.result = this; 
     } 
     return found; 
    } 

invoquons comme ceci:

MatchContext ctx; 
    if (match(root, 0, ctx)) 
     myAction(ctx.result); 

Answer 2

La hiérarchie de l'arborescence est déjà implicitement défini par la déclaration des classes. Vous avez juste besoin de traverser une branche d'arbre via les appels chaînés getSuperclass() au type que vous voulez rechercher. Les nœuds d'arbre (types de classe) peuvent alors être organisés en utilisant une simple carte de hachage.

Étant donné que la hiérarchie de type est statique, vous pouvez le définir comme ENUM

public enum ClassType{ 
    HOMINOIDEA(HOMINOIDEA.class), 
    HOMINIDAE(HOMINIDAE.class), 
    HOMININAE(HOMININAE.class), 
    //and so on 
    UNKNOWN(null);  

    private static final Map<Class<?>, ClassType> typesMap = new HashMap<>(); 
    public final Class<?> type; 

    static{ 
     for (ClassType classType : EnumSet.allOf(ClassType.class)){    
      if(classType.type != null){ 
       typesMap.put(classType.type, classType); 
      } 
     } 
    } 

    private ClassType(Class<?> type){ 
     this.type = type;   
    } 

    public static ClassType getClassTypeOf(Class<?> type){ 
     for(Class<?> lookupType = type; lookupType != null; lookupType = lookupType.getSuperclass()){ 
      ClassType classType = typesMap.get(lookupType); 
      if(classType != null){ 
       return classType; 
      } 
     }  
     return UNKNOWN; 
    } 
} 

puis cartographier les types de classes aux actions:

public static void main(String[] args){ 
    EnumMap<ClassType, Action> actionMap = new EnumMap<>(ClassType.class); 
    actionMap.put(ClassType.HOMININAE, new HomininaeAction()); 
    Homininae h = new Homininae(); 
    actionMap.get(ClassType.getClassTypeOf(h)); //action associated with homininaes  
} 

---

Voici un autre dans certains termes version plus dynamique

public class ActionDispatcher { 
    private final Map<Class<?>, Consumer<?>> actionMap = new HashMap<>(); 

    public <T> void registerAction(Class<T> type, Consumer<? super T> action){ 
     actionMap.put(type, action); 
    }  

    @SuppressWarnings("unchecked") 
    public void dispatchActionFor(Object object){ 
     Consumer<Object> action = ((Consumer<Object>)getActionFor(object.getClass())); 
     if(action != null){ 
      action.accept(object); 
     } 
    } 

    private Consumer<?> getActionFor(Class<?> type){   
     for(Class<?> lookupType = type; lookupType != null; lookupType = lookupType.getSuperclass()){ 
      Consumer<?> action = actionMap.get(lookupType); 
      if(action != null){ 
       return action; 
      } 
     }  
     return null; 
    } 

    //demo 
    public static void main(String[] args){ 
     ActionDispatcher dispatcher = new ActionDispatcher(); 
     dispatcher.registerAction(Number.class, n -> System.out.println("number: " + n)); 
     dispatcher.registerAction(Double.class, d -> System.out.println("double: " + d)); 
     dispatcher.registerAction(String.class, s -> System.out.println("first char: " + s.charAt(0))); 
     dispatcher.registerAction(Object.class, o -> System.out.println("object: " + o)); 

     dispatcher.dispatchActionFor(new Integer(3)); 
     dispatcher.dispatchActionFor(new Double(3.0)); 
     dispatcher.dispatchActionFor("string"); 
     dispatcher.dispatchActionFor(new Thread()); 
    } 

} 

La sortie de c'est:

number: 3 
double: 3.0 
first char: s 
object: Thread[Thread-0,5,main]