code: public T newInstance(Object... parameters) {
          Constructor<T> constructor = m_constructor;
          if (m_loadConstructor) {
              Class<?>[] parameterTypes = new Class[parameters.length];
              for (int i = 0; i < parameters.length; ++i) {
                  parameterTypes[i] = parameters[i] == null ? null : parameters[i].getClass();
              }
              constructor = findConstructor(parameterTypes);
          }
          if (constructor != null) {
              try {
                  return constructor.newInstance(parameters);
              } catch (InstantiationException | IllegalAccessException | IllegalArgumentException
                      | InvocationTargetException e) {
                  m_errorHandler.handle(
                          "Unable to construct " + m_proClass.getName() + " with parameters: "
                                  + Arrays.toString(parameters),
                          e instanceof InvocationTargetException ? e.getCause() : e);
              }
          }
          return null;
      }
docs: Construct a new instance of the pro class using {@code parameters}. If the constructor fails the configured
  {@link ErrorHandler} will be invoked. If a constructor was not selected by {@link #useConstructorFor(Class...)}
  then the constructor will be selected using the {@link Class} of each {@code parameter}. If there isn't an exact
  type match the first constructor found where all parameter types can be assigned to the constructors parameter
  types will be used. This makes passing {@code null} in as a parameter dangerous since that can be passed in for
  any object
  
  @param parameters array of parameters to pass to the constructor
  @return new instance of {@code T} or {@code null} if the class or constructor could not be found
  @see Constructor#newInstance(Object...)