wdocument.java

分布式全文搜索工具包 可以支持集群 主要使用java開發 比較方便使用

/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.hadoop.contrib.dlucene.writable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.util.List;

import org.apache.hadoop.contrib.dlucene.Utils;
import org.apache.hadoop.contrib.dlucene.writable.SearchResults.FieldType;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.Writable;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.Field.Index;
import org.apache.lucene.document.Field.Store;

/**
 * A {@link Writable} wrapper for {@link Document}.
 */
public class WDocument implements Writable {

  /** The document. */
  private Document document = null;

  /**
   * Constructor.
   * 
   * @param document the Document.
   */
  public WDocument(Document document) {
    this.document = document;
  }

  /**
   * Constructor.
   */
  private WDocument() {
    this.document = new Document();
  }

  /**
   * Get the document being wrapped.
   * 
   * @return the Document
   */
  public Document getDocument() {
    return this.document;
  }

  /**
   * Deserialize the document.
   * 
   * @param in the input stream
   * @return the document
   * @throws IOException
   */
  public static WDocument read(DataInput in) throws IOException {
    WDocument document = new WDocument();
    document.readFields(in);
    return document;
  }

  // ///////////////////////////////////////////////
  // Writable
  // ///////////////////////////////////////////////

  /*
   * (non-Javadoc)
   * 
   * @see org.apache.hadoop.io.Writable#write(java.io.DataOutput)
   */
  public void write(DataOutput out) throws IOException {
    Utils.checkArgs(out);
    List<Field> fields = document.getFields();
    out.writeInt(fields.size());
    for (Field f : fields) {
      out.writeBoolean(f.isCompressed());
      out.writeBoolean(f.isIndexed());
      out.writeBoolean(f.isStored());
      out.writeBoolean(f.isTokenized());
      out.writeBoolean(f.getOmitNorms());

      // out.writeBoolean(f.isBinary());
      // out.writeBoolean(f.isLazy());
      // out.writeBoolean(f.isStoreOffsetWithTermVector());
      // out.writeBoolean(f.isStorePositionWithTermVector());
      // out.writeBoolean(f.isTermVectorStored());
      // out.writeFloat(f.getBoost());

      Text.writeString(out, f.name());

      FieldType fType = null;
      if (f.readerValue() != null)
        fType = FieldType.READER;
      else if (f.stringValue() != null)
        fType = FieldType.STRING;
      else if (f.binaryValue() != null)
        fType = FieldType.BINARY;
      else if (f.tokenStreamValue() != null)
        fType = FieldType.TOKENSTREAM;
      if (fType != null) {
        out.writeInt(fType.ordinal());
      }

      if (fType == FieldType.STRING)
        Text.writeString(out, f.stringValue());
      else if (fType == FieldType.BINARY) {
        out.writeInt(f.binaryValue().length);
        out.write(f.binaryValue());
      } else if (fType == FieldType.READER)
        throw new IOException(
            "Fields of type Reader are not currently supported");
      else if (fType == FieldType.TOKENSTREAM)
        throw new IOException(
            "Fields of type TokenStream are not currently supported");
    }
  }

  /*
   * (non-Javadoc)
   * 
   * @see org.apache.hadoop.io.Writable#readFields(java.io.DataInput)
   */
  public void readFields(DataInput in) throws IOException {
    Utils.checkArgs(in);

    int m = in.readInt();
    for (int j = 0; j < m; j++) {

      boolean isCompressed = in.readBoolean();
      boolean isIndexed = in.readBoolean();
      boolean isStored = in.readBoolean();
      boolean isTokenized = in.readBoolean();
      boolean omitNorms = in.readBoolean();

      // boolean isBinary = in.readBoolean();
      // boolean isLazy = in.readBoolean();
      // boolean isStoreOffsetWithTermVector = in.readBoolean();
      // boolean isStorePositionWithTermVector = in.readBoolean();
      // boolean isTermVectorStored = in.readBoolean();
      // float boost = in.readFloat();

      String name = Text.readString(in);
      Field.Store store = null;
      if (isStored && !isCompressed) {
        store = Store.YES;
      } else if (isStored && isCompressed) {
        store = Store.COMPRESS;
      } else if (!isStored && !isCompressed) {
        store = Store.NO;
      }

      Field.Index index = null;
      if (!isIndexed && !isTokenized) {
        index = Index.NO;
      } else if (isIndexed && isTokenized) {
        index = Index.TOKENIZED;
      } else if (isIndexed && !isTokenized && !omitNorms) {
        index = Index.UN_TOKENIZED;
      } else if (isIndexed && !isTokenized && omitNorms) {
        index = Index.NO_NORMS;
      }

      FieldType fType = FieldType.values()[in.readInt()];
      Field f = null;
      String sValue = null;
      byte[] bValue = null;
      if (fType == FieldType.STRING) {
        sValue = Text.readString(in);
        f = new Field(name, sValue, store, index);
      } else if (fType == FieldType.BINARY) {
        int length = in.readInt();
        bValue = new byte[length];
        in.readFully(bValue);
        f = new Field(name, bValue, store);
      } else if (fType == FieldType.READER)
        throw new IOException(
            "Fields of type Reader are not currently supported");
      else if (fType == FieldType.TOKENSTREAM)
        throw new IOException(
            "Fields of type TokenStream are not currently supported");

      document.add(f);
    }
  }
}