import java.io.Serializable;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.Set;

/**
 * @author shinsuke
 *
 */
public class ResultData implements Serializable {
    private static final long serialVersionUID = 1L;

    private String transformerName;

    private byte[] data;

    private String encoding;

import org.codelibs.fess.crawler.entity.ResponseData;
import org.codelibs.fess.crawler.processor.ResponseProcessor;

/**
 * @author kuma
 *
 */
public class NullResponseProcessor implements ResponseProcessor {

    @Override
    public void process(final ResponseData responseData) {
        // do nothing
    }

import org.apache.maven.project.ProjectBuildingException;
import org.apache.maven.project.ProjectBuildingRequest;
import org.apache.maven.project.ProjectBuildingResult;

@Named
@Singleton
public class DefaultProjectBuilder implements ProjectBuilder {

    private final org.apache.maven.project.ProjectBuilder builder;

    @Inject
    public DefaultProjectBuilder(org.apache.maven.project.ProjectBuilder builder) {
        this.builder = builder;

 */
package org.codelibs.fess.crawler.transformer.impl;

import org.codelibs.fess.crawler.transformer.Transformer;

/**
 * @author shinsuke
 *
 */
public abstract class AbstractTransformer implements Transformer {

    protected String name;

    public void setName(final String name) {
        this.name = name;
    }

    @Override
    public String getName() {
        return name;
    }

    extends AtomicReference<@Nullable Runnable> implements Runnable {
  static {
    // Prevent rare disastrous classloading in first call to LockSupport.park.
    // See: https://bugs.openjdk.java.net/browse/JDK-8074773
    @SuppressWarnings("unused")
    Class<?> ensureLoaded = LockSupport.class;
  }

  private static final class DoNothingRunnable implements Runnable {
    @Override
    public void run() {}
  }

import java.util.function.Supplier;

import org.lastaflute.web.login.credential.LoginCredential;
import org.lastaflute.web.response.ActionResponse;

public class ActionResponseCredential implements LoginCredential {

    private final Supplier<ActionResponse> action;

    public ActionResponseCredential(final Supplier<ActionResponse> action) {
        this.action = action;
    }

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.crawler.container;

import org.lastaflute.di.core.factory.SingletonLaContainerFactory;

public class LastaCrawlerContainer implements CrawlerContainer {

    public LastaCrawlerContainer() {
        initialize();
    }

    @Override
    public <T> T getComponent(final String name) {

 * Entry}.
 *
 * @author Jared Levy
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
abstract class AbstractMapEntry<K extends @Nullable Object, V extends @Nullable Object>
    implements Entry<K, V> {

  @Override
  @ParametricNullness
  public abstract K getKey();

  @Override
  @ParametricNullness
  public abstract V getValue();

  @Override
  @ParametricNullness

import jcifs.Decodable;
import jcifs.internal.SMBProtocolDecodingException;
import jcifs.internal.util.SMBUtil;


/**
 * @author mbechler
 *
 */
public class ValidateNegotiateInfoResponse implements Decodable {

    private int capabilities;
    private byte[] serverGuid = new byte[16];
    private int securityMode;
    private int dialect;


    /**
     * @return the capabilities
     */

import jcifs.Encodable;
import jcifs.internal.SMBProtocolDecodingException;
import jcifs.internal.util.SMBUtil;


/**
 * @author mbechler
 *
 */
public class FileEndOfFileInformation implements FileInformation, Encodable {

    private long endOfFile;


    /**
     * 
     */
    public FileEndOfFileInformation () {}


    /**
     * {@inheritDoc}
     *