passwordLength = password.length;
            } else if( DISABLE_PLAIN_TEXT_PASSWORDS ) {
                throw new RuntimeException( "Plain text passwords are disabled" );
            } else {
                // plain text
                password = new byte[(session.auth.password.length() + 1) * 2];
                passwordLength = writeString( session.auth.password, password, 0 );
            }

    protected String includeFilteringPattern;

    protected String excludeFilteringPattern;

    protected Set<String> cachedIncludeSet = new LinkedHashSet<>();

    protected Set<String> cachedExcludeSet = new LinkedHashSet<>();

    protected String sessionId;

    protected UrlFilterService urlFilterService;

    /*
     * (non-Javadoc)
     *

            PluginContainer childContainer, PluginContainer parentContainer, boolean handleAsInheritance) {
        throw new UnsupportedOperationException();
    }

    public static List<Plugin> orderAfterMerge(
            List<Plugin> merged, List<Plugin> highPrioritySource, List<Plugin> lowPrioritySource) {
        throw new UnsupportedOperationException();
    }

        ComponentUtil.setFessConfig(new FessConfig.SimpleImpl() {
            @Override
            public String getCrawlerWebProtocols() {
                return "http,https";
            }

            @Override
            public String getCrawlerFileProtocols() {
                return "file,smb";
            }
        });

        final ProtocolHelper protocolHelper = new ProtocolHelper();
        protocolHelper.init();

    super(incidentEdges);
  }

  static <N, E> UndirectedMultiNetworkConnections<N, E> of() {
    return new UndirectedMultiNetworkConnections<>(
        new HashMap<E, N>(INNER_CAPACITY, INNER_LOAD_FACTOR));
  }

  static <N, E> UndirectedMultiNetworkConnections<N, E> ofImmutable(Map<E, N> incidentEdges) {
    return new UndirectedMultiNetworkConnections<>(ImmutableMap.copyOf(incidentEdges));
  }

    checkNotNull(timeoutUnit);
    try {
      return callable.call();
    } catch (RuntimeException e) {
      throw new UncheckedExecutionException(e);
    } catch (Exception e) {
      restoreInterruptIfIsInterruptedException(e);
      throw new ExecutionException(e);
    } catch (Error e) {
      throw new ExecutionError(e);
    }
  }

  @CanIgnoreReturnValue // TODO(kak): consider removing this
  @Override

     */
    public static Artifact toPomArtifactUnconditionally(Artifact artifact) {
        return new DefaultArtifact(artifact.getGroupId(), artifact.getArtifactId(), "pom", artifact.getVersion());
    }

    public static RemoteRepository toRemoteRepository(Repository repository) {
        RemoteRepository.Builder builder =
                new RemoteRepository.Builder(repository.getId(), repository.getLayout(), repository.getUrl());

Register an _application_ interceptor by calling `addInterceptor()` on `OkHttpClient.Builder`:

```java
OkHttpClient client = new OkHttpClient.Builder()
    .addInterceptor(new LoggingInterceptor())
    .build();

Request request = new Request.Builder()
    .url("http://www.publicobject.com/helloworld.txt")
    .header("User-Agent", "OkHttp Example")
    .build();

        }
        return asJson(new ApiResult.ApiUpdateResponse().id(id).created(false).status(ApiResult.Status.OK).result());
    }

    protected EditBody createEditBody(final PathMapping entity) {
        final EditBody body = new EditBody();
        copyBeanToBean(entity, body, op -> op.exclude(Constants.COMMON_CONVERSION_RULE));
        return body;

            throwValidationErrorApi(messages -> messages.addErrorsCrudCouldNotFindCrudTable(GLOBAL, id));
        });
        return asJson(new ApiResponse().status(Status.OK).result());
    }

    protected EditBody createEditBody(final RelatedContent entity) {
        final EditBody body = new EditBody();
        copyBeanToBean(entity, body, copyOp -> {
            copyOp.excludeNull();
        });
        return body;
    }