Payload.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 TokenStream = Lucene.Net.Analysis.TokenStream;
using ArrayUtil = Lucene.Net.Util.ArrayUtil;

namespace Lucene.Net.Index
{
    
    [Serializable]
    public class Payload : System.ICloneable
    {
        protected internal byte[] data;
        
        protected internal int internalOffset;
        
        protected internal int internalLength;
        
        public Payload()
        {
            // nothing to do
        }
        
        public Payload(byte[] data):this(data, 0, data.Length)
        {
        }
        
        public Payload(byte[] data, int offset, int length)
        {
            if (offset < 0 || offset + length > data.Length)
            {
                throw new System.ArgumentException();
            }
            this.data = data;
            this.internalOffset = offset;
            this.internalLength = length;
        }

        public virtual void  SetData(byte[] value, int offset, int length)
        {
            this.data = value;
            this.internalOffset = offset;
            this.internalLength = length;
        }

        public virtual void SetData(byte[] value)
        {
            SetData(value, 0, value.Length);
        }

        public virtual byte[] GetData()
        {
            return this.data;
        }

        public virtual int Offset
        {
            get { return this.internalOffset; }
        }

        public virtual int Length
        {
            get { return this.internalLength; }
        }

        public virtual byte ByteAt(int index)
        {
            if (0 <= index && index < this.internalLength)
            {
                return this.data[this.internalOffset + index];
            }
            throw new System. IndexOutOfRangeException("Index of bound " + index);
        }
        
        public virtual byte[] ToByteArray()
        {
            byte[] retArray = new byte[this.internalLength];
            Array.Copy(this.data, this.internalOffset, retArray, 0, this.internalLength);
            return retArray;
        }
        
        public virtual void  CopyTo(byte[] target, int targetOffset)
        {
            if (this.internalLength > target.Length + targetOffset)
            {
                throw new System.IndexOutOfRangeException();
            }
            Array.Copy(this.data, this.internalOffset, target, targetOffset, this.internalLength);
        }
        
        public virtual System.Object Clone()
        {
            try
            {
                // Start with a shallow copy of data
                Payload clone = (Payload) base.MemberwiseClone();
                // Only copy the part of data that belongs to this Payload
                if (internalOffset == 0 && internalLength == data.Length)
                {
                    // It is the whole thing, so just clone it.
                    clone.data = new byte[data.Length];
                    data.CopyTo(clone.data, 0);
                }
                else
                {
                    // Just get the part
                    clone.data = this.ToByteArray();
                    clone.internalOffset = 0;
                }
                return clone;
            }
            catch (System.Exception e)
            {
                throw new System.SystemException(e.Message, e); // shouldn't happen
            }
        }
        
        public  override bool Equals(System.Object obj)
        {
            if (obj == this)
                return true;
            if (obj is Payload)
            {
                Payload other = (Payload) obj;
                if (internalLength == other.internalLength)
                {
                    for (int i = 0; i < internalLength; i++)
                        if (data[internalOffset + i] != other.data[other.internalOffset + i])
                            return false;
                    return true;
                }
                else
                    return false;
            }
            else
                return false;
        }
        
        public override int GetHashCode()
        {
            return ArrayUtil.HashCode(data, internalOffset, internalOffset + internalLength);
        }
    }
}