final MethodDesc methodDesc = beanDesc.getMethodDescNoException(name);
        if (methodDesc == null) {
            return null;
        }
        final Object value = methodDesc.invoke(annotation);
        if (value == null || "".equals(value)) {
            return null;
        }
        return value;
    }

    return new String[length];
  }

  @Override
  public final String[] createValueArray(int length) {
    return new String[length];
  }

  /** Returns the original element list, unchanged. */
  @Override
  public Iterable<Entry<String, String>> order(List<Entry<String, String>> insertionOrder) {
    return insertionOrder;
  }

        if (lifecyclePhases == null) {
            return null;
        }

        if (lifecyclePhases.isEmpty()) {
            return Collections.emptyMap();
        }

        Map<String, String> phases = new LinkedHashMap<>();
        for (Map.Entry<String, LifecyclePhase> e : lifecyclePhases.entrySet()) {
            phases.put(e.getKey(), e.getValue().toString());
        }
        return phases;
    }

            val string = reader.readUtf8String()
            return parseUtcTime(string)
          }

          override fun encode(
            writer: DerWriter,
            value: Long,
          ) {
            val string = formatUtcTime(value)
            return writer.writeUtf8(string)
          }
        },
    )

    }

    /**
     * Returns the {@link Class} of the target.
     *
     * @return {@link Class} of the target
     */
    public Class<?> getTargetClass() {
        return targetClass;
    }

    /**
     * Returns the method name.
     *
     * @return Method name
     */
    public String getMethodName() {
        return methodName;
    }

    /**

            }
            try {
                return pathMapperFunc.apply(input, matcher);
            } catch (final Exception e) {
                logger.warn("Failed to apply {} to {}.", regexPattern.pattern(), input, e);
            }
        }
        return input;
    }

    public boolean hasUAMathcer() {
        return StringUtil.isNotBlank(getUserAgent());
    }

  }

  @Override
  public int size() {
    return size;
  }

  @Override
  boolean isPartialView() {
    return false;
  }

  @Override
  @Nullable Object[] internalArray() {
    return array;
  }

  @Override
  int internalArrayStart() {
    return 0;
  }

  @Override
  int internalArrayEnd() {
    return size;
  }

  @Override

    return (T[]) Array.newInstance(type, length);
  }

  /**
   * Returns a new array of the given length with the same type as a reference array.
   *
   * @param reference any array of the desired type
   * @param length the length of the new array
   */
  public static <T extends @Nullable Object> T[] newArray(T[] reference, int length) {
    return Platform.newArray(reference, length);
  }

        }
        return this.fileId;
    }

    /**
     * @return the initialSize
     */
    @Override
    public long getInitialSize() {
        return this.initialSize;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbFileHandle#getTree()
     */
    @Override
    public SmbTreeHandleImpl getTree() {

     */
    @Override
    public ResponseData doGet(final String uri) {
        return processRequest(uri, true);
    }

    /**
     * Processes an SMB request for the given URI.
     *
     * @param uri the URI to process
     * @param includeContent whether to include content in the response
     * @return the response data
     */