IndexOutput.cs

Go to the documentation of this file.

/* 
 * 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.
 */

using System;
using Lucene.Net.Support;
using UnicodeUtil = Lucene.Net.Util.UnicodeUtil;

namespace Lucene.Net.Store
{
    
    public abstract class IndexOutput : IDisposable
    {
        public abstract void  WriteByte(byte b);
        
        public virtual void  WriteBytes(byte[] b, int length)
        {
            WriteBytes(b, 0, length);
        }
        
        public abstract void  WriteBytes(byte[] b, int offset, int length);
        
        public virtual void  WriteInt(int i)
        {
            WriteByte((byte) (i >> 24));
            WriteByte((byte) (i >> 16));
            WriteByte((byte) (i >> 8));
            WriteByte((byte) i);
        }
        
        public virtual void  WriteVInt(int i)
        {
            while ((i & ~ 0x7F) != 0)
            {
                WriteByte((byte) ((i & 0x7f) | 0x80));
                i = Number.URShift(i, 7);
            }
            WriteByte((byte) i);
        }
        
        public virtual void  WriteLong(long i)
        {
            WriteInt((int) (i >> 32));
            WriteInt((int) i);
        }
        
        public virtual void  WriteVLong(long i)
        {
            while ((i & ~ 0x7F) != 0)
            {
                WriteByte((byte) ((i & 0x7f) | 0x80));
                i = Number.URShift(i, 7);
            }
            WriteByte((byte) i);
        }
        
        public virtual void  WriteString(System.String s)
        {
            UnicodeUtil.UTF8Result utf8Result = new UnicodeUtil.UTF8Result();
            UnicodeUtil.UTF16toUTF8(s, 0, s.Length, utf8Result);
            WriteVInt(utf8Result.length);
            WriteBytes(utf8Result.result, 0, utf8Result.length);
        }
        
        [Obsolete("-- please pre-convert to utf8 bytes instead or use WriteString")]
        public virtual void  WriteChars(System.String s, int start, int length)
        {
            int end = start + length;
            for (int i = start; i < end; i++)
            {
                int code = (int) s[i];
                if (code >= 0x01 && code <= 0x7F)
                    WriteByte((byte) code);
                else if (((code >= 0x80) && (code <= 0x7FF)) || code == 0)
                {
                    WriteByte((byte) (0xC0 | (code >> 6)));
                    WriteByte((byte) (0x80 | (code & 0x3F)));
                }
                else
                {
                    WriteByte((byte) (0xE0 | (Number.URShift(code, 12))));
                    WriteByte((byte) (0x80 | ((code >> 6) & 0x3F)));
                    WriteByte((byte) (0x80 | (code & 0x3F)));
                }
            }
        }
        
        [Obsolete("-- please pre-convert to utf8 bytes instead or use WriteString")]
        public virtual void  WriteChars(char[] s, int start, int length)
        {
            int end = start + length;
            for (int i = start; i < end; i++)
            {
                int code = (int) s[i];
                if (code >= 0x01 && code <= 0x7F)
                    WriteByte((byte) code);
                else if (((code >= 0x80) && (code <= 0x7FF)) || code == 0)
                {
                    WriteByte((byte) (0xC0 | (code >> 6)));
                    WriteByte((byte) (0x80 | (code & 0x3F)));
                }
                else
                {
                    WriteByte((byte) (0xE0 | (Number.URShift(code, 12))));
                    WriteByte((byte) (0x80 | ((code >> 6) & 0x3F)));
                    WriteByte((byte) (0x80 | (code & 0x3F)));
                }
            }
        }
        
        private static int COPY_BUFFER_SIZE = 16384;
        private byte[] copyBuffer;
        
        public virtual void  CopyBytes(IndexInput input, long numBytes)
        {
            System.Diagnostics.Debug.Assert(numBytes >= 0, "numBytes=" + numBytes);
            long left = numBytes;
            if (copyBuffer == null)
                copyBuffer = new byte[COPY_BUFFER_SIZE];
            while (left > 0)
            {
                int toCopy;
                if (left > COPY_BUFFER_SIZE)
                    toCopy = COPY_BUFFER_SIZE;
                else
                    toCopy = (int) left;
                input.ReadBytes(copyBuffer, 0, toCopy);
                WriteBytes(copyBuffer, 0, toCopy);
                left -= toCopy;
            }
        }
        
        public abstract void  Flush();

        [Obsolete("Use Dispose() instead.")]
        public void Close()
        {
            Dispose();
        }

        public void Dispose()
        {
            Dispose(true);
        }

        protected abstract void Dispose(bool disposing);

        public abstract long FilePointer { get; }

        public abstract void  Seek(long pos);

        public abstract long Length { get; }

        public virtual void  SetLength(long length)
        {
        }
        
        
        // map must be Map<String, String>
        public virtual void  WriteStringStringMap(System.Collections.Generic.IDictionary<string,string> map)
        {
            if (map == null)
            {
                WriteInt(0);
            }
            else
            {
                WriteInt(map.Count);
                foreach (var entry in map)
                {
                    WriteString(entry.Key);
                    WriteString(entry.Value);
                }
            }
        }
    }
}