Java 类javax.el.ELResolver 实例源码

private ELContext createELContext(final ELResolver resolver, final FunctionMapper functionMapper, final VariableMapper variableMapper) {

        return new ELContext() {
            @Override
            public ELResolver getELResolver() {
                return resolver;
            }

            @Override
            public FunctionMapper getFunctionMapper() {
                return functionMapper;
            }

            @Override
            public VariableMapper getVariableMapper() {
                return variableMapper;
            }
        };
    }

@Override
public void setValue(EvaluationContext ctx, Object value)
        throws ELException {
    Target t = getTarget(ctx);
    ctx.setPropertyResolved(false);
    ELResolver resolver = ctx.getELResolver();

    // coerce to the expected type
    Class<?> targetClass = resolver.getType(ctx, t.base, t.property);
    if (COERCE_TO_ZERO == true
            || !isAssignable(value, targetClass)) {
        resolver.setValue(ctx, t.base, t.property,
                ELSupport.coerceToType(value, targetClass));
    } else {
        resolver.setValue(ctx, t.base, t.property, value);
    }
    if (!ctx.isPropertyResolved()) {
        throw new PropertyNotFoundException(MessageFactory.get(
                "error.resolver.unhandled", t.base, t.property));            
    }
}

public JasperELResolver(List<ELResolver> appResolvers) {
    appResolversSize = appResolvers.size();
    resolvers = new ELResolver[appResolversSize + 7];
    size = 0;

    add(new ImplicitObjectELResolver());
    for (ELResolver appResolver : appResolvers) {
        add(appResolver);
    }
    add(new MapELResolver());
    add(new ResourceBundleELResolver());
    add(new ListELResolver());
    add(new ArrayELResolver());
    add(new BeanELResolver());
    add(new ScopedAttributeELResolver());
}

private void doTestConstructor(int count) throws Exception {

        List<ELResolver> list = new ArrayList<ELResolver>();
        for (int i = 0; i < count; i++) {
            list.add(new ImplicitObjectELResolver());
        }

        JasperELResolver resolver = new JasperELResolver(list);


        Assert.assertEquals(Integer.valueOf(count),
                getField("appResolversSize", resolver));
        Assert.assertEquals(7 + count,
                ((ELResolver[])getField("resolvers", resolver)).length);
        Assert.assertEquals(Integer.valueOf(7 + count),
                getField("size", resolver));
    }

public Comp(
  ELResolver   resolver,
  ELContext    context,
  Locale       locale,
  String       property,
  SortStrength sortStrength)
{
  _resolver = resolver;
  _context  = context;

  // use Collator as comparator whenever locale or strength is available,
  // so sorting is natural to that locale.
  if (locale != null || sortStrength != null)
  {
    if (locale != null)
      _collator = Collator.getInstance(locale);
    else
      _collator = Collator.getInstance();

    if (sortStrength != null)
      _collator.setStrength(sortStrength.getStrength());
  }
  else
  {
    _collator = null;
  }

  _prop = property;
}

public Object getValue(EvaluationContext ctx) throws ELException {
    Object base = this.children[0].getValue(ctx);
    int propCount = this.jjtGetNumChildren();
    int i = 1;
    Object property = null;
    ELResolver resolver = ctx.getELResolver();
    while (base != null && i < propCount) {
        property = this.children[i].getValue(ctx);
        if (property == null) {
            return null;
        } else {
            ctx.setPropertyResolved(false);
            base = resolver.getValue(ctx, base, property);
        }
        i++;
    }
    return base;
}

private ELResolver createELResolver() {
    this.instantiated = true;
    if (this.resolver == null) {
        CompositeELResolver r = new CompositeELResolver();
        r.add(new ImplicitObjectELResolver());
        for (Iterator itr = this.resolvers.iterator(); itr.hasNext();) {
            r.add((ELResolver) itr.next());
        }
        r.add(new MapELResolver());
        r.add(new ResourceBundleELResolver());
        r.add(new ListELResolver());
        r.add(new ArrayELResolver());   
        r.add(new BeanELResolver());
        r.add(new ScopedAttributeELResolver());
        this.resolver = r;
    }
    return this.resolver;
}

@Override
public void setValue(EvaluationContext ctx, Object value)
        throws ELException {
    Target t = getTarget(ctx);
    ctx.setPropertyResolved(false);
    ELResolver resolver = ctx.getELResolver();

    // coerce to the expected type
    Class<?> targetClass = resolver.getType(ctx, t.base, t.property);
    if (COERCE_TO_ZERO == true
            || !isAssignable(value, targetClass)) {
        resolver.setValue(ctx, t.base, t.property,
                ELSupport.coerceToType(value, targetClass));
    } else {
        resolver.setValue(ctx, t.base, t.property, value);
    }
    if (!ctx.isPropertyResolved()) {
        throw new PropertyNotFoundException(MessageFactory.get(
                "error.resolver.unhandled", t.base, t.property));            
    }
}

public JasperELResolver(List<ELResolver> appResolvers) {
    appResolversSize = appResolvers.size();
    resolvers = new ELResolver[appResolversSize + 7];
    size = 0;

    add(new ImplicitObjectELResolver());
    for (ELResolver appResolver : appResolvers) {
        add(appResolver);
    }
    add(new MapELResolver());
    add(new ResourceBundleELResolver());
    add(new ListELResolver());
    add(new ArrayELResolver());
    add(new BeanELResolver());
    add(new ScopedAttributeELResolver());
}

private void doTestConstructor(int count) throws Exception {

        List<ELResolver> list = new ArrayList<ELResolver>();
        for (int i = 0; i < count; i++) {
            list.add(new ImplicitObjectELResolver());
        }

        JasperELResolver resolver = new JasperELResolver(list);


        Assert.assertEquals(Integer.valueOf(count),
                getField("appResolversSize", resolver));
        Assert.assertEquals(7 + count,
                ((ELResolver[])getField("resolvers", resolver)).length);
        Assert.assertEquals(Integer.valueOf(7 + count),
                getField("size", resolver));
    }

@Override
public void setValue(EvaluationContext ctx, Object value) throws ELException {
    Target t = getTarget(ctx);
    ctx.setPropertyResolved(false);
    ELResolver resolver = ctx.getELResolver();

    // coerce to the expected type
    Class<?> targetClass = resolver.getType(ctx, t.base, t.property);
    if (COERCE_TO_ZERO == true || !isAssignable(value, targetClass)) {
        resolver.setValue(ctx, t.base, t.property, ELSupport.coerceToType(value, targetClass));
    } else {
        resolver.setValue(ctx, t.base, t.property, value);
    }
    if (!ctx.isPropertyResolved()) {
        throw new PropertyNotFoundException(MessageFactory.get("error.resolver.unhandled", t.base, t.property));
    }
}

public JasperELResolver(List<ELResolver> appResolvers) {
    appResolversSize = appResolvers.size();
    resolvers = new ELResolver[appResolversSize + 7];
    size = 0;

    add(new ImplicitObjectELResolver());
    for (ELResolver appResolver : appResolvers) {
        add(appResolver);
    }
    add(new MapELResolver());
    add(new ResourceBundleELResolver());
    add(new ListELResolver());
    add(new ArrayELResolver());
    add(new BeanELResolver());
    add(new ScopedAttributeELResolver());
}

private static void registerJSFELResolver(ClassLoader loader) {
   // Register JSFELResolver
   Class<?> factory = null;
   try {
      factory = loader.loadClass("javax.faces.FactoryFinder");
   } catch (ClassNotFoundException e) {
      return;
   }
   if (factory != null) {
      Object instance = Reflects.forMethod().invokeStaticMethod(factory, "getFactory",
            new Object[] { String.class, "javax.faces.application.ApplicationFactory" });
      if (instance != null) {
         Object context = Reflects.forMethod().invokeMethod(instance, "getApplication", new Object[] {});
         if (context != null) {
            Reflects.forMethod().invokeMethod(context, "addELResolver",
                  new Object[] { ELResolver.class, new UnifiedResourceELResolver() });
         }
      }
   }
}

private static void registerJSPELResolver(ClassLoader loader, ServletContext servletContext) {
   if (servletContext == null) {
      throw new RuntimeException("Register JSP EL Resolver failed, servletContext couldn't be null.");
   }
   // Register JSPELResolver
   Class<?> factory = null;
   try {
      factory = loader.loadClass("javax.servlet.jsp.JspFactory");
   } catch (ClassNotFoundException e) {
      return;
   }
   if (factory != null) {
      Object instance = Reflects.forMethod().invokeStaticMethod(factory, "getDefaultFactory", new Object[] {});
      if (instance != null) {
         Object context = Reflects.forMethod().invokeMethod(instance, "getJspApplicationContext",
               new Object[] { ServletContext.class, servletContext });
         if (context != null) {
            Reflects.forMethod().invokeMethod(context, "addELResolver",
                  new Object[] { ELResolver.class, new UnifiedResourceELResolver() });
         }
      }
   }
}

@Override
public void setValue(EvaluationContext ctx, Object value)
        throws ELException {
    Target t = getTarget(ctx);
    ctx.setPropertyResolved(false);
    ELResolver resolver = ctx.getELResolver();

    // coerce to the expected type
    Class<?> targetClass = resolver.getType(ctx, t.base, t.property);
    if (COERCE_TO_ZERO == true
            || !isAssignable(value, targetClass)) {
        resolver.setValue(ctx, t.base, t.property,
                ELSupport.coerceToType(value, targetClass));
    } else {
        resolver.setValue(ctx, t.base, t.property, value);
    }
    if (!ctx.isPropertyResolved()) {
        throw new PropertyNotFoundException(MessageFactory.get(
                "error.resolver.unhandled", t.base, t.property));            
    }
}

public JasperELResolver(List<ELResolver> appResolvers) {
    appResolversSize = appResolvers.size();
    resolvers = new ELResolver[appResolversSize + 7];
    size = 0;

    add(new ImplicitObjectELResolver());
    for (ELResolver appResolver : appResolvers) {
        add(appResolver);
    }
    add(new MapELResolver());
    add(new ResourceBundleELResolver());
    add(new ListELResolver());
    add(new ArrayELResolver());
    add(new BeanELResolver());
    add(new ScopedAttributeELResolver());
}

private void doTestConstructor(int count) throws Exception {

        List<ELResolver> list = new ArrayList<ELResolver>();
        for (int i = 0; i < count; i++) {
            list.add(new ImplicitObjectELResolver());
        }

        JasperELResolver resolver = new JasperELResolver(list);


        Assert.assertEquals(Integer.valueOf(count),
                getField("appResolversSize", resolver));
        Assert.assertEquals(7 + count,
                ((ELResolver[])getField("resolvers", resolver)).length);
        Assert.assertEquals(Integer.valueOf(7 + count),
                getField("size", resolver));

    }

private ELResolver getELResolver() {

    if (elResolver == null) {
        // Create a CompositeELResolver
        CompositeELResolver celResolver = new CompositeELResolver();

        celResolver.add(new ImplicitObjectELResolver());
        // Add ELResolvers registered in JspApplicationContext
        JspApplicationContextImpl jaContext = getJspApplicationContext();
        Iterator<ELResolver> it = jaContext.getELResolvers();
        while (it.hasNext()) {
            celResolver.add(it.next());
        }
        ELResolver streamELResolver =
            getExpressionFactory(this).getStreamELResolver();
        if (streamELResolver != null) {
            celResolver.add(streamELResolver);
        }
        celResolver.add(new StaticFieldELResolver());
        celResolver.add(new MapELResolver());
        celResolver.add(new ResourceBundleELResolver());
        celResolver.add(new ListELResolver());
        celResolver.add(new ArrayELResolver());
        celResolver.add(new BeanELResolver());
        celResolver.add(new ScopedAttributeELResolver());
        elResolver = celResolver;
    }
    return elResolver;
}

@Override
public void setValue(EvaluationContext ctx, Object value)
        throws ELException {
    Target t = getTarget(ctx);
    ctx.setPropertyResolved(false);
    ELResolver resolver = ctx.getELResolver();

    // coerce to the expected type
    Class<?> targetClass = resolver.getType(ctx, t.base, t.property);
    if (COERCE_TO_ZERO == true
            || !isAssignable(value, targetClass)) {
        resolver.setValue(ctx, t.base, t.property,
                ELSupport.coerceToType(value, targetClass));
    } else {
        resolver.setValue(ctx, t.base, t.property, value);
    }
    if (!ctx.isPropertyResolved()) {
        throw new PropertyNotFoundException(MessageFactory.get(
                "error.resolver.unhandled", t.base, t.property));            
    }
}

public JasperELResolver(List<ELResolver> appResolvers) {
    appResolversSize = appResolvers.size();
    resolvers = new ELResolver[appResolversSize + 7];
    size = 0;

    add(new ImplicitObjectELResolver());
    for (ELResolver appResolver : appResolvers) {
        add(appResolver);
    }
    add(new MapELResolver());
    add(new ResourceBundleELResolver());
    add(new ListELResolver());
    add(new ArrayELResolver());
    add(new BeanELResolver());
    add(new ScopedAttributeELResolver());
}

private void doTestConstructor(int count) throws Exception {

        List<ELResolver> list = new ArrayList<ELResolver>();
        for (int i = 0; i < count; i++) {
            list.add(new ImplicitObjectELResolver());
        }

        JasperELResolver resolver = new JasperELResolver(list);


        Assert.assertEquals(Integer.valueOf(count),
                getField("appResolversSize", resolver));
        Assert.assertEquals(7 + count,
                ((ELResolver[])getField("resolvers", resolver)).length);
        Assert.assertEquals(Integer.valueOf(7 + count),
                getField("size", resolver));
    }

private void doTestConstructor(int count) throws Exception {

        List<ELResolver> list = new ArrayList<ELResolver>();
        for (int i = 0; i < count; i++) {
            list.add(new ImplicitObjectELResolver());
        }

        JasperELResolver resolver = new JasperELResolver(list);


        Assert.assertEquals(Integer.valueOf(count),
                getField("appResolversSize", resolver));
        Assert.assertEquals(7 + count,
                ((ELResolver[])getField("resolvers", resolver)).length);
        Assert.assertEquals(Integer.valueOf(7 + count),
                getField("size", resolver));
    }

@Override
public void setValue(EvaluationContext ctx, Object value)
        throws ELException {
    Target t = getTarget(ctx);
    ctx.setPropertyResolved(false);
    ELResolver resolver = ctx.getELResolver();

    // coerce to the expected type
    Class<?> targetClass = resolver.getType(ctx, t.base, t.property);
    if (COERCE_TO_ZERO == true
            || !isAssignable(value, targetClass)) {
        resolver.setValue(ctx, t.base, t.property,
                ELSupport.coerceToType(value, targetClass));
    } else {
        resolver.setValue(ctx, t.base, t.property, value);
    }
    if (!ctx.isPropertyResolved()) {
        throw new PropertyNotFoundException(MessageFactory.get(
                "error.resolver.unhandled", t.base, t.property));            
    }
}

public static ELResolver getDefaultResolver() {
    if (Constants.IS_SECURITY_ENABLED) {
        CompositeELResolver defaultResolver = new CompositeELResolver();
        defaultResolver.add(new MapELResolver());
        defaultResolver.add(new ResourceBundleELResolver());
        defaultResolver.add(new ListELResolver());
        defaultResolver.add(new ArrayELResolver());
        defaultResolver.add(new BeanELResolver());
        return defaultResolver;
    } else {
        return DefaultResolver;
    }
}

public JasperELResolver(List<ELResolver> appResolvers) {
    appResolversSize = appResolvers.size();
    resolvers = new ELResolver[appResolversSize + 7];
    size = 0;

    add(new ImplicitObjectELResolver());
    for (ELResolver appResolver : appResolvers) {
        add(appResolver);
    }
    add(new MapELResolver());
    add(new ResourceBundleELResolver());
    add(new ListELResolver());
    add(new ArrayELResolver());
    add(new BeanELResolver());
    add(new ScopedAttributeELResolver());
}

@Override
public ELResolver getELResolver() {
  if (elResolver == null) {
    final CompositeELResolver resolver = new CompositeELResolver();
    customResolver = new CompositeELResolver();
    resolver.add(customResolver);
    resolver.add(factory.getStreamELResolver());
    resolver.add(new StaticFieldELResolver());
    resolver.add(new MapELResolver());
    resolver.add(new ResourceBundleELResolver());
    resolver.add(new ListELResolver());
    resolver.add(new ArrayELResolver());
    resolver.add(new BeanELResolverEx());
    elResolver = resolver;
  }

  return elResolver;
}

private ExtendedELContext createELContext(final ELResolver resolver, final FunctionMapper functionMapper,
        final VariableMapper variableMapper, final ConstantResolver constantResolver) {
    return new ExtendedELContext() {
        @Override
        public ELResolver getELResolver() {
            return resolver;
        }

        @Override
        public FunctionMapper getFunctionMapper() {
            return functionMapper;
        }

        @Override
        public VariableMapper getVariableMapper() {
            return variableMapper;
        }

        @Override
        public ConstantResolver getConstantResolver() {
            return constantResolver;
        }
    };
}

@Nonnull
ELContext createELContext(@Nonnull final VariableMapper variableMapper) {
    return new ELContext() {
        @Nonnull
        @Override
        public ELResolver getELResolver() {
            return elResolver;
        }

        @Nonnull
        @Override
        public FunctionMapper getFunctionMapper() {
            return functionMapper;
        }

        @Nonnull
        @Override
        public VariableMapper getVariableMapper() {
            return variableMapper;
        }
    };
}

@Override
public void setValue(EvaluationContext ctx, Object value)
        throws ELException {
    Target t = getTarget(ctx);
    ctx.setPropertyResolved(false);
    ELResolver resolver = ctx.getELResolver();

    // coerce to the expected type
    Class<?> targetClass = resolver.getType(ctx, t.base, t.property);
    if (COERCE_TO_ZERO == true
            || !isAssignable(value, targetClass)) {
        resolver.setValue(ctx, t.base, t.property,
                ELSupport.coerceToType(value, targetClass));
    } else {
        resolver.setValue(ctx, t.base, t.property, value);
    }
    if (!ctx.isPropertyResolved()) {
        throw new PropertyNotFoundException(MessageFactory.get(
                "error.resolver.unhandled", t.base, t.property));            
    }
}

private ELResolver createELResolver() {
    this.instantiated = true;
    if (this.resolver == null) {
        CompositeELResolver r = new CompositeELResolver();
        r.add(new ImplicitObjectELResolver());
        for (Iterator<ELResolver> itr = this.resolvers.iterator();
                itr.hasNext();) {
            r.add(itr.next());
        }
        r.add(new MapELResolver());
        r.add(new ResourceBundleELResolver());
        r.add(new ListELResolver());
        r.add(new ArrayELResolver());    
        r.add(new BeanELResolver());
        r.add(new ScopedAttributeELResolver());
        this.resolver = r;
    }
    return this.resolver;
}

@Override
public ELResolver getOwbELResolver() {
    WebBeansContext old = null;
    boolean exit = false;
    try { // just some safety around this but should be very very rare
        WebBeansContext.currentInstance();
    } catch (final IllegalStateException ise) {
        old = ThreadSingletonServiceImpl.enter(appContext.getWebBeansContext());
        exit = true;
    }
    try {
        return new WebBeansELResolver();
    } finally {
        if (exit) {
            ThreadSingletonServiceImpl.exit(old);
        }
    }
}

public static void initializeServletContext(final ServletContext servletContext, final WebBeansContext context) {
    if (context == null || !context.getBeanManagerImpl().isInUse()) {
        return;
    }

    final ELAdaptor elAdaptor = context.getService(ELAdaptor.class);
    final ELResolver resolver = elAdaptor.getOwbELResolver();
    //Application is configured as JSP
    if (context.getOpenWebBeansConfiguration().isJspApplication()) {
        logger.debug("Application is configured as JSP. Adding EL Resolver.");

        setJspELFactory(servletContext, resolver);
    }

    // Add BeanManager to the 'javax.enterprise.inject.spi.BeanManager' servlet context attribute
    servletContext.setAttribute(BeanManager.class.getName(), context.getBeanManagerImpl());
}

@Override
public ELResolver getELResolver() 
{
    CompositeELResolver result = new CompositeELResolver();
    result.add(new MapELResolver());
    result.add(new ArrayELResolver());
    result.add(new ListELResolver());
    result.add(new BeanELResolver());
    return result;
}

public Test()
{
    Configuration configuration = new DefaultConfiguration() {
        public ResourceReader getResourceReader() {
            return new FileResourceReader(resourceDir, ".html");
        }
        @Override
        public ELResolver getELResolver() {
            CompositeELResolver result = new CompositeELResolver();
            result.add(new JsonElResolver());
            result.add(super.getELResolver());
            return result;
        }
    };

    compiler = new FaceletsCompilerImp(configuration);
}

@Override
public Object getValue(EvaluationContext ctx) throws ELException {
    Object base = this.children[0].getValue(ctx);
    int propCount = this.jjtGetNumChildren();
    int i = 1;
    Object suffix = null;
    ELResolver resolver = ctx.getELResolver();
    while (base != null && i < propCount) {
        suffix = this.children[i].getValue(ctx);
        if (i + 1 < propCount &&
                (this.children[i+1] instanceof AstMethodParameters)) {
            AstMethodParameters mps =
                (AstMethodParameters) this.children[i+1];
            // This is a method
            Object[] paramValues = mps.getParameters(ctx);
            base = resolver.invoke(ctx, base, suffix,
                    getTypesFromValues(paramValues), paramValues);
            i+=2;
        } else {
            // This is a property
            if (suffix == null) {
                return null;
            }

            ctx.setPropertyResolved(false);
            base = resolver.getValue(ctx, base, suffix);
            i++;
        }
    }
    if (!ctx.isPropertyResolved()) {
        throw new PropertyNotFoundException(MessageFactory.get(
                "error.resolver.unhandled", base, suffix));            
    }
    return base;
}

private ELResolver createELResolver() {
    this.instantiated = true;
    if (this.resolver == null) {
        CompositeELResolver r = new JasperELResolver(this.resolvers);
        this.resolver = r;
    }
    return this.resolver;
}

@Override
public void addELResolver(ELResolver resolver) throws IllegalStateException {
    if (resolver == null) {
        throw new IllegalArgumentException("ELResolver was null");
    }
    if (this.instantiated) {
        throw new IllegalStateException(
                "cannot call addELResolver after the first request has been made");
    }
    this.resolvers.add(resolver);
}

public static ELResolver getDefaultResolver() {
    if (Constants.IS_SECURITY_ENABLED) {
        CompositeELResolver defaultResolver = new CompositeELResolver();
        defaultResolver.add(new MapELResolver());
        defaultResolver.add(new ResourceBundleELResolver());
        defaultResolver.add(new ListELResolver());
        defaultResolver.add(new ArrayELResolver());
        defaultResolver.add(new BeanELResolver());
        return defaultResolver;
    } else {
        return DefaultResolver;
    }
}

@Override
public synchronized void add(ELResolver elResolver) {
    super.add(elResolver);

    if (resolvers.length > size) {
        resolvers[size] = elResolver;
    } else {
        ELResolver[] nr = new ELResolver[size + 1];
        System.arraycopy(resolvers, 0, nr, 0, size);
        nr[size] = elResolver;

        resolvers = nr;
    }
    size ++;
}

/**
 * Creates the list of FeatureDescriptors.
 */
private List<FeatureDescriptor> _createFeatureDescriptorList()
{
  ArrayList<FeatureDescriptor> list = new ArrayList<FeatureDescriptor>();
  // FeatureDescriptor for "requestContext"
  FeatureDescriptor requestContext = new FeatureDescriptor();
  requestContext.setName(RequestContext.VARIABLE_NAME);
  // TODO translate this
  requestContext.setShortDescription("Trinidad RequestContext");
  requestContext.setValue(ELResolver.RESOLVABLE_AT_DESIGN_TIME, false);
  requestContext.setValue(ELResolver.TYPE, RequestContext.class);
  list.add(requestContext);

  // FeatureDescriptor for "pageFlowScope"
  FeatureDescriptor pageFlowScope = new FeatureDescriptor();
  pageFlowScope.setName(PAGE_FLOW_SCOPE_VARIABLE_NAME);
  // TODO translate this
  pageFlowScope.setShortDescription("Trinidad Page Flow Scope");
  pageFlowScope.setValue(ELResolver.RESOLVABLE_AT_DESIGN_TIME, false);
  pageFlowScope.setValue(ELResolver.TYPE, Map.class);
  list.add(pageFlowScope);

  // FeatureDescriptor for "processScope"
  FeatureDescriptor processScope = new FeatureDescriptor();
  processScope.setName(PAGE_FLOW_SCOPE_VARIABLE_NAME);
  // TODO translate this
  pageFlowScope.setShortDescription(
    "Backwards compatibility alias for Trinidad Page Flow Scope");
  processScope.setExpert(true);
  processScope.setValue(ELResolver.RESOLVABLE_AT_DESIGN_TIME, false);
  processScope.setValue(ELResolver.TYPE, Map.class);
  list.add(pageFlowScope);

  return Collections.unmodifiableList(list);
}