Beispiel #1
0
        private int[] getIndex(PDFDictionary dict)
        {
            PDFArray Index = dict["Index"] as PDFArray;

            if (Index == null)
            {
                int[]     ind  = { 0, 0 };
                PDFNumber size = dict["Size"] as PDFNumber;
                if (size == null || size.GetValue() <= 0)
                {
                    throw new InvalidDocumentException();
                }

                ind[1] = (int)size.GetValue();
                return(ind);
            }

            int[] index = new int[Index.Count];
            for (int i = 0; i < Index.Count; ++i)
            {
                PDFNumber number = Index[i] as PDFNumber;
                if (number == null || number.GetValue() < 0)
                {
                    throw new InvalidDocumentException();
                }

                index[i] = (int)number.GetValue();
            }

            return(index);
        }
Beispiel #2
0
 internal RotatingRectangle(PDFArray array, Page page)
 {
     _array = array;
     _page  = page;
     if (array.Count != 8)
     {
         setDefault();
         changeArray();
     }
     else
     {
         float[] arrayf = new float[8];
         for (int i = 0; i < 8; ++i)
         {
             PDFNumber number = array[i] as PDFNumber;
             if (number == null)
             {
                 setDefault();
                 changeArray();
                 return;
             }
             arrayf[i] = (float)number.GetValue();
         }
         setFromArray(arrayf);
     }
 }
Beispiel #3
0
        protected override bool isHitInRange(PDFArray limits, object key)
        {
            if (key.GetType() != System.Type.GetType("int"))
            {
                throw new ArgumentException("Key must have a integer type for NumberTree.");
            }

            int number = (int)key;

            PDFNumber first = limits[0] as PDFNumber;
            PDFNumber last  = limits[1] as PDFNumber;

            if (first != null && last != null)
            {
                int comp1 = ((int)first.GetValue()).CompareTo(number);
                int comp2 = ((int)last.GetValue()).CompareTo(number);

                if (comp1 <= 0 && comp2 >= 0)
                {
                    return(true);
                }
            }

            return(false);
        }
Beispiel #4
0
        protected override IPDFObject findItem(PDFArray array, object key)
        {
            if (array == null)
            {
                return(null);
            }

            int number = (int)key;

            for (int i = 0; i < array.Count; i += 2)
            {
                PDFNumber val = array[i] as PDFNumber;
                if (i + 2 < array.Count)
                {
                    PDFNumber val_next = array[i + 2] as PDFNumber;
                    if (val != null && val_next != null &&
                        ((int)val.GetValue()) <= number && number < ((int)val_next.GetValue()))
                    {
                        return(array[i + 1]);
                    }
                }
                else
                {
                    if (val != null && ((int)val.GetValue()) <= number)
                    {
                        return(array[i + 1]);
                    }
                }
            }

            return(null);
        }
Beispiel #5
0
        internal override float GetTextWidth(PDFString str, float fontSize)
        {
            PDFArray  widths    = GetDictionary()["Widths"] as PDFArray;
            PDFNumber fc        = GetDictionary()["FirstChar"] as PDFNumber;
            int       firstChar = 0;

            if (fc != null)
            {
                firstChar = (int)fc.GetValue();
            }

            byte[] data   = str.GetBytes();
            float  result = 0;

            for (int i = 0; i < data.Length; ++i)
            {
                PDFNumber w = widths[data[i] - firstChar] as PDFNumber;
                if (w != null)
                {
                    return((float)(w.GetValue() * fontSize / 1000.0f));
                }
            }

            return(result);
        }
Beispiel #6
0
        internal override float GetCharWidth(char c, float fontSize)
        {
            PDFArray widths = GetDictionary()["Widths"] as PDFArray;

            if (widths != null)
            {
                PDFNumber fc        = GetDictionary()["FirstChar"] as PDFNumber;
                int       firstChar = 0;
                if (fc != null)
                {
                    firstChar = (int)fc.GetValue();
                }

                int       glyf = getGlyf(c);
                PDFNumber w    = widths[glyf - firstChar] as PDFNumber;
                if (w != null)
                {
                    return((float)(w.GetValue() * fontSize / 1000.0f));
                }
            }
            else
            {
                StandardFonts font;
                if (isStandardFont(out font))
                {
                    IGlyfMetrics metrics = getStandardFontMetrics(font);
                    return(metrics.GetCharWidth(c) * fontSize / 1000.0f);
                }
            }
            return(0);
        }
Beispiel #7
0
        internal static PDFDictionary Copy(PDFDictionary dict)
        {
            PDFDictionary newDict = new PDFDictionary();
            PDFName       type    = dict["Type"] as PDFName;

            if (type != null)
            {
                newDict.AddItem("Type", type.Clone());
            }

            PDFName s = dict["S"] as PDFName;

            if (s != null)
            {
                newDict.AddItem("S", s.Clone());
            }

            PDFString p = dict["P"] as PDFString;

            if (p != null)
            {
                newDict.AddItem("P", p.Clone());
            }

            PDFNumber st = dict["St"] as PDFNumber;

            if (st != null)
            {
                newDict.AddItem("St", st.Clone());
            }

            return(newDict);
        }
Beispiel #8
0
        private void addCount()
        {
            PDFNumber count = _dictionary["Count"] as PDFNumber;

            if (count == null || count.GetValue() >= 0)
            {
                _dictionary.AddItem("Count", new PDFNumber(Count));
            }
        }
Beispiel #9
0
        private void readPermissions(PDFDictionary dictionary)
        {
            PDFNumber perms = dictionary["P"] as PDFNumber;

            if (perms == null)
            {
                throw new PDFException();
            }
            _permission = (int)perms.GetValue();
        }
Beispiel #10
0
        private int getDefaultCharWidth()
        {
            PDFNumber dw = GetDictionary()["DW"] as PDFNumber;

            if (dw != null)
            {
                return((int)dw.GetValue());
            }

            return(1000);
        }
Beispiel #11
0
        internal override float GetCharWidth(char c, float fontSize)
        {
            if (c < 32 || c > 255)
            {
                return(0);
            }

            PDFArray  widths = GetDictionary()["Widths"] as PDFArray;
            PDFNumber w      = widths[c - 32] as PDFNumber;

            return((float)w.GetValue() * fontSize / 1000.0f);
        }
Beispiel #12
0
        /// <summary>
        /// Gets or sets the element at the specified index.
        /// </summary>
        /// <param name="index" href="http://msdn.microsoft.com/en-us/library/system.int32.aspx">The zero-based index of the element to get or set.</param>
        /// <returns cref="PointF" href="http://msdn.microsoft.com/en-us/library/system.drawing.pointf.aspx">The element at the specified index.</returns>
        public PointF this[int index]
        {
            get
            {
                if (index < 0 || index >= _array.Count / 2)
                {
                    throw new IndexOutOfRangeException();
                }
                PDFNumber numberX = _array[index * 2] as PDFNumber;
                PDFNumber numberY = _array[index * 2 + 1] as PDFNumber;
                if (numberX == null)
                {
                    numberX = new PDFNumber(0);
                }
                if (numberY == null)
                {
                    numberY = new PDFNumber(0);
                }
                float numX = (float)numberX.GetValue();
                float numY = (float)numberY.GetValue();
                if (_page != null)
                {
                    numX = numX - _page.PageRect.Left;
                    numY = _page.PageRect.Bottom - numY;
                }
                return(new PointF(numX, numY));
            }
            set
            {
                if (index < 0 || index >= _array.Count / 2)
                {
                    throw new IndexOutOfRangeException();
                }
                if (_page != null)
                {
                    value.X = value.X + _page.PageRect.Left;
                    value.Y = _page.PageRect.Bottom - value.Y;
                }
                _array.RemoveItem(index * 2);
                _array.RemoveItem(index * 2);
                _array.Insert(index * 2, new PDFNumber(value.Y));
                _array.Insert(index * 2, new PDFNumber(value.X));

                if (ChangedPointsArray != null)
                {
                    ChangedPointsArray(this);
                }
            }
        }
Beispiel #13
0
        private float getRectValue(byte num)
        {
            PDFArray rect = _dictionary["Rect"] as PDFArray;

            if (rect == null)
            {
                return(0);
            }

            PDFNumber val = rect[num] as PDFNumber;

            if (val == null)
            {
                return(0);
            }
            return((float)val.GetValue());
        }
Beispiel #14
0
        internal override float GetTextWidth(PDFString str, float fontSize)
        {
            PDFArray widths = GetDictionary()["Widths"] as PDFArray;
            float    result = 0.0f;

            byte[] buf = str.GetBytes();
            for (int i = 0; i < buf.Length; ++i)
            {
                PDFNumber w = widths[buf[i] - 32] as PDFNumber;
                if (w != null)
                {
                    result += (float)w.GetValue();
                }
            }

            result = result * fontSize / 1000.0f;
            return(result);
        }
Beispiel #15
0
        private void readAlgorithmVersion(PDFDictionary dictionary)
        {
            PDFNumber version = dictionary["V"] as PDFNumber;

            if (version != null)
            {
                int value = (int)version.GetValue();
                if (value >= 0 && value <= 5)
                {
                    _version = value;
                }
                else
                {
                    throw new PDFUnsupportEncryptorException();
                }
                return;
            }
            _revision = 0;
        }
Beispiel #16
0
        internal static PDFDictionary Copy(PDFDictionary dict)
        {
            PDFDictionary newDict = new PDFDictionary();
            PDFName       type    = dict["Type"] as PDFName;

            if (type != null)
            {
                newDict.AddItem("Type", type.Clone());
            }

            PDFNumber count = dict["Count"] as PDFNumber;

            if (count != null)
            {
                newDict.AddItem("Count", count.Clone());
            }

            PDFString title = dict["Title"] as PDFString;

            if (title != null)
            {
                newDict.AddItem("Title", title.Clone());
            }

            PDFArray c = dict["C"] as PDFArray;

            if (c != null)
            {
                newDict.AddItem("C", c.Clone());
            }

            PDFNumber f = dict["F"] as PDFNumber;

            if (f != null)
            {
                newDict.AddItem("F", f.Clone());
            }

            //First, Last, Parent, Prev, Next, SE - do not
            //Dest, A - need set after adding

            return(newDict);
        }
Beispiel #17
0
        private void readKeyLength(PDFDictionary dictionary)
        {
            PDFNumber lenght = dictionary["Length"] as PDFNumber;

            if (lenght != null)
            {
                int value = (int)lenght.GetValue();
                if ((value >= 40 && value <= 128 && value % 8 == 0) || (value == 256 && _revision == 5))
                {
                    _length = value;
                }
                else
                {
                    throw new InvalidDocumentException();
                }
                return;
            }
            _length = 40;
        }
Beispiel #18
0
        private void addItem(PDFArray array, IPDFObject key, IPDFObject value)
        {
            if (array == null)
            {
                return;
            }

            int number = (int)(key as PDFNumber).GetValue();

            for (int i = 0; i < array.Count; i += 2)
            {
                PDFNumber val = array[i] as PDFNumber;

                if (i + 2 < array.Count)
                {
                    PDFNumber val_next = array[i + 2] as PDFNumber;

                    if (val != null && val_next != null &&
                        ((int)val.GetValue()) <= number && number < ((int)val_next.GetValue()))
                    {
                        array.Insert(i + 2, key);
                        array.Insert(i + 3, value);
                        return;
                    }
                }
                else
                {
                    if (val != null && ((int)val.GetValue()) <= number)
                    {
                        array.AddItem(key);
                        array.AddItem(value);
                        return;
                    }
                    else
                    {
                        array.Insert(i, key);
                        array.Insert(i + 1, value);
                        return;
                    }
                }
            }
        }
Beispiel #19
0
        internal override float GetTextWidth(PDFString str, float fontSize)
        {
            PDFArray widths = GetDictionary()["Widths"] as PDFArray;

            byte[] data   = str.GetBytes();
            float  result = 0;

            if (widths != null)
            {
                PDFNumber fc        = GetDictionary()["FirstChar"] as PDFNumber;
                int       firstChar = 0;
                if (fc != null)
                {
                    firstChar = (int)fc.GetValue();
                }

                for (int i = 0; i < data.Length; ++i)
                {
                    PDFNumber w = widths[data[i] - firstChar] as PDFNumber;
                    if (w != null)
                    {
                        result += (float)w.GetValue();
                    }
                }

                return(result * fontSize / 1000.0f);
            }

            StandardFonts font;

            if (isStandardFont(out font))
            {
                IGlyfMetrics metrics = getStandardFontMetrics(font);
                string       tmp     = ConvertFromFontEncoding(str);
                for (int i = 0; i < tmp.Length; ++i)
                {
                    result += metrics.GetCharWidth(tmp[i]);
                }
            }

            return(result * fontSize / 1000.0f);
        }
Beispiel #20
0
        private int[] getW(PDFDictionary dict)
        {
            PDFArray W = dict["W"] as PDFArray;

            if (W == null)
            {
                throw new InvalidDocumentException();
            }
            int[] w = { 1, 1, 1 };
            for (int i = 0; i < W.Count; ++i)
            {
                PDFNumber number = W[i] as PDFNumber;
                if (number != null && number.GetValue() >= 0)
                {
                    w[i] = (int)number.GetValue();
                }
            }

            return(w);
        }
Beispiel #21
0
        private void deleteItem(PDFArray array, IPDFObject key)
        {
            if (array == null)
            {
                return;
            }

            int number = (int)(key as PDFNumber).GetValue();

            for (int i = 0; i < array.Count; i += 2)
            {
                PDFNumber val = array[i] as PDFNumber;
                if (val != null && ((int)val.GetValue()) == number)
                {
                    array.RemoveItem(i + 1);
                    array.RemoveItem(i);
                    return;
                }
            }
        }
Beispiel #22
0
        internal static PDFArray CopyArrayCoordinates(PDFArray source, RectangleF oldPageRect, RectangleF newPageRect, bool oldPageIsNull)
        {
            PDFArray arr = new PDFArray();

            for (int i = 0; i < source.Count; ++i)
            {
                PDFNumber num = source[i] as PDFNumber;
                if (num == null)
                {
                    arr.AddItem(new PDFNumber(0));
                }
                else
                {
                    double val = num.GetValue();
                    if (i % 2 == 0)//x
                    {
                        if (oldPageIsNull)
                        {
                            arr.AddItem(new PDFNumber(val + newPageRect.Left));
                        }
                        else
                        {
                            arr.AddItem(new PDFNumber(-oldPageRect.Left + val + newPageRect.Left));
                        }
                    }
                    else//y
                    {
                        if (oldPageIsNull)
                        {
                            arr.AddItem(new PDFNumber(newPageRect.Bottom - val));
                        }
                        else
                        {
                            arr.AddItem(new PDFNumber(newPageRect.Bottom - (oldPageRect.Bottom - val)));
                        }
                    }
                }
            }

            return(arr);
        }
Beispiel #23
0
        private void readRevision(PDFDictionary dictionary)
        {
            PDFNumber revision = dictionary["R"] as PDFNumber;

            if (revision != null)
            {
                int value = (int)revision.GetValue();
                if (value >= 2 && value <= 5)
                {
                    _revision = value;
                }

                if (_revision > 5)
                {
                    throw new PDFUnsupportEncryptorException();
                }
                return;
            }

            throw new PDFException();
        }
Beispiel #24
0
        private uint getFlag(PDFDictionary dict)
        {
            PDFNumber ff = dict["Ff"] as PDFNumber;

            if (ff == null)
            {
                PDFDictionary parent = dict["Parent"] as PDFDictionary;
                if (parent != null)
                {
                    ff = parent["Ff"] as PDFNumber;
                }
            }

            uint flag = 0;

            if (ff != null)
            {
                flag = (uint)ff.GetValue();
            }

            return(flag);
        }
Beispiel #25
0
        internal override float GetCharWidth(char c, float fontSize)
        {
            byte glyf = 0;

            if (!_charset.TryGetValue(c, out glyf))
            {
                return(0);
            }

            PDFNumber firstChar = GetDictionary()["FirstChar"] as PDFNumber;
            int       f         = (int)firstChar.GetValue();

            PDFArray  widths = GetDictionary()["Widths"] as PDFArray;
            PDFNumber num    = widths[glyf - f] as PDFNumber;

            if (num != null)
            {
                return((float)(num.GetValue() * fontSize / 1000.0f));
            }

            return(0);
        }
Beispiel #26
0
        private void parsePrevAndXrefStm()
        {
            if (_xrefPositions.Count == 0)
            {
                PDFNumber Prev    = _trailer["Prev"] as PDFNumber;
                PDFNumber XRefStm = _trailer["XRefStm"] as PDFNumber;

                if (XRefStm != null)
                {
                    int val = (int)XRefStm.GetValue();
                    _trailer.RemoveItem("XRefStm");
                    _parsedXrefTables.Add(val);
                    parseXref(val);
                }
                if (Prev != null)
                {
                    int val = (int)Prev.GetValue();
                    _trailer.RemoveItem("Prev");
                    _parsedXrefTables.Add(val);
                    parseXref(val);
                }
            }
        }
Beispiel #27
0
        private IPDFObject parseNumberOrLink(int firstByte)
        {
            bool succes;

            if (_usedLastParsedNumber)
            {
                _usedLastParsedNumber = false;
                if (!_lastParsedNumberIsInteger)
                {
                    return(new PDFNumber(_lastParsedNumber));
                }

                if (isNumberPart(firstByte))
                {
                    readLexeme(firstByte);

                    if (IsEOL(_lastParsedByte))
                    {
                        SkipEOL();
                    }
                    if (_lastParsedByte == 'R')
                    {
                        int second = CurrentLexemeToInteger(out succes);
                        if (!succes)
                        {
                            return(null);
                        }

                        _lastParsedByte = _stream.ReadByte();
                        return(new PDFLink(_xref, (int)_lastParsedNumber));
                    }

                    PDFNumber obj    = new PDFNumber(_lastParsedNumber);
                    int       number = CurrentLexemeToInteger(out succes);
                    if (!succes)
                    {
                        double n = CurrentLexemeToDouble(out succes);
                        if (!succes)
                        {
                            return(null);
                        }
                        _usedLastParsedNumber      = true;
                        _lastParsedNumberIsInteger = false;
                        _lastParsedNumber          = n;
                    }
                    else
                    {
                        _usedLastParsedNumber      = true;
                        _lastParsedNumberIsInteger = true;
                        _lastParsedNumber          = number;
                    }
                    return(obj);
                }
                else
                {
                    return(new PDFNumber(_lastParsedNumber));;
                }
            }
            else
            {
                readLexeme(firstByte);
                if (IsEOL(_lastParsedByte))
                {
                    SkipEOL();
                }

                if (!isNumberPart(_lastParsedByte))
                {
                    double val = CurrentLexemeToDouble(out succes);
                    if (!succes)
                    {
                        return(null);
                    }
                    return(new PDFNumber(val));
                }

                int first = CurrentLexemeToInteger(out succes);
                if (!succes)
                {
                    double val = CurrentLexemeToDouble(out succes);
                    if (!succes)
                    {
                        return(null);
                    }
                    return(new PDFNumber(val));
                }

                readLexeme(_lastParsedByte);
                if (IsEOL(_lastParsedByte))
                {
                    SkipEOL();
                }
                if (_lastParsedByte == 'R')
                {
                    int second = CurrentLexemeToInteger(out succes);
                    if (!succes)
                    {
                        return(null);
                    }

                    _lastParsedByte = _stream.ReadByte();
                    return(new PDFLink(_xref, first));
                }

                int number = CurrentLexemeToInteger(out succes);
                if (!succes)
                {
                    double n = CurrentLexemeToDouble(out succes);
                    if (!succes)
                    {
                        return(null);
                    }
                    _usedLastParsedNumber      = true;
                    _lastParsedNumberIsInteger = false;
                    _lastParsedNumber          = n;
                }
                else
                {
                    _usedLastParsedNumber      = true;
                    _lastParsedNumberIsInteger = true;
                    _lastParsedNumber          = number;
                }

                return(new PDFNumber(first));
            }
        }
Beispiel #28
0
        private void parseProperties(PDFArray arr, IDocumentEssential owner)
        {
            PDFNumber left, top;
            float     pageLeft = 0, pageBottom = 0;

            if (_page != null)
            {
                RectangleF rect = _page.PageRect;
                pageLeft   = rect.Left;
                pageBottom = rect.Bottom;
            }

            switch (_zoomMode)
            {
            case ZoomMode.FitBoundingVertical:
            case ZoomMode.FitVertical:
                left = arr[2] as PDFNumber;
                if (left != null)
                {
                    _left = (float)left.GetValue() - pageLeft;
                }
                break;

            case ZoomMode.FitBoundingHorizontal:
            case ZoomMode.FitHorizontal:
                top = arr[2] as PDFNumber;
                if (top != null)
                {
                    _top = pageBottom - (float)top.GetValue();
                }
                break;

            case ZoomMode.FitRectangle:
                //left bottom right top
                left = arr[2] as PDFNumber;
                if (left != null)
                {
                    _left = (float)left.GetValue() - pageLeft;
                }

                top = arr[5] as PDFNumber;
                if (top != null)
                {
                    _top = pageBottom - (float)top.GetValue();
                }

                PDFNumber bottom = arr[3] as PDFNumber;
                PDFNumber right  = arr[4] as PDFNumber;
                if (bottom != null)
                {
                    _height = pageBottom - _top - (float)bottom.GetValue();
                }
                if (right != null)
                {
                    _width = (float)right.GetValue() - (_left + pageLeft);
                }
                break;

            case ZoomMode.FitXYZ:
                left = arr[2] as PDFNumber;
                if (left != null)
                {
                    _left = (float)left.GetValue() - pageLeft;
                }

                top = arr[3] as PDFNumber;
                if (top != null)
                {
                    _top = pageBottom - (float)top.GetValue();
                }

                PDFNumber zoom = arr[4] as PDFNumber;
                if (zoom != null)
                {
                    _zoom = (int)(zoom.GetValue() * 100);
                }
                break;
            }
        }
Beispiel #29
0
        private int getGlyfWidth(ushort glyf)
        {
            PDFArray w  = getWidthsArray();
            int      dw = getDefaultCharWidth();

            if (w == null)
            {
                return(dw);
            }

            for (int i = 0; i < w.Count; ++i)
            {
                PDFNumber first = w[i] as PDFNumber;
                if (first != null)
                {
                    if (first.GetValue() > glyf)
                    {
                        return(dw);
                    }

                    if (first != null)
                    {
                        IPDFObject second = w[i + 1];
                        if (second is PDFNumber)
                        {
                            if (first.GetValue() <= glyf && glyf <= (second as PDFNumber).GetValue())
                            {
                                PDFNumber value = w[i + 2] as PDFNumber;
                                if (value != null)
                                {
                                    return((int)value.GetValue());
                                }
                                return(dw);
                            }
                            else
                            {
                                i += 2;
                            }
                        }
                        else if (second is PDFArray)
                        {
                            int count = (second as PDFArray).Count;
                            if (first.GetValue() <= glyf && glyf <= first.GetValue() + count)
                            {
                                int       index = glyf - (int)first.GetValue();
                                PDFNumber width = (second as PDFArray)[index] as PDFNumber;
                                if (width != null)
                                {
                                    return((int)width.GetValue());
                                }
                                return(dw);
                            }
                            else
                            {
                                ++i;
                            }
                        }
                    }
                }
            }

            return(dw);
        }
Beispiel #30
0
        private void parseGenerationEntry(Entry entry)
        {
            PDFDictionaryStream dictStream = GetObject(entry.Offset) as PDFDictionaryStream;

            if (dictStream != null)
            {
                PDFNumber n = dictStream.Dictionary["N"] as PDFNumber;
                if (n == null)
                {
                    return;
                }
                int count = (int)n.GetValue();
                if (count <= 0)
                {
                    return;
                }

                n = dictStream.Dictionary["First"] as PDFNumber;
                if (n == null)
                {
                    return;
                }
                int first = (int)n.GetValue();
                if (first < 0)
                {
                    return;
                }

                dictStream.Decode();
                List <int> objects = new List <int>();
                List <int> offsets = new List <int>();

                Lexer lexer = new Lexer(dictStream.GetStream(), this, null, 512);
                lexer.Position = 0;

                for (int i = 0; i < count; ++i)
                {
                    bool succes;
                    int  objNo = lexer.ReadInteger(out succes);
                    if (!succes)
                    {
                        break;
                    }
                    int offset = lexer.ReadInteger(out succes);
                    if (!succes)
                    {
                        break;
                    }
                    objects.Add(objNo);
                    offsets.Add(offset);
                }

                int l = objects.Count;
                for (int i = 0; i < l; ++i)
                {
                    lexer.Position = offsets[i] + first;
                    IPDFObject obj = lexer.ReadObject();
                    if (obj == null)
                    {
                        obj = new PDFNull();
                    }

                    int index = objects[i];
                    if (index >= 0 && index < _entries.Count)
                    {
                        if (_entries[index] == null)
                        {
                            _entries[index] = new Entry(0, 0);
                        }
                        if (entry.Offset == _entries[index].Offset)
                        {
                            _entries[index].Object = obj;
                        }
                    }
                }
            }
        }