return fromClassNameToSuffix(componentName);
        }

        @Override
        public Class<?> fromComponentNameToClass(String componentName) {
            try {
                return Class.forName(componentName);
            } catch (ClassNotFoundException e) {
                return null;
            }
        }

        @Override
        public Class<?> toCompleteClass(Class<?> clazz) {

      }.socketFactory

  companion object {
    val isSupported: Boolean =
      try {
        // Trigger an early exception over a fatal error, prefer a RuntimeException over Error.
        Class.forName("org.conscrypt.Conscrypt\$Version", false, javaClass.classLoader)

        when {
          // Bump this version if we ever have a binary incompatibility
          Conscrypt.isAvailable() && atLeastVersion(2, 1, 0) -> true

      SerializedForm(Charset charset) {
        this.charsetCanonicalName = charset.name();
      }

      private Object readResolve() {
        return stringFunnel(Charset.forName(charsetCanonicalName));
      }

      private static final long serialVersionUID = 0;
    }
  }

  /**
   * Returns a funnel for integers.
   *
   * @since 13.0
   */

      SerializedForm(Charset charset) {
        this.charsetCanonicalName = charset.name();
      }

      private Object readResolve() {
        return stringFunnel(Charset.forName(charsetCanonicalName));
      }

      private static final long serialVersionUID = 0;
    }
  }

  /**
   * Returns a funnel for integers.
   *
   * @since 13.0
   */

        final HttpPost httpPost = new HttpPost(url);
        final HttpEntity postEntity = MultipartEntityBuilder.create()
                .setMode(HttpMultipartMode.BROWSER_COMPATIBLE)
                .setCharset(Charset.forName("UTF-8"))
                .addBinaryBody("filedata", in)
                .build();
        httpPost.setEntity(postEntity);

        try (CloseableHttpResponse response = httpClient.execute(httpPost)) {

    static Method newStringUnsafeMethod = null;

    static {
        try {
            final Class<?> sharedSecretsClass = Class.forName("sun.misc.SharedSecrets");
            javaLangAccess = sharedSecretsClass.getDeclaredMethod("getJavaLangAccess").invoke(null);
            final Class<?> javaLangAccessClass = Class.forName("sun.misc.JavaLangAccess");
            newStringUnsafeMethod = javaLangAccessClass.getMethod("newStringUnsafe", char[].class);

            logger.warn("Cannot load subpackages from {}", basePackage, e);
        }

        subPackages.stream().forEach(protocol -> {
            try {
                final Class<Object> handlerClazz = ClassUtil.forName(basePackage + "." + protocol + ".Handler");
                final Field protocolTypeField = ClassUtil.getDeclaredField(handlerClazz, "PROTOCOL_TYPE");

    }

  private fun loomThreadFactory(): ThreadFactory {
    val ofVirtual = Thread::class.java.getMethod("ofVirtual").invoke(null)

    return Class
      .forName("java.lang.Thread\$Builder")
      .getMethod("factory")
      .invoke(ofVirtual) as ThreadFactory
  }

  private fun isLoom(): Boolean = getPlatformSystemProperty() == LOOM_PROPERTY

   */
  @JvmOverloads
  fun charset(defaultValue: Charset? = null): Charset? {
    val charset = parameter("charset") ?: return defaultValue
    return try {
      Charset.forName(charset)
    } catch (_: IllegalArgumentException) {
      defaultValue // This charset is invalid or unsupported. Give up.
    }
  }

  /**

       */
      @Override
      @J2ObjCIncompatible
      @Nullable LittleEndianBytes tryMakeVarHandleLittleEndianBytes() {
        try {
          Class.forName("java.lang.invoke.VarHandle");
        } catch (ClassNotFoundException beforeJava9) {
          return null;
        }
        return VarHandleLittleEndianBytes.INSTANCE;
      }
    };