Beispiel #1
0
        private int MergeWithRight(int index, T value)
        {
            // E.g. [1 1][2 2 2][1] into [1 1][2 2][9][1]
            if (index + 1 >= List.Count || List[index + 1].Value.CompareTo(value) != 0)
            {
                List[index] = new RLEDataPair <T>(List[index].Key - 1, List[index].Value); // --List[index].Key;
                List.Insert(index + 1, new RLEDataPair <T>(1, value));
                return(index + 1);
            }
            else
            // E.g. [1 1][2 2 2][1] into [1 1][2 2][1 1]
            {
                List[index] = new RLEDataPair <T>(List[index].Key - 1, List[index].Value); // --List[index].Key;
                if (List[index].Key == 0)
                {
                    // [1 1][2][3 3] into [1 1][3 3 3]
                    List.RemoveAt(index);
                    --index;
                }
                // This following can happen if run has a length of one
                // and merge with left and right needs to be done
                else if (List[index].Value.CompareTo(List[index + 1].Value) == 0)
                {
                    // [2 2][1][1 1] into [2 2][1 1 1]
                    List[index + 1] = new RLEDataPair <T>(List[index + 1].Key + List[index].Key + 1, List[index + 1].Value); // List[index + 1].Key += List[index].Key + 1;
                    List.RemoveAt(index);
                    return(index);
                }

                List[index] = new RLEDataPair <T>(List[index].Key + 1, List[index].Value); // ++List[index].Key;
                return(index + 1);
            }
        }
Beispiel #2
0
 public void Assign(List <RLEDataPair <T> > arr)
 {
     m_decompressedLength = 0;
     for (int i = 0; i < arr.Count; i++)
     {
         RLEDataPair <T> t = arr[i];
         m_decompressedLength += t.Key;
     }
     List = arr;
 }
Beispiel #3
0
 public void Assign(RLEDataPair <T>[] arr)
 {
     m_decompressedLength = 0;
     for (int i = 0; i < arr.Length; i++)
     {
         RLEDataPair <T> t = arr[i];
         m_decompressedLength += t.Key;
     }
     List = new List <RLEDataPair <T> >(arr);
 }
Beispiel #4
0
        public void SetDataOnIndex(int index, T value)
        {
            int sum = 0;

            for (int i = 0; i < List.Count; i++)
            {
                sum += List[i].Key;
                if (sum <= index)
                {
                    continue;
                }

                // Do nothing if we are trying to set the same value
                // This further simplifies logic behind merging adjacent runs
                // because we now know that the position on index is going to
                // contain different data
                if (List[i].Value.CompareTo(value) == 0)
                {
                    return;
                }

                var maxPosWithinRun = List[i].Key - 1;
                var posWithinRun    = index - (sum - List[i].Key);

                // If we are at run's edge let's merge adjacent runs if possible
                if (List[i].Key == 1)
                {
                    var newIndex = MergeWithLeft(i, value);
                    MergeWithRight(newIndex, value);
                }
                else
                if (posWithinRun == 0)
                {
                    MergeWithLeft(i, value);
                }
                else
                if (posWithinRun == maxPosWithinRun)
                {
                    MergeWithRight(i, value);
                }
                else
                // Nothing to merge. Split the old run and place a new one in the middle
                {
                    var tmpCnt = List[i].Key;

                    List[i] = new RLEDataPair <T>(posWithinRun, List[i].Value);
                    List.Insert(i + 1, new RLEDataPair <T>(1, value));
                    List.Insert(i + 2, new RLEDataPair <T>(tmpCnt - List[i].Key - 1, List[i].Value));
                }

                return;
            }
        }
Beispiel #5
0
        public void Decompress(ref T[] outData)
        {
            int offset = 0;

            for (int i = 0; i < List.Count; i++)
            {
                RLEDataPair <T> pair = List[i];
                for (int j = 0; j < pair.Key; j++)
                {
                    outData[offset + j] = pair.Value;
                }

                offset += pair.Key;
            }
        }
Beispiel #6
0
        public T[] Decompress()
        {
            T[] data = new T[m_decompressedLength];

            // 2nd pass - decompress data
            int offset = 0;

            for (int i = 0; i < List.Count; i++)
            {
                RLEDataPair <T> pair = List[i];
                for (int j = 0; j < pair.Key; j++)
                {
                    data[offset + j] = pair.Value;
                }

                offset += pair.Key;
            }

            return(data);
        }