C# Lucene.Net.Store.Directory.CreateOutput方法代码示例

        public PreFlexRWStoredFieldsWriter(Directory directory, string segment, IOContext context)
        {
            Debug.Assert(directory != null);
            this.Directory = directory;
            this.Segment = segment;

            bool success = false;
            try
            {
                FieldsStream = directory.CreateOutput(IndexFileNames.SegmentFileName(segment, "", Lucene3xStoredFieldsReader.FIELDS_EXTENSION), context);
                IndexStream = directory.CreateOutput(IndexFileNames.SegmentFileName(segment, "", Lucene3xStoredFieldsReader.FIELDS_INDEX_EXTENSION), context);

                FieldsStream.WriteInt(Lucene3xStoredFieldsReader.FORMAT_CURRENT);
                IndexStream.WriteInt(Lucene3xStoredFieldsReader.FORMAT_CURRENT);

                success = true;
            }
            finally
            {
                if (!success)
                {
                    Abort();
                }
            }
        }

		internal FieldsWriter(Directory d, System.String segment, FieldInfos fn)
		{
			fieldInfos = fn;
			fieldsStream = d.CreateOutput(segment + ".fdt");
			indexStream = d.CreateOutput(segment + ".fdx");
			doClose = true;
		}

        public TermVectorsWriter(Directory directory, System.String segment, FieldInfos fieldInfos)
        {
            // Open files for TermVector storage
            tvx = directory.CreateOutput(segment + "." + IndexFileNames.VECTORS_INDEX_EXTENSION);
            tvx.WriteInt(TermVectorsReader.FORMAT_CURRENT);
            tvd = directory.CreateOutput(segment + "." + IndexFileNames.VECTORS_DOCUMENTS_EXTENSION);
            tvd.WriteInt(TermVectorsReader.FORMAT_CURRENT);
            tvf = directory.CreateOutput(segment + "." + IndexFileNames.VECTORS_FIELDS_EXTENSION);
            tvf.WriteInt(TermVectorsReader.FORMAT_CURRENT);

            this.fieldInfos = fieldInfos;
        }

        public TermVectorsWriter(Directory directory, System.String segment, FieldInfos fieldInfos)
        {
            // Open files for TermVector storage
            tvx = directory.CreateOutput(segment + TVX_EXTENSION);
            tvx.WriteInt(FORMAT_VERSION);
            tvd = directory.CreateOutput(segment + TVD_EXTENSION);
            tvd.WriteInt(FORMAT_VERSION);
            tvf = directory.CreateOutput(segment + TVF_EXTENSION);
            tvf.WriteInt(FORMAT_VERSION);

            this.fieldInfos = fieldInfos;
            fields = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(fieldInfos.Size()));
            terms = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10));
        }

        /// <summary>
        /// Save a single segment's info. </summary>
        public override void Write(Directory dir, SegmentInfo si, FieldInfos fis, IOContext ioContext)
        {
            string fileName = IndexFileNames.SegmentFileName(si.Name, "", Lucene46SegmentInfoFormat.SI_EXTENSION);
            si.AddFile(fileName);

            IndexOutput output = dir.CreateOutput(fileName, ioContext);

            bool success = false;
            try
            {
                CodecUtil.WriteHeader(output, Lucene46SegmentInfoFormat.CODEC_NAME, Lucene46SegmentInfoFormat.VERSION_CURRENT);
                // Write the Lucene version that created this segment, since 3.1
                output.WriteString(si.Version);
                output.WriteInt(si.DocCount);

                output.WriteByte((byte)(sbyte)(si.UseCompoundFile ? SegmentInfo.YES : SegmentInfo.NO));
                output.WriteStringStringMap(si.Diagnostics);
                output.WriteStringSet(si.Files);
                CodecUtil.WriteFooter(output);
                success = true;
            }
            finally
            {
                if (!success)
                {
                    IOUtils.CloseWhileHandlingException(output);
                    si.Dir.DeleteFile(fileName);
                }
                else
                {
                    output.Dispose();
                }
            }
        }

 /// <summary>Creates a file of the specified size with random data. </summary>
 private void  CreateRandomFile(Directory dir, System.String name, int size)
 {
     IndexOutput os = dir.CreateOutput(name);
     for (int i = 0; i < size; i++)
     {
         byte b = (byte) ((new System.Random().NextDouble()) * 256);
         os.WriteByte(b);
     }
     os.Close();
 }

		private void  Initialize(Directory directory, System.String segment, FieldInfos fis, int interval, bool isi)
		{
			indexInterval = interval;
			fieldInfos = fis;
			isIndex = isi;
			output = directory.CreateOutput(segment + (isIndex ? ".tii" : ".tis"));
			output.WriteInt(FORMAT); // write format
			output.WriteLong(0); // leave space for size
			output.WriteInt(indexInterval); // write indexInterval
			output.WriteInt(skipInterval); // write skipInterval
		}

 public PreFlexRWTermVectorsWriter(Directory directory, string segment, IOContext context)
 {
     this.Directory = directory;
     this.Segment = segment;
     bool success = false;
     try
     {
         // Open files for TermVector storage
         Tvx = directory.CreateOutput(IndexFileNames.SegmentFileName(segment, "", Lucene3xTermVectorsReader.VECTORS_INDEX_EXTENSION), context);
         Tvx.WriteInt(Lucene3xTermVectorsReader.FORMAT_CURRENT);
         Tvd = directory.CreateOutput(IndexFileNames.SegmentFileName(segment, "", Lucene3xTermVectorsReader.VECTORS_DOCUMENTS_EXTENSION), context);
         Tvd.WriteInt(Lucene3xTermVectorsReader.FORMAT_CURRENT);
         Tvf = directory.CreateOutput(IndexFileNames.SegmentFileName(segment, "", Lucene3xTermVectorsReader.VECTORS_FIELDS_EXTENSION), context);
         Tvf.WriteInt(Lucene3xTermVectorsReader.FORMAT_CURRENT);
         success = true;
     }
     finally
     {
         if (!success)
         {
             Abort();
         }
     }
 }

 public virtual void CopyFile(Directory dir, string src, string dest)
 {
     IndexInput @in = dir.OpenInput(src, NewIOContext(Random()));
     IndexOutput @out = dir.CreateOutput(dest, NewIOContext(Random()));
     var b = new byte[1024];
     long remainder = @in.Length();
     while (remainder > 0)
     {
         int len = (int)Math.Min(b.Length, remainder);
         @in.ReadBytes(b, 0, len);
         @out.WriteBytes(b, len);
         remainder -= len;
     }
     @in.Dispose();
     @out.Dispose();
 }

        public virtual FieldInfos CreateAndWriteFieldInfos(Directory dir, string filename)
        {
            //Positive test of FieldInfos
            Assert.IsTrue(TestDoc != null);
            FieldInfos.Builder builder = new FieldInfos.Builder();
            foreach (IndexableField field in TestDoc)
            {
                builder.AddOrUpdate(field.Name(), field.FieldType());
            }
            FieldInfos fieldInfos = builder.Finish();
            //Since the complement is stored as well in the fields map
            Assert.IsTrue(fieldInfos.Size() == DocHelper.All.Count); //this is all b/c we are using the no-arg constructor

            IndexOutput output = dir.CreateOutput(filename, NewIOContext(Random()));
            Assert.IsTrue(output != null);
            //Use a RAMOutputStream

            FieldInfosWriter writer = Codec.Default.FieldInfosFormat().FieldInfosWriter;
            writer.Write(dir, filename, "", fieldInfos, IOContext.DEFAULT);
            output.Dispose();
            return fieldInfos;
        }

        private int LastFieldNumber = -1; // only for assert

        #endregion Fields

        #region Constructors

        public PreFlexRWNormsConsumer(Directory directory, string segment, IOContext context)
        {
            string normsFileName = IndexFileNames.SegmentFileName(segment, "", NORMS_EXTENSION);
            bool success = false;
            IndexOutput output = null;
            try
            {
                output = directory.CreateOutput(normsFileName, context);
                // output.WriteBytes(NORMS_HEADER, 0, NORMS_HEADER.Length);
                foreach (var @sbyte in NORMS_HEADER)
                {
                    output.WriteByte((byte)@sbyte);
                }
                @out = output;
                success = true;
            }
            finally
            {
                if (!success)
                {
                    IOUtils.CloseWhileHandlingException(output);
                }
            }
        }

 private void  Demo_FSIndexInputBug(Directory fsdir, System.String file)
 {
     // Setup the test file - we need more than 1024 bytes
     IndexOutput os = fsdir.CreateOutput(file);
     for (int i = 0; i < 2000; i++)
     {
         os.WriteByte((byte) i);
     }
     os.Close();
     
     IndexInput in_Renamed = fsdir.OpenInput(file);
     
     // This read primes the buffer in IndexInput
     byte b = in_Renamed.ReadByte();
     
     // Close the file
     in_Renamed.Close();
     
     // ERROR: this call should fail, but succeeds because the buffer
     // is still filled
     b = in_Renamed.ReadByte();
     
     // ERROR: this call should fail, but succeeds for some reason as well
     in_Renamed.Seek(1099);
     
     // OK: this call correctly fails. We are now past the 1024 internal
     // buffer, so an actual IO is attempted, which fails
     Assert.Throws<NullReferenceException>(() => in_Renamed.ReadByte(), "expected readByte() to throw exception");
 }

 public override void Write(Directory directory, string segmentName, string segmentSuffix, FieldInfos infos, IOContext context)
 {
     string fileName = IndexFileNames.SegmentFileName(segmentName, "", FIELD_INFOS_EXTENSION);
     IndexOutput output = directory.CreateOutput(fileName, context);
     bool success = false;
     try
     {
         output.WriteVInt(FORMAT_PREFLEX_RW);
         output.WriteVInt(infos.Size());
         foreach (FieldInfo fi in infos)
         {
             sbyte bits = 0x0;
             if (fi.HasVectors())
             {
                 bits |= STORE_TERMVECTOR;
             }
             if (fi.OmitsNorms())
             {
                 bits |= OMIT_NORMS;
             }
             if (fi.HasPayloads())
             {
                 bits |= STORE_PAYLOADS;
             }
             if (fi.Indexed)
             {
                 bits |= IS_INDEXED;
                 Debug.Assert(fi.FieldIndexOptions == FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS || !fi.HasPayloads());
                 if (fi.FieldIndexOptions == FieldInfo.IndexOptions.DOCS_ONLY)
                 {
                     bits |= OMIT_TERM_FREQ_AND_POSITIONS;
                 }
                 else if (fi.FieldIndexOptions == FieldInfo.IndexOptions.DOCS_AND_FREQS)
                 {
                     bits |= OMIT_POSITIONS;
                 }
             }
             output.WriteString(fi.Name);
             /*
              * we need to write the field number since IW tries
              * to stabelize the field numbers across segments so the
              * FI ordinal is not necessarily equivalent to the field number
              */
             output.WriteInt(fi.Number);
             output.WriteByte((byte)bits);
             if (fi.Indexed && !fi.OmitsNorms())
             {
                 // to allow null norm types we need to indicate if norms are written
                 // only in RW case
                 output.WriteByte((byte)(sbyte)(fi.NormType == null ? 0 : 1));
             }
             Debug.Assert(fi.Attributes() == null); // not used or supported
         }
         success = true;
     }
     finally
     {
         if (success)
         {
             output.Dispose();
         }
         else
         {
             IOUtils.CloseWhileHandlingException(output);
         }
     }
 }

 /// <summary>Writes this vector to the file <code>name</code> in Directory
 /// <code>d</code>, in a format that can be read by the constructor {@link
 /// #BitVector(Directory, String)}.  
 /// </summary>
 public void Write(Directory d, System.String name)
 {
     IndexOutput output = d.CreateOutput(name);
     try
     {
         if (IsSparse())
         {
             WriteDgaps(output); // sparse bit-set more efficiently saved as d-gaps.
         }
         else
         {
             WriteBits(output);
         }
     }
     finally
     {
         output.Close();
     }
 }

        /// <summary>
        /// Sole constructor. </summary>
        public Lucene40StoredFieldsWriter(Directory directory, string segment, IOContext context)
        {
            Debug.Assert(directory != null);
            this.Directory = directory;
            this.Segment = segment;

            bool success = false;
            try
            {
                FieldsStream = directory.CreateOutput(IndexFileNames.SegmentFileName(segment, "", FIELDS_EXTENSION), context);
                IndexStream = directory.CreateOutput(IndexFileNames.SegmentFileName(segment, "", FIELDS_INDEX_EXTENSION), context);

                CodecUtil.WriteHeader(FieldsStream, CODEC_NAME_DAT, VERSION_CURRENT);
                CodecUtil.WriteHeader(IndexStream, CODEC_NAME_IDX, VERSION_CURRENT);
                Debug.Assert(HEADER_LENGTH_DAT == FieldsStream.FilePointer);
                Debug.Assert(HEADER_LENGTH_IDX == IndexStream.FilePointer);
                success = true;
            }
            finally
            {
                if (!success)
                {
                    Abort();
                }
            }
        }