RAMDirectoryUtil.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:4k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.contrib.index.lucene;
  19. import java.io.DataInput;
  20. import java.io.DataOutput;
  21. import java.io.IOException;
  22. import org.apache.hadoop.io.Text;
  23. import org.apache.lucene.store.IndexInput;
  24. import org.apache.lucene.store.IndexOutput;
  25. import org.apache.lucene.store.RAMDirectory;
  26. /**
  27.  * A utility class which writes an index in a ram dir into a DataOutput and
  28.  * read from a DataInput an index into a ram dir.
  29.  */
  30. public class RAMDirectoryUtil {
  31.   private static final int BUFFER_SIZE = 1024; // RAMOutputStream.BUFFER_SIZE;
  32.   /**
  33.    * Write a number of files from a ram directory to a data output.
  34.    * @param out  the data output
  35.    * @param dir  the ram directory
  36.    * @param names  the names of the files to write
  37.    * @throws IOException
  38.    */
  39.   public static void writeRAMFiles(DataOutput out, RAMDirectory dir,
  40.       String[] names) throws IOException {
  41.     out.writeInt(names.length);
  42.     for (int i = 0; i < names.length; i++) {
  43.       Text.writeString(out, names[i]);
  44.       long length = dir.fileLength(names[i]);
  45.       out.writeLong(length);
  46.       if (length > 0) {
  47.         // can we avoid the extra copy?
  48.         IndexInput input = null;
  49.         try {
  50.           input = dir.openInput(names[i], BUFFER_SIZE);
  51.           int position = 0;
  52.           byte[] buffer = new byte[BUFFER_SIZE];
  53.           while (position < length) {
  54.             int len =
  55.                 position + BUFFER_SIZE <= length ? BUFFER_SIZE
  56.                     : (int) (length - position);
  57.             input.readBytes(buffer, 0, len);
  58.             out.write(buffer, 0, len);
  59.             position += len;
  60.           }
  61.         } finally {
  62.           if (input != null) {
  63.             input.close();
  64.           }
  65.         }
  66.       }
  67.     }
  68.   }
  69.   /**
  70.    * Read a number of files from a data input to a ram directory.
  71.    * @param in  the data input
  72.    * @param dir  the ram directory
  73.    * @throws IOException
  74.    */
  75.   public static void readRAMFiles(DataInput in, RAMDirectory dir)
  76.       throws IOException {
  77.     int numFiles = in.readInt();
  78.     for (int i = 0; i < numFiles; i++) {
  79.       String name = Text.readString(in);
  80.       long length = in.readLong();
  81.       if (length > 0) {
  82.         // can we avoid the extra copy?
  83.         IndexOutput output = null;
  84.         try {
  85.           output = dir.createOutput(name);
  86.           int position = 0;
  87.           byte[] buffer = new byte[BUFFER_SIZE];
  88.           while (position < length) {
  89.             int len =
  90.                 position + BUFFER_SIZE <= length ? BUFFER_SIZE
  91.                     : (int) (length - position);
  92.             in.readFully(buffer, 0, len);
  93.             output.writeBytes(buffer, 0, len);
  94.             position += len;
  95.           }
  96.         } finally {
  97.           if (output != null) {
  98.             output.close();
  99.           }
  100.         }
  101.       }
  102.     }
  103.   }
  104. }