View Javadoc

    1   /*
    2    * $Header: /home/projects/jaxen/scm/jaxen/src/java/main/org/jaxen/XPathFunctionContext.java,v 1.27 2005/09/24 11:38:54 elharo Exp $
    3    * $Revision: 1.27 $
    4    * $Date: 2005/09/24 11:38:54 $
    5    *
    6    * ====================================================================
    7    *
    8    * Copyright (C) 2000-2002 bob mcwhirter & James Strachan.
    9    * All rights reserved.
    10   *
    11   * Redistribution and use in source and binary forms, with or without
    12   * modification, are permitted provided that the following conditions
    13   * are met:
    14   *
    15   * 1. Redistributions of source code must retain the above copyright
    16   *    notice, this list of conditions, and the following disclaimer.
    17   *
    18   * 2. Redistributions in binary form must reproduce the above copyright
    19   *    notice, this list of conditions, and the disclaimer that follows
    20   *    these conditions in the documentation and/or other materials
    21   *    provided with the distribution.
    22   *
    23   * 3. The name "Jaxen" must not be used to endorse or promote products
    24   *    derived from this software without prior written permission.  For
    25   *    written permission, please contact license@jaxen.org.
    26   *
    27   * 4. Products derived from this software may not be called "Jaxen", nor
    28   *    may "Jaxen" appear in their name, without prior written permission
    29   *    from the Jaxen Project Management (pm@jaxen.org).
    30   *
    31   * In addition, we request (but do not require) that you include in the
    32   * end-user documentation provided with the redistribution and/or in the
    33   * software itself an acknowledgement equivalent to the following:
    34   *     "This product includes software developed by the
    35   *      Jaxen Project <http://www.jaxen.org/>."
    36   * Alternatively, the acknowledgment may be graphical using the logos
    37   * available at http://www.jaxen.org/
    38   *
    39   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
    40   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
    41   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
    42   * DISCLAIMED.  IN NO EVENT SHALL THE Jaxen AUTHORS OR THE PROJECT
    43   * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    44   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    45   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
    46   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
    47   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
    48   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
    49   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
    50   * SUCH DAMAGE.
    51   *
    52   * ====================================================================
    53   * This software consists of voluntary contributions made by many
    54   * individuals on behalf of the Jaxen Project and was originally
    55   * created by bob mcwhirter <bob@werken.com> and
    56   * James Strachan <jstrachan@apache.org>.  For more information on the
    57   * Jaxen Project, please see <http://www.jaxen.org/>.
    58   *
    59   * $Id: XPathFunctionContext.java,v 1.27 2005/09/24 11:38:54 elharo Exp $
    60   */
    61
    62
    63  package org.jaxen;
    64
    65  import org.jaxen.function.BooleanFunction;
    66  import org.jaxen.function.CeilingFunction;
    67  import org.jaxen.function.ConcatFunction;
    68  import org.jaxen.function.ContainsFunction;
    69  import org.jaxen.function.CountFunction;
    70  import org.jaxen.function.FalseFunction;
    71  import org.jaxen.function.FloorFunction;
    72  import org.jaxen.function.IdFunction;
    73  import org.jaxen.function.LangFunction;
    74  import org.jaxen.function.LastFunction;
    75  import org.jaxen.function.LocalNameFunction;
    76  import org.jaxen.function.NameFunction;
    77  import org.jaxen.function.NamespaceUriFunction;
    78  import org.jaxen.function.NormalizeSpaceFunction;
    79  import org.jaxen.function.NotFunction;
    80  import org.jaxen.function.NumberFunction;
    81  import org.jaxen.function.PositionFunction;
    82  import org.jaxen.function.RoundFunction;
    83  import org.jaxen.function.StartsWithFunction;
    84  import org.jaxen.function.StringFunction;
    85  import org.jaxen.function.StringLengthFunction;
    86  import org.jaxen.function.SubstringAfterFunction;
    87  import org.jaxen.function.SubstringBeforeFunction;
    88  import org.jaxen.function.SubstringFunction;
    89  import org.jaxen.function.SumFunction;
    90  import org.jaxen.function.TranslateFunction;
    91  import org.jaxen.function.TrueFunction;
    92  import org.jaxen.function.ext.EndsWithFunction;
    93  import org.jaxen.function.ext.EvaluateFunction;
    94  import org.jaxen.function.ext.LowerFunction;
    95  import org.jaxen.function.ext.MatrixConcatFunction;
    96  import org.jaxen.function.ext.UpperFunction;
    97  import org.jaxen.function.xslt.DocumentFunction;
    98
    99  /*** A <code>FunctionContext</code> implementing the core XPath
    100  *  function library, plus Jaxen extensions.
    101  *
    102  *  <p>
    103  *  The core XPath function library is provided through this
    104  *  implementation of <code>FunctionContext</code>.  Additionally,
    105  *  extension functions have been provided, as enumerated below.
    106  *  </p>
    107  *
    108  *  <p>
    109  *  This class is re-entrant and thread-safe.  If using the
    110  *  default instance, it is inadvisable to call
    111  *  {@link #registerFunction(String, String, Function)}
    112  *  as that will extend the global function context, affecting other
    113  *  users.  But that's your call, really, now isn't
    114  *  it?  That may be what you really want to do.
    115  *  </p>
    116  *
    117  *  <p>
    118  *  Extension functions:
    119  *  </p>
    120  *
    121  *  <ul>
    122  *     <li>matrix-concat(..)</li>
    123  *     <li>evaluate(..)</li>
    124  *     <li>upper-case(..)</li>
    125  *     <li>lower-case(..)</li>
    126  *     <li>ends-with(..)</li>
    127  *  </ul>
    128  *
    129  *  @see FunctionContext
    130  *  @see org.jaxen.function
    131  *  @see org.jaxen.function.xslt
    132  *  @see org.jaxen.function.ext
    133  *
    134  *  @author <a href="mailto:bob@werken.com">bob mcwhirter</a>
    135  */
    136 public class XPathFunctionContext extends SimpleFunctionContext
    137 {
    138     private static XPathFunctionContext instance = new XPathFunctionContext();
    139
    140     /*** Retrieve the default function context
    141      *
    142      *  @return the default function context
    143      */
    144     public static FunctionContext getInstance()
    145     {
    146         return instance;
    147     }
    148
    149     /*** Create a new XPath function context.
    150      *  All core XPath and Jaxen extension functions are registered.
    151      */
    152     public XPathFunctionContext()
    153     {
    154         this(true);
    155     }
    156
    157     /*** Create a new XPath function context.
    158      *  All core XPath functions are registered.
    159      *
    160      * @param includeExtensionFunctions if true extension functions are included;
    161      *     if false, they aren't.
    162      */
    163     public XPathFunctionContext(boolean includeExtensionFunctions)
    164     {
    165         registerXPathFunctions();
    166         if (includeExtensionFunctions) {
    167             registerXSLTFunctions();
    168             registerExtensionFunctions();
    169         }
    170     }
    171
    172     private void registerXPathFunctions() {
    173
    174         registerFunction( null,  // namespace URI
    175                           "boolean",
    176                           new BooleanFunction() );
    177
    178         registerFunction( null,  // namespace URI
    179                           "ceiling",
    180                           new CeilingFunction() );
    181
    182         registerFunction( null,  // namespace URI
    183                           "concat",
    184                           new ConcatFunction() );
    185
    186         registerFunction( null,  // namespace URI
    187                           "contains",
    188                           new ContainsFunction() );
    189
    190         registerFunction( null,  // namespace URI
    191                           "count",
    192                           new CountFunction() );
    193
    194         registerFunction( null,  // namespace URI
    195                           "false",
    196                           new FalseFunction() );
    197
    198         registerFunction( null,  // namespace URI
    199                           "floor",
    200                           new FloorFunction() );
    201
    202         registerFunction( null,  // namespace URI
    203                           "id",
    204                           new IdFunction() );
    205
    206         registerFunction( null,  // namespace URI
    207                           "lang",
    208                           new LangFunction() );
    209
    210         registerFunction( null,  // namespace URI
    211                           "last",
    212                           new LastFunction() );
    213
    214         registerFunction( null,  // namespace URI
    215                           "local-name",
    216                           new LocalNameFunction() );
    217
    218         registerFunction( null,  // namespace URI
    219                           "name",
    220                           new NameFunction() );
    221
    222         registerFunction( null,  // namespace URI
    223                           "namespace-uri",
    224                           new NamespaceUriFunction() );
    225
    226         registerFunction( null,  // namespace URI
    227                           "normalize-space",
    228                           new NormalizeSpaceFunction() );
    229
    230         registerFunction( null,  // namespace URI
    231                           "not",
    232                           new NotFunction() );
    233
    234         registerFunction( null,  // namespace URI
    235                           "number",
    236                           new NumberFunction() );
    237
    238         registerFunction( null,  // namespace URI
    239                           "position",
    240                           new PositionFunction() );
    241
    242         registerFunction( null,  // namespace URI
    243                           "round",
    244                           new RoundFunction() );
    245
    246         registerFunction( null,  // namespace URI
    247                           "starts-with",
    248                           new StartsWithFunction() );
    249
    250         registerFunction( null,  // namespace URI
    251                           "string",
    252                           new StringFunction() );
    253
    254         registerFunction( null,  // namespace URI
    255                           "string-length",
    256                           new StringLengthFunction() );
    257
    258         registerFunction( null,  // namespace URI
    259                           "substring-after",
    260                           new SubstringAfterFunction() );
    261
    262         registerFunction( null,  // namespace URI
    263                           "substring-before",
    264                           new SubstringBeforeFunction() );
    265
    266         registerFunction( null,  // namespace URI
    267                           "substring",
    268                           new SubstringFunction() );
    269
    270         registerFunction( null,  // namespace URI
    271                           "sum",
    272                           new SumFunction() );
    273
    274         registerFunction( null,  // namespace URI
    275                           "true",
    276                           new TrueFunction() );
    277
    278         registerFunction( null,  // namespace URI
    279                           "translate",
    280                           new TranslateFunction() );
    281     }
    282
    283     private void registerXSLTFunctions() {
    284
    285         // extension functions defined in XSLT
    286         registerFunction( null,  // namespace URI
    287                           "document",
    288                           new DocumentFunction() );
    289     }
    290
    291     private void registerExtensionFunctions() {
    292         // extension functions should go into a namespace, but which one?
    293         // for now, keep them in default namespace to not break any code
    294
    295         registerFunction( null,  // namespace URI
    296                           "matrix-concat",
    297                           new MatrixConcatFunction() );
    298
    299         registerFunction( null,  // namespace URI
    300                           "evaluate",
    301                           new EvaluateFunction() );
    302
    303         registerFunction( null,  // namespace URI
    304                           "lower-case",
    305                           new LowerFunction() );
    306
    307         registerFunction( null,  // namespace URI
    308                           "upper-case",
    309                           new UpperFunction() );
    310
    311         registerFunction( null,  // namespace URI
    312                           "ends-with",
    313                           new EndsWithFunction() );
    314     }
    315
    316
    317 }