示例#1
0
            internal virtual void AddWord(int wordNum, byte word)
            {
                Debug.Assert(wordNum > LastWordNum);
                Debug.Assert(word != 0);

                if (!Reverse)
                {
                    if (LastWordNum == -1)
                    {
                        Clean = 2 + wordNum; // special case for the 1st sequence
                        DirtyWords.WriteByte(word);
                    }
                    else
                    {
                        switch (wordNum - LastWordNum)
                        {
                        case 1:
                            if (word == 0xFF && (byte)DirtyWords.Bytes[DirtyWords.Length - 1] == 0xFF)
                            {
                                --DirtyWords.Length;
                                WriteSequence();
                                Reverse = true;
                                Clean   = 2;
                            }
                            else
                            {
                                DirtyWords.WriteByte(word);
                            }
                            break;

                        case 2:
                            DirtyWords.WriteByte(0);
                            DirtyWords.WriteByte(word);
                            break;

                        default:
                            WriteSequence();
                            Clean = wordNum - LastWordNum - 1;
                            DirtyWords.WriteByte(word);
                            break;
                        }
                    }
                }
                else
                {
                    Debug.Assert(LastWordNum >= 0);
                    switch (wordNum - LastWordNum)
                    {
                    case 1:
                        if (word == 0xFF)
                        {
                            if (DirtyWords.Length == 0)
                            {
                                ++Clean;
                            }
                            else if ((byte)DirtyWords.Bytes[DirtyWords.Length - 1] == 0xFF)
                            {
                                --DirtyWords.Length;
                                WriteSequence();
                                Clean = 2;
                            }
                            else
                            {
                                DirtyWords.WriteByte(word);
                            }
                        }
                        else
                        {
                            DirtyWords.WriteByte(word);
                        }
                        break;

                    case 2:
                        DirtyWords.WriteByte(0);
                        DirtyWords.WriteByte(word);
                        break;

                    default:
                        WriteSequence();
                        Reverse = false;
                        Clean   = wordNum - LastWordNum - 1;
                        DirtyWords.WriteByte(word);
                        break;
                    }
                }
                LastWordNum  = wordNum;
                Cardinality += BitUtil.BitCount(word);
            }
示例#2
0
            internal virtual void AddWord(int wordNum, byte word)
            {
                if (Debugging.AssertsEnabled)
                {
                    Debugging.Assert(wordNum > lastWordNum);
                    Debugging.Assert(word != 0);
                }

                if (!reverse)
                {
                    if (lastWordNum == -1)
                    {
                        clean = 2 + wordNum; // special case for the 1st sequence
                        dirtyWords.WriteByte(word);
                    }
                    else
                    {
                        switch (wordNum - lastWordNum)
                        {
                        case 1:
                            if (word == 0xFF && (byte)dirtyWords.Bytes[dirtyWords.Length - 1] == 0xFF)
                            {
                                --dirtyWords.Length;
                                WriteSequence();
                                reverse = true;
                                clean   = 2;
                            }
                            else
                            {
                                dirtyWords.WriteByte(word);
                            }
                            break;

                        case 2:
                            dirtyWords.WriteByte(0);
                            dirtyWords.WriteByte(word);
                            break;

                        default:
                            WriteSequence();
                            clean = wordNum - lastWordNum - 1;
                            dirtyWords.WriteByte(word);
                            break;
                        }
                    }
                }
                else
                {
                    if (Debugging.AssertsEnabled)
                    {
                        Debugging.Assert(lastWordNum >= 0);
                    }
                    switch (wordNum - lastWordNum)
                    {
                    case 1:
                        if (word == 0xFF)
                        {
                            if (dirtyWords.Length == 0)
                            {
                                ++clean;
                            }
                            else if ((byte)dirtyWords.Bytes[dirtyWords.Length - 1] == 0xFF)
                            {
                                --dirtyWords.Length;
                                WriteSequence();
                                clean = 2;
                            }
                            else
                            {
                                dirtyWords.WriteByte(word);
                            }
                        }
                        else
                        {
                            dirtyWords.WriteByte(word);
                        }
                        break;

                    case 2:
                        dirtyWords.WriteByte(0);
                        dirtyWords.WriteByte(word);
                        break;

                    default:
                        WriteSequence();
                        reverse = false;
                        clean   = wordNum - lastWordNum - 1;
                        dirtyWords.WriteByte(word);
                        break;
                    }
                }
                lastWordNum  = wordNum;
                cardinality += BitUtil.BitCount(word);
            }