Esempio n. 1
0
 /// <summary>
 /// Attempts to set the value of the given property object on the given base object. If this
 /// resolver handles the given (base, property) pair, the propertyResolved property of the
 /// ELContext object must be set to true by the resolver, before returning. If this property is
 /// not true after this method is called, the caller can safely assume no value has been set.
 /// </summary>
 /// <param name="context">
 ///            The context of this evaluation. </param>
 /// <param name="base">
 ///            The base object whose property value is to be set, or null to set a top-level
 ///            variable. </param>
 /// <param name="property">
 ///            The property or variable to be set. </param>
 /// <param name="value">
 ///            The value to set the property or variable to. </param>
 /// <exception cref="NullPointerException">
 ///             if context is null </exception>
 /// <exception cref="PropertyNotFoundException">
 ///             if the given (base, property) pair is handled by this ELResolver but the
 ///             specified variable or property does not exist. </exception>
 /// <exception cref="PropertyNotWritableException">
 ///             if the given (base, property) pair is handled by this ELResolver but the
 ///             specified variable or property is not writable. </exception>
 /// <exception cref="ELException">
 ///             if an exception was thrown while attempting to set the property or variable. The
 ///             thrown exception must be included as the cause property of this exception, if
 ///             available. </exception>
 public abstract void setValue(ELContext context, object @base, object property, object value);
Esempio n. 2
0
 /// <summary>
 /// Attempts to resolve and invoke the given <code>method</code> on the given <code>base</code>
 /// object.
 ///
 /// <para>
 /// If this resolver handles the given (base, method) pair, the <code>propertyResolved</code>
 /// property of the <code>ELContext</code> object must be set to <code>true</code> by the
 /// resolver, before returning. If this property is not <code>true</code> after this method is
 /// called, the caller should ignore the return value.
 /// </para>
 ///
 /// <para>
 /// A default implementation is provided that returns null so that existing classes that extend
 /// ELResolver can continue to function.
 /// </para>
 /// </summary>
 /// <param name="context">
 ///            The context of this evaluation. </param>
 /// <param name="base">
 ///            The bean on which to invoke the method </param>
 /// <param name="method">
 ///            The simple name of the method to invoke. Will be coerced to a <code>String</code>. </param>
 /// <param name="paramTypes">
 ///            An array of Class objects identifying the method's formal parameter types, in
 ///            declared order. Use an empty array if the method has no parameters. Can be
 ///            <code>null</code>, in which case the method's formal parameter types are assumed
 ///            to be unknown. </param>
 /// <param name="params">
 ///            The parameters to pass to the method, or <code>null</code> if no parameters. </param>
 /// <returns> The result of the method invocation (<code>null</code> if the method has a
 ///         <code>void</code> return type). </returns>
 /// <exception cref="MethodNotFoundException">
 ///             if no suitable method can be found. </exception>
 /// <exception cref="ELException">
 ///             if an exception was thrown while performing (base, method) resolution. The thrown
 ///             exception must be included as the cause property of this exception, if available.
 ///             If the exception thrown is an <code>InvocationTargetException</code>, extract its
 ///             <code>cause</code> and pass it to the <code>ELException</code> constructor.
 /// @since 2.2 </exception>
 public virtual object invoke(ELContext context, object @base, object method, Type[] paramTypes, object[] @params)
 {
     return(null);
 }
Esempio n. 3
0
 /// <summary>
 /// Attempts to resolve the given property object on the given base object. If this resolver
 /// handles the given (base, property) pair, the propertyResolved property of the ELContext
 /// object must be set to true by the resolver, before returning. If this property is not true
 /// after this method is called, the caller should ignore the return value.
 /// </summary>
 /// <param name="context">
 ///            The context of this evaluation. </param>
 /// <param name="base">
 ///            The base object whose property value is to be returned, or null to resolve a
 ///            top-level variable. </param>
 /// <param name="property">
 ///            The property or variable to be resolved. </param>
 /// <returns> If the propertyResolved property of ELContext was set to true, then the result of the
 ///         variable or property resolution; otherwise undefined. </returns>
 /// <exception cref="NullPointerException">
 ///             if context is null </exception>
 /// <exception cref="PropertyNotFoundException">
 ///             if the given (base, property) pair is handled by this ELResolver but the
 ///             specified variable or property does not exist or is not readable. </exception>
 /// <exception cref="ELException">
 ///             if an exception was thrown while performing the property or variable resolution.
 ///             The thrown exception must be included as the cause property of this exception, if
 ///             available. </exception>
 public abstract object getValue(ELContext context, object @base, object property);
Esempio n. 4
0
 /// <summary>
 /// For a given base and property, attempts to determine whether a call to
 /// <seealso cref="setValue(ELContext, object, object, object)"/> will always fail. If this resolver
 /// handles the given (base, property) pair, the propertyResolved property of the ELContext
 /// object must be set to true by the resolver, before returning. If this property is not true
 /// after this method is called, the caller should ignore the return value.
 /// </summary>
 /// <param name="context">
 ///            The context of this evaluation. </param>
 /// <param name="base">
 ///            The base object whose property value is to be analyzed, or null to analyze a
 ///            top-level variable. </param>
 /// <param name="property">
 ///            The property or variable to return the read-only status for. </param>
 /// <returns> If the propertyResolved property of ELContext was set to true, then true if the
 ///         property is read-only or false if not; otherwise undefined. </returns>
 /// <exception cref="NullPointerException">
 ///             if context is null </exception>
 /// <exception cref="PropertyNotFoundException">
 ///             if the given (base, property) pair is handled by this ELResolver but the
 ///             specified variable or property does not exist. </exception>
 /// <exception cref="ELException">
 ///             if an exception was thrown while performing the property or variable resolution.
 ///             The thrown exception must be included as the cause property of this exception, if
 ///             available. </exception>
 public abstract bool isReadOnly(ELContext context, object @base, object property);
Esempio n. 5
0
 /// <summary>
 /// Parses an expression into a <seealso cref="MethodExpression"/> for later evaluation. Use this method
 /// for expressions that refer to methods. If the expression is a String literal, a
 /// MethodExpression is created, which when invoked, returns the String literal, coerced to
 /// expectedReturnType. An ELException is thrown if expectedReturnType is void or if the coercion
 /// of the String literal to the expectedReturnType yields an error (see Section "1.16 Type
 /// Conversion"). This method should perform syntactic validation of the expression. If in doing
 /// so it detects errors, it should raise an ELException.
 /// </summary>
 /// <param name="context">
 ///            The EL context used to parse the expression. The FunctionMapper and VariableMapper
 ///            stored in the ELContext are used to resolve functions and variables found in the
 ///            expression. They can be null, in which case functions or variables are not
 ///            supported for this expression. The object returned must invoke the same functions
 ///            and access the same variable mappings regardless of whether the mappings in the
 ///            provided FunctionMapper and VariableMapper instances change between calling
 ///            ExpressionFactory.createMethodExpression() and any method on MethodExpression.
 ///            Note that within the EL, the ${} and #{} syntaxes are treated identically. This
 ///            includes the use of VariableMapper and FunctionMapper at expression creation time.
 ///            Each is invoked if not null, independent of whether the #{} or ${} syntax is used
 ///            for the expression. </param>
 /// <param name="expression">
 ///            The expression to parse </param>
 /// <param name="expectedReturnType">
 ///            The expected return type for the method to be found. After evaluating the
 ///            expression, the MethodExpression must check that the return type of the actual
 ///            method matches this type. Passing in a value of null indicates the caller does not
 ///            care what the return type is, and the check is disabled. </param>
 /// <param name="expectedParamTypes">
 ///            The expected parameter types for the method to be found. Must be an array with no
 ///            elements if there are no parameters expected. It is illegal to pass null. </param>
 /// <returns> The parsed expression </returns>
 /// <exception cref="ELException">
 ///             Thrown if there are syntactical errors in the provided expression. </exception>
 /// <exception cref="NullPointerException">
 ///             if paramTypes is null. </exception>
 public abstract MethodExpression createMethodExpression(ELContext context, string expression, Type expectedReturnType, Type[] expectedParamTypes);
Esempio n. 6
0
 /// <summary>
 /// Evaluates the expression relative to the provided context, and returns true if a call to
 /// <seealso cref="setValue(ELContext, object)"/> will always fail.
 /// </summary>
 /// <param name="context">
 ///            The context of this evaluation. </param>
 /// <returns> true if the expression is read-only or false if not. </returns>
 /// <exception cref="NullPointerException">
 ///             if context is null. </exception>
 /// <exception cref="PropertyNotFoundException">
 ///             if one of the property resolutions failed because a specified variable or
 ///             property does not exist or is not readable. </exception>
 /// <exception cref="ELException">
 ///             if an exception was thrown while performing property or variable resolution. The
 ///             thrown exception must be included as the cause property of this exception, if
 ///             available. </exception>
 public abstract bool isReadOnly(ELContext context);
Esempio n. 7
0
 public override bool isReadOnly(ELContext context, object @base, object property)
 {
     return(this.readOnly);
 }
Esempio n. 8
0
 /// <summary>
 /// If a String literal is specified as the expression, returns the String literal coerced to the
 /// expected return type of the method signature. An ELException is thrown if expectedReturnType
 /// is void or if the coercion of the String literal to the expectedReturnType yields an error
 /// (see Section "1.16 Type Conversion" of the EL specification). If not a String literal,
 /// evaluates the expression relative to the provided context, invokes the method that was found
 /// using the supplied parameters, and returns the result of the method invocation. Any
 /// parameters passed to this method is ignored if isLiteralText() is true.
 /// </summary>
 /// <param name="context">
 ///            The context of this evaluation. </param>
 /// <param name="params">
 ///            The parameters to pass to the method, or null if no parameters. </param>
 /// <returns> the result of the method invocation (null if the method has a void return type). </returns>
 /// <exception cref="NullPointerException">
 ///             if context is null </exception>
 /// <exception cref="PropertyNotFoundException">
 ///             if one of the property resolutions failed because a specified variable or
 ///             property does not exist or is not readable. </exception>
 /// <exception cref="MethodNotFoundException">
 ///             if no suitable method can be found. </exception>
 /// <exception cref="ELException">
 ///             if a String literal is specified and expectedReturnType of the MethodExpression
 ///             is void or if the coercion of the String literal to the expectedReturnType yields
 ///             an error (see Section "1.16 Type Conversion"). </exception>
 /// <exception cref="ELException">
 ///             if an exception was thrown while performing property or variable resolution. The
 ///             thrown exception must be included as the cause property of this exception, if
 ///             available. If the exception thrown is an InvocationTargetException, extract its
 ///             cause and pass it to the ELException constructor. </exception>
 public abstract object invoke(ELContext context, object[] @params);
Esempio n. 9
0
 public override IEnumerator <FeatureDescriptor> getFeatureDescriptors(ELContext context, object @base)
 {
     return(null);
 }
Esempio n. 10
0
 public override Type getType(ELContext context, object @base, object property)
 {
     return(typeof(object));
 }
Esempio n. 11
0
 /// <summary>
 /// Evaluates the expression relative to the provided context, and returns the most general type
 /// that is acceptable for an object to be passed as the value parameter in a future call to the
 /// <seealso cref="setValue(ELContext, object)"/> method. This is not always the same as
 /// getValue().getClass(). For example, in the case of an expression that references an array
 /// element, the getType method will return the element type of the array, which might be a
 /// superclass of the type of the actual element that is currently in the specified array
 /// element.
 /// </summary>
 /// <param name="context">
 ///            The context of this evaluation. </param>
 /// <returns> the most general acceptable type; otherwise undefined. </returns>
 /// <exception cref="NullPointerException">
 ///             if context is null. </exception>
 /// <exception cref="PropertyNotFoundException">
 ///             if one of the property resolutions failed because a specified variable or
 ///             property does not exist or is not readable. </exception>
 /// <exception cref="ELException">
 ///             if an exception was thrown while performing property or variable resolution. The
 ///             thrown exception must be included as the cause property of this exception, if
 ///             available. </exception>
 public abstract Type getType(ELContext context);
Esempio n. 12
0
 /// <summary>
 /// Returns a <seealso cref="ValueReference"/> for this expression instance.
 /// </summary>
 /// <param name="context">
 ///            the context of this evaluation </param>
 /// <returns> the <code>ValueReference</code> for this <code>ValueExpression</code>, or
 ///         <code>null</code> if this <code>ValueExpression</code> is not a reference to a base
 ///         (null or non-null) and a property. If the base is null, and the property is a EL
 ///         variable, return the <code>ValueReference</code> for the <code>ValueExpression</code>
 ///         associated with this EL variable.
 ///
 /// @since 2.2 </returns>
 public virtual ValueReference getValueReference(ELContext context)
 {
     return(null);
 }
Esempio n. 13
0
 /// <summary>
 /// Evaluates the expression relative to the provided context, and sets the result to the
 /// provided value.
 /// </summary>
 /// <param name="context">
 ///            The context of this evaluation. </param>
 /// <param name="value">
 ///            The new value to be set. </param>
 /// <exception cref="NullPointerException">
 ///             if context is null. </exception>
 /// <exception cref="PropertyNotFoundException">
 ///             if one of the property resolutions failed because a specified variable or
 ///             property does not exist or is not readable. </exception>
 /// <exception cref="PropertyNotWritableException">
 ///             if the final variable or property resolution failed because the specified
 ///             variable or property is not writable. </exception>
 /// <exception cref="ELException">
 ///             if an exception was thrown while attempting to set the property or variable. The
 ///             thrown exception must be included as the cause property of this exception, if
 ///             available. </exception>
 public abstract void setValue(ELContext context, object value);
Esempio n. 14
0
 /// <summary>
 /// Returns the most general type that this resolver accepts for the property argument, given a
 /// base object. One use for this method is to assist tools in auto-completion. This assists
 /// tools in auto-completion and also provides a way to express that the resolver accepts a
 /// primitive value, such as an integer index into an array. For example, the
 /// <seealso cref="ArrayELResolver"/> will accept any int as a property, so the return value would be
 /// Integer.class.
 /// </summary>
 /// <param name="context">
 ///            The context of this evaluation. </param>
 /// <param name="base">
 ///            The base object to return the most general property type for, or null to enumerate
 ///            the set of top-level variables that this resolver can evaluate. </param>
 /// <returns> null if this ELResolver does not know how to handle the given base object; otherwise
 ///         Object.class if any type of property is accepted; otherwise the most general property
 ///         type accepted for the given base. </returns>
 public abstract Type getCommonPropertyType(ELContext context, object @base);
Esempio n. 15
0
 /// <summary>
 /// If the base object is a ResourceBundle, returns the most general type that this resolver
 /// accepts for the property argument. Otherwise, returns null. Assuming the base is a
 /// ResourceBundle, this method will always return String.class.
 /// </summary>
 /// <param name="context">
 ///            The context of this evaluation. </param>
 /// <param name="base">
 ///            The bundle to analyze. Only bases of type ResourceBundle are handled by this
 ///            resolver. </param>
 /// <returns> null if base is not a ResourceBundle; otherwise String.class. </returns>
 public override Type getCommonPropertyType(ELContext context, object @base)
 {
     return(isResolvable(@base) ? typeof(string) : null);
 }
Esempio n. 16
0
 /// <summary>
 /// Evaluates the expression relative to the provided context, and returns information about the
 /// actual referenced method.
 /// </summary>
 /// <param name="context">
 ///            The context of this evaluation. </param>
 /// <returns> The context of this evaluation </returns>
 /// <exception cref="NullPointerException">
 ///             if context is null </exception>
 /// <exception cref="PropertyNotFoundException">
 ///             if one of the property resolutions failed because a specified variable or
 ///             property does not exist or is not readable. </exception>
 /// <exception cref="MethodNotFoundException">
 ///             if no suitable method can be found. </exception>
 /// <exception cref="ELException">
 ///             if an exception was thrown while performing property or variable resolution. The
 ///             thrown exception must be included as the cause property of this exception, if
 ///             available. </exception>
 public abstract MethodInfo getMethodInfo(ELContext context);
Esempio n. 17
0
 /// <summary>
 /// Returns information about the set of variables or properties that can be resolved for the
 /// given base object. One use for this method is to assist tools in auto-completion. If the base
 /// parameter is null, the resolver must enumerate the list of top-level variables it can
 /// resolve. The Iterator returned must contain zero or more instances of
 /// java.beans.FeatureDescriptor, in no guaranteed order. In the case of primitive types such as
 /// int, the value null must be returned. This is to prevent the useless iteration through all
 /// possible primitive values. A return value of null indicates that this resolver does not
 /// handle the given base object or that the results are too complex to represent with this
 /// method and the <seealso cref="getCommonPropertyType(ELContext, object)"/> method should be used
 /// instead. Each FeatureDescriptor will contain information about a single variable or property.
 /// In addition to the standard properties, the FeatureDescriptor must have two named attributes
 /// (as set by the setValue method):
 /// <ul>
 /// <li><seealso cref="TYPE"/> - The value of this named attribute must be an instance of java.lang.Class
 /// and specify the runtime type of the variable or property.</li>
 /// <li><seealso cref="RESOLVABLE_AT_DESIGN_TIME"/> - The value of this named attribute must be an
 /// instance of java.lang.Boolean and indicates whether it is safe to attempt to resolve this
 /// property at designtime. For instance, it may be unsafe to attempt a resolution at design time
 /// if the ELResolver needs access to a resource that is only available at runtime and no
 /// acceptable simulated value can be provided.</li>
 /// </ul>
 /// The caller should be aware that the Iterator returned might iterate through a very large or
 /// even infinitely large set of properties. Care should be taken by the caller to not get stuck
 /// in an infinite loop. This is a "best-effort" list. Not all ELResolvers will return completely
 /// accurate results, but all must be callable at both design-time and runtime (i.e. whether or
 /// not Beans.isDesignTime() returns true), without causing errors. The propertyResolved property
 /// of the ELContext is not relevant to this method. The results of all ELResolvers are
 /// concatenated in the case of composite resolvers.
 /// </summary>
 /// <param name="context">
 ///            The context of this evaluation. </param>
 /// <param name="base">
 ///            The base object whose set of valid properties is to be enumerated, or null to
 ///            enumerate the set of top-level variables that this resolver can evaluate. </param>
 /// <returns> An Iterator containing zero or more (possibly infinitely more) FeatureDescriptor
 ///         objects, or null if this resolver does not handle the given base object or that the
 ///         results are too complex to represent with this method </returns>
 public abstract IEnumerator <FeatureDescriptor> getFeatureDescriptors(ELContext context, object @base);
Esempio n. 18
0
        /// <summary>
        /// Returns information about the set of variables or properties that can be resolved for the
        /// given base object. One use for this method is to assist tools in auto-completion. The results
        /// are collected from all component resolvers. The propertyResolved property of the ELContext is
        /// not relevant to this method. The results of all ELResolvers are concatenated. The Iterator
        /// returned is an iterator over the collection of FeatureDescriptor objects returned by the
        /// iterators returned by each component resolver's getFeatureDescriptors method. If null is
        /// returned by a resolver, it is skipped.
        /// </summary>
        /// <param name="context">
        ///            The context of this evaluation. </param>
        /// <param name="base">
        ///            The base object to return the most general property type for, or null to enumerate
        ///            the set of top-level variables that this resolver can evaluate. </param>
        /// <returns> An Iterator containing zero or more (possibly infinitely more) FeatureDescriptor
        ///         objects, or null if this resolver does not handle the given base object or that the
        ///         results are too complex to represent with this method </returns>
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
//ORIGINAL LINE: @Override public java.util.Iterator<java.beans.FeatureDescriptor> getFeatureDescriptors(final ELContext context, final Object super)
        public override IEnumerator <FeatureDescriptor> getFeatureDescriptors(ELContext context, object @base)
        {
            return(new IteratorAnonymousInnerClass(this, context, @base));
        }
Esempio n. 19
0
 /// <summary>
 /// For a given base and property, attempts to identify the most general type that is acceptable
 /// for an object to be passed as the value parameter in a future call to the
 /// <seealso cref="setValue(ELContext, object, object, object)"/> method. If this resolver handles the
 /// given (base, property) pair, the propertyResolved property of the ELContext object must be
 /// set to true by the resolver, before returning. If this property is not true after this method
 /// is called, the caller should ignore the return value. This is not always the same as
 /// getValue().getClass(). For example, in the case of an <seealso cref="ArrayELResolver"/>, the getType
 /// method will return the element type of the array, which might be a superclass of the type of
 /// the actual element that is currently in the specified array element.
 /// </summary>
 /// <param name="context">
 ///            The context of this evaluation. </param>
 /// <param name="base">
 ///            The base object whose property value is to be analyzed, or null to analyze a
 ///            top-level variable. </param>
 /// <param name="property">
 ///            The property or variable to return the acceptable type for. </param>
 /// <returns> If the propertyResolved property of ELContext was set to true, then the most general
 ///         acceptable type; otherwise undefined. </returns>
 /// <exception cref="java.lang.NullPointerException">
 ///             if context is null </exception>
 /// <exception cref="PropertyNotFoundException">
 ///             if the given (base, property) pair is handled by this ELResolver but the
 ///             specified variable or property does not exist or is not readable. </exception>
 /// <exception cref="ELException">
 ///             if an exception was thrown while performing the property or variable resolution.
 ///             The thrown exception must be included as the cause property of this exception, if
 ///             available. </exception>
 public abstract Type getType(ELContext context, object @base, object property);
Esempio n. 20
0
 /// <summary>
 /// Parses an expression into a <seealso cref="ValueExpression"/> for later evaluation. Use this method for
 /// expressions that refer to values. This method should perform syntactic validation of the
 /// expression. If in doing so it detects errors, it should raise an ELException.
 /// </summary>
 /// <param name="context">
 ///            The EL context used to parse the expression. The FunctionMapper and VariableMapper
 ///            stored in the ELContext are used to resolve functions and variables found in the
 ///            expression. They can be null, in which case functions or variables are not
 ///            supported for this expression. The object returned must invoke the same functions
 ///            and access the same variable mappings regardless of whether the mappings in the
 ///            provided FunctionMapper and VariableMapper instances change between calling
 ///            ExpressionFactory.createValueExpression() and any method on ValueExpression. Note
 ///            that within the EL, the ${} and #{} syntaxes are treated identically. This
 ///            includes the use of VariableMapper and FunctionMapper at expression creation time.
 ///            Each is invoked if not null, independent of whether the #{} or ${} syntax is used
 ///            for the expression. </param>
 /// <param name="expression">
 ///            The expression to parse </param>
 /// <param name="expectedType">
 ///            The type the result of the expression will be coerced to after evaluation. </param>
 /// <returns> The parsed expression </returns>
 /// <exception cref="ELException">
 ///             Thrown if there are syntactical errors in the provided expression. </exception>
 /// <exception cref="NullPointerException">
 ///             if paramTypes is null. </exception>
 public abstract ValueExpression createValueExpression(ELContext context, string expression, Type expectedType);
Esempio n. 21
0
 /// <summary>
 /// Evaluates the expression relative to the provided context, and returns the resulting value.
 /// The resulting value is automatically coerced to the type returned by getExpectedType(), which
 /// was provided to the ExpressionFactory when this expression was created.
 /// </summary>
 /// <param name="context">
 ///            The context of this evaluation. </param>
 /// <returns> The result of the expression evaluation. </returns>
 /// <exception cref="NullPointerException">
 ///             if context is null. </exception>
 /// <exception cref="PropertyNotFoundException">
 ///             if one of the property resolutions failed because a specified variable or
 ///             property does not exist or is not readable. </exception>
 /// <exception cref="ELException">
 ///             if an exception was thrown while performing property or variable resolution. The
 ///             thrown exception must be included as the cause property of this exception, if
 ///             available. </exception>
 public abstract object getValue(ELContext context);