This PR fixes a security issue where an IAM user based
    on his policy is granted more privileges than restricted
    by the users IAM policy.

    This is due to an issue of prefix based Matcher() function
    which was incorrectly matching prefix based on resource
    prefixes instead of exact match.
```

 * password, and domain. Additionally, it offers a method to construct a path
 * prefix for SMB1 URLs based on the configured server and port.
 * </p>
 *
 * <p>
 * The path prefix is in the format "smb1://server:port/", where the port is
 * included only if it's greater than 0. If the server is not set, the path
 * prefix will be "smb1://".
 * </p>
 */
public class SmbAuthentication {
    private String server;

    private int port;

    return delegate().apply(key);
  }

  @Override
  public void refresh(K key) {
    delegate().refresh(key);
  }

  /**
   * A simplified version of {@link ForwardingLoadingCache} where subclasses can pass in an already
   * constructed {@link LoadingCache} as the delegate.
   *
   * @since 10.0
   */
  public abstract static class SimpleForwardingLoadingCache<K, V>

     */
    public ModelBuilderException(ModelBuilderResult result) {
        super(result.toString());
        this.result = result;
    }

    /**
     * Gets the interim result of the model building up to the point where it failed.
     *
     * @return The interim model building result or {@code null} if not available.
     */
    public ModelBuilderResult getResult() {
        return result;
    }

    /**

        NdrShort ns = new NdrShort(0xABCD); // value & 0xFF => 0xCD
        buf.reset();
        int startIndex = buf.getIndex();
        ns.encode(buf);

        // Find where the actual data starts (after alignment)
        int alignmentBytes = 0;
        if (startIndex % 2 != 0) {
            alignmentBytes = 1; // Need 1 byte of padding for 2-byte alignment
        }

     * @throws IOException if the stream cannot be created or opened
     */
    @Nonnull
    InputStream openStream() throws IOException;

    /**
     * Returns a human-readable description of where this source came from,
     * used primarily for error messages and debugging.
     * <p>
     * Examples of locations:
     * <ul>
     *   <li>Absolute file path: {@code /path/to/pom.xml}</li>

    public String available;

    /** Access permissions for documents from this data source */
    @CustomSize(maxKey = "form.admin.max.input.size")
    public String permissions;

    /** Virtual hosts where this configuration applies */
    @CustomSize(maxKey = "form.admin.max.input.size")
    public String virtualHosts;

    /** Sort order for displaying configurations */
    @Required
    @Min(value = 0)

// A TokenReader is like a reader, but returns lex tokens of type Token. It also can tell you what
// the text of the most recently returned token is, and where it was found.
// The underlying scanner elides all spaces except newline, so the input looks like a stream of
// Tokens; original spacing is lost but we don't need it.
type TokenReader interface {
	// Next returns the next token.

        return subtypeOf(newArrayType(upperBounds[0]));
      }
    }
    return JavaVersion.CURRENT.newArrayType(componentType);
  }

  /**
   * Returns a type where {@code rawType} is parameterized by {@code arguments} and is owned by
   * {@code ownerType}.
   */
  static ParameterizedType newParameterizedTypeWithOwner(
      @Nullable Type ownerType, Class<?> rawType, Type... arguments) {

      // Some Android 5.0.x Samsung devices have bugs in JDK reflection APIs that cause
      // getDeclaredField to throw a NoSuchFieldException when the field is definitely there.
      // For these users fallback to a suboptimal implementation, based on synchronized. This will
      // be a definite performance hit to those users.
      thrownReflectionFailure = reflectionFailure;