Decisions according to generic types

  final IEntityView getEntityView(Object trigger) throws BusinessLogicException {
    IEntityView result = _entityView;
    if (trigger instanceof EntityManagerPlug2<?>) {
      // check if currently set entity view matches the generic declaration

      // get generic interfaces from trigger object
      for (Type possibleType : trigger.getClass().getGenericInterfaces()) {
        if ((result = getEntityViewFromGenericType(possibleType, _entityView)) != null) {
          if (_entityView == null) {
            _entityView = result;
          }
          return result;
        }
      }
      // get generic interfaces from trigger object super class
      Class<? extends Object> clazz = trigger.getClass();
      Type possibleType = clazz.getGenericSuperclass();

      while (possibleType != null && !(possibleType instanceof ParameterizedType)) {
        clazz = clazz.getSuperclass();
        if (clazz != null) {
          possibleType = clazz.getGenericSuperclass();
        } else {
          possibleType = null;
        }
      }

      if (possibleType != null) {
        if ((result = getEntityViewFromGenericType(possibleType, _entityView)) != null) {
          if (_entityView == null) {
            _entityView = result;
          }
          return result;
        }
      }
      _logger.error("No implementation found for {}.", trigger);
    } else if (result != null && !result.getClass().getSimpleName().endsWith(ALL_JOY_BUO_EXT_EMA)) {
      // check if currently set entity view matches the old rule of being a "AllJoyBuoExtEma" if not set result to null?
      result = null;
    }
    return result;
  }




  IEntityView getEntityViewFromGenericType(Type possibleType, IEntityView defaultView) throws BusinessLogicException {
    try {
      if (possibleType instanceof ParameterizedType) {
        // loop thru all implemented interfaces
        for (Type parameterizedType : ((ParameterizedType)possibleType).getActualTypeArguments()) {
          // check all parameterized types
          if (IEntityView.class.isAssignableFrom((Class<?>)parameterizedType)) {
            // take first implemented interface using IEntityView
            @SuppressWarnings("unchecked")
            Class<IEntityView> typeClass = (Class<IEntityView>)parameterizedType;
            if (typeClass.equals(IEntityView.class)) {
              // if given interface is the IEntityView itself use old logic ...
                return constructor.newInstance(getSession());
              } else {
                return defaultView;
              }
            } else if (typeClass.isInterface()) {
              if (defaultView == null || !typeClass.isAssignableFrom(defaultView.getClass())) {
                // if parameter type is a interface use EntityViewFactory
                if (_logger.isDebugEnabled()) {
                  _logger.debug("Creating new entity view implementation from interface {}.", typeClass);
                }
                return EntityViewFactory.create(typeClass, getSession());
              } else {
                return defaultView;
              }
            } else if (defaultView == null || !typeClass.equals(defaultView.getClass())) {
              // if parameter type is a classic use it's constructor
              Constructor<IEntityView> constructor = typeClass.getConstructor(SessionContext.class);
              if (_logger.isDebugEnabled()) {
                _logger.debug("Creating classic implementation {} thru constuctor.", typeClass);
              }
              return constructor.newInstance(getSession());
            }
          }
        }
      }
      return defaultView;
    } catch (Exception e) {
      throw BusinessLogicException.wrap(e);
    }
  }