FnResolveUri.java

  1. /*
  2.  * Portions of this software was developed by employees of the National Institute
  3.  * of Standards and Technology (NIST), an agency of the Federal Government and is
  4.  * being made available as a public service. Pursuant to title 17 United States
  5.  * Code Section 105, works of NIST employees are not subject to copyright
  6.  * protection in the United States. This software may be subject to foreign
  7.  * copyright. Permission in the United States and in foreign countries, to the
  8.  * extent that NIST may hold copyright, to use, copy, modify, create derivative
  9.  * works, and distribute this software and its documentation without fee is hereby
  10.  * granted on a non-exclusive basis, provided that this notice and disclaimer
  11.  * of warranty appears in all copies.
  12.  *
  13.  * THE SOFTWARE IS PROVIDED 'AS IS' WITHOUT ANY WARRANTY OF ANY KIND, EITHER
  14.  * EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTY
  15.  * THAT THE SOFTWARE WILL CONFORM TO SPECIFICATIONS, ANY IMPLIED WARRANTIES OF
  16.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND FREEDOM FROM
  17.  * INFRINGEMENT, AND ANY WARRANTY THAT THE DOCUMENTATION WILL CONFORM TO THE
  18.  * SOFTWARE, OR ANY WARRANTY THAT THE SOFTWARE WILL BE ERROR FREE.  IN NO EVENT
  19.  * SHALL NIST BE LIABLE FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO, DIRECT,
  20.  * INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF, RESULTING FROM,
  21.  * OR IN ANY WAY CONNECTED WITH THIS SOFTWARE, WHETHER OR NOT BASED UPON WARRANTY,
  22.  * CONTRACT, TORT, OR OTHERWISE, WHETHER OR NOT INJURY WAS SUSTAINED BY PERSONS OR
  23.  * PROPERTY OR OTHERWISE, AND WHETHER OR NOT LOSS WAS SUSTAINED FROM, OR AROSE OUT
  24.  * OF THE RESULTS OF, OR USE OF, THE SOFTWARE OR SERVICES PROVIDED HEREUNDER.
  25.  */

  27. package gov.nist.secauto.metaschema.core.metapath.function.library;

  29. import gov.nist.secauto.metaschema.core.metapath.DynamicContext;
  30. import gov.nist.secauto.metaschema.core.metapath.ISequence;
  31. import gov.nist.secauto.metaschema.core.metapath.MetapathConstants;
  32. import gov.nist.secauto.metaschema.core.metapath.function.FunctionUtils;
  33. import gov.nist.secauto.metaschema.core.metapath.function.IArgument;
  34. import gov.nist.secauto.metaschema.core.metapath.function.IFunction;
  35. import gov.nist.secauto.metaschema.core.metapath.function.InvalidArgumentFunctionException;
  36. import gov.nist.secauto.metaschema.core.metapath.function.UriFunctionException;
  37. import gov.nist.secauto.metaschema.core.metapath.item.IItem;
  38. import gov.nist.secauto.metaschema.core.metapath.item.atomic.IAnyUriItem;
  39. import gov.nist.secauto.metaschema.core.metapath.item.atomic.IStringItem;
  40. import gov.nist.secauto.metaschema.core.util.ObjectUtils;

  42. import java.net.URI;
  43. import java.util.List;

  45. import edu.umd.cs.findbugs.annotations.NonNull;
  46. import edu.umd.cs.findbugs.annotations.Nullable;

  48. public final class FnResolveUri {
  49.   @NonNull
  50.   static final IFunction SIGNATURE_ONE_ARG = IFunction.builder()
  51.       .name("resolve-uri")
  52.       .namespace(MetapathConstants.NS_XPATH_FUNCTIONS)
  53.       .deterministic()
  54.       .contextDependent()
  55.       .focusIndependent()
  56.       .argument(IArgument.newBuilder()
  57.           .name("relative")
  58.           .type(IStringItem.class)
  59.           .zeroOrOne()
  60.           .build())
  61.       .returnType(IAnyUriItem.class)
  62.       .returnZeroOrOne()
  63.       .functionHandler(FnResolveUri::executeOneArg)
  64.       .build();

  66.   @NonNull
  67.   static final IFunction SIGNATURE_TWO_ARG = IFunction.builder()
  68.       .name("resolve-uri")
  69.       .namespace(MetapathConstants.NS_XPATH_FUNCTIONS)
  70.       .deterministic()
  71.       .contextIndependent()
  72.       .focusIndependent()
  73.       .argument(IArgument.newBuilder()
  74.           .name("relative")
  75.           .type(IStringItem.class)
  76.           .zeroOrOne()
  77.           .build())
  78.       .argument(IArgument.newBuilder()
  79.           .name("base")
  80.           .type(IStringItem.class)
  81.           .one()
  82.           .build())
  83.       .returnType(IAnyUriItem.class)
  84.       .returnZeroOrOne()
  85.       .functionHandler(FnResolveUri::executeTwoArg)
  86.       .build();

  88.   private FnResolveUri() {
  89.     // disable construction
  90.   }

  92.   @SuppressWarnings("unused")
  93.   @NonNull
  94.   private static ISequence<IAnyUriItem> executeOneArg(
  95.       @NonNull IFunction function,
  96.       @NonNull List<ISequence<?>> arguments,
  97.       @NonNull DynamicContext dynamicContext,
  98.       IItem focus) {

  100.     ISequence<? extends IStringItem> relativeSequence
  101.         = FunctionUtils.asType(ObjectUtils.requireNonNull(arguments.get(0)));
  102.     if (relativeSequence.isEmpty()) {
  103.       return ISequence.empty(); // NOPMD - readability
  104.     }

  106.     IAnyUriItem baseUri = FnStaticBaseUri.fnStaticBaseUri(dynamicContext);
  107.     if (baseUri == null) {
  108.       throw new UriFunctionException(UriFunctionException.BASE_URI_NOT_DEFINED_IN_STATIC_CONTEXT,
  109.           "The base-uri is not defined in the static context");
  110.     }

  112.     IStringItem relativeString = FunctionUtils.getFirstItem(relativeSequence, true);

  114.     IAnyUriItem resolvedUri = fnResolveUri(relativeString, baseUri);
  115.     return resolvedUri == null ? ISequence.empty() : ISequence.of(resolvedUri);
  116.   }

  118.   /**
  119.    * Implements the two argument version of the XPath 3.1 function <a href=
  120.    * "https://www.w3.org/TR/xpath-functions-31/#func-resolve-uri">resolve-uri</a>.
  121.    *
  122.    * @param function
  123.    *          the function definition
  124.    * @param arguments
  125.    *          a list of sequence arguments with an expected size of 2
  126.    * @param dynamicContext
  127.    *          the evaluation context
  128.    * @param focus
  129.    *          the current focus item
  130.    * @return a sequence containing the resolved URI or and empty sequence if
  131.    *         either the base or relative URI is {@code null}
  132.    */
  133.   @SuppressWarnings("PMD.UnusedPrivateMethod") // used in lambda
  134.   @NonNull
  135.   private static ISequence<IAnyUriItem> executeTwoArg(
  136.       @NonNull IFunction function, // NOPMD - ok
  137.       @NonNull List<ISequence<?>> arguments,
  138.       @NonNull DynamicContext dynamicContext, // NOPMD - ok
  139.       IItem focus) { // NOPMD - ok

  141.     /* there will always be two arguments */
  142.     assert arguments.size() == 2;

  144.     ISequence<? extends IStringItem> relativeSequence = FunctionUtils.asType(
  145.         ObjectUtils.requireNonNull(arguments.get(0)));
  146.     if (relativeSequence.isEmpty()) {
  147.       return ISequence.empty(); // NOPMD - readability
  148.     }

  150.     ISequence<? extends IStringItem> baseSequence = FunctionUtils.asType(ObjectUtils.requireNonNull(arguments.get(1)));
  151.     IStringItem baseString = FunctionUtils.getFirstItem(baseSequence, true);

  153.     if (baseString == null) {
  154.       throw new InvalidArgumentFunctionException(
  155.           InvalidArgumentFunctionException.INVALID_ARGUMENT_TO_RESOLVE_URI,
  156.           "Invalid argument to fn:resolve-uri().");
  157.     }
  158.     IAnyUriItem baseUri = IAnyUriItem.cast(baseString);

  160.     IStringItem relativeString = FunctionUtils.getFirstItem(relativeSequence, true);

  162.     IAnyUriItem resolvedUri = fnResolveUri(relativeString, baseUri);
  163.     return resolvedUri == null ? ISequence.empty() : ISequence.of(resolvedUri);
  164.   }

  166.   /**
  167.    * Resolve the {@code relative} URI against the provided {@code base} URI.
  168.    *
  169.    * @param relative
  170.    *          the relative URI to resolve
  171.    * @param base
  172.    *          the base URI to resolve against
  173.    * @return the resolved URI or {@code null} if the {@code relative} URI in
  174.    *         {@code null}
  175.    */
  176.   @Nullable
  177.   public static IAnyUriItem fnResolveUri(@Nullable IStringItem relative, @NonNull IAnyUriItem base) {
  178.     IAnyUriItem relativeUri = relative == null ? null : IAnyUriItem.cast(relative);

  180.     return fnResolveUri(relativeUri, base);
  181.   }

  183.   /**
  184.    * Resolve the {@code relative} URI against the provided {@code base} URI.
  185.    *
  186.    * @param relative
  187.    *          the relative URI to resolve
  188.    * @param base
  189.    *          the base URI to resolve against
  190.    * @return the resolved URI or {@code null} if the {@code relative} URI in
  191.    *         {@code null}
  192.    */
  193.   @Nullable
  194.   public static IAnyUriItem fnResolveUri(@Nullable IAnyUriItem relative, @NonNull IAnyUriItem base) {
  195.     if (relative == null) {
  196.       return null; // NOPMD - readability
  197.     }

  199.     @SuppressWarnings("null")
  200.     @NonNull URI resolvedUri = base.getValue().resolve(relative.getValue());
  201.     return IAnyUriItem.valueOf(resolvedUri);
  202.   }
  203. }
Created with JaCoCo 0.8.10.202304240956