Пример #1
0
        public void Build()
        {
            // формируем массив пар
            List <int>  keys_list    = new List <int>();
            List <long> offsets_list = new List <long>();

            bearing.Scan((off, obj) =>
            {
                if (applicable(obj))
                {
                    int hash = hashFun(obj);
                    keys_list.Add(hash);
                    offsets_list.Add(off);
                }
                return(true);
            });
            int[] keys = keys_list.ToArray();
            keys_list = null;
            long[] offsets = offsets_list.ToArray();
            offsets_list = null;
            int ne = keys.Length;

            // Сортируем по ключу
            Array.Sort(keys, offsets);

            // Эта часть делается если компаратор объектов comp задан
            // Производится сортировка участков с одинаковыми ключами
            if (comp != null)
            {
                // массив в который будет вкладываться набор объектов с одинаковыми ключами
                List <object> objs = new List <object>();
                // проходим по массиву ключей, в группах одинаковых ключей выделяем массив объектов
                int key, start = -1; // ключ интервала и начало интервала в массивах keys и offsets
                key = Int32.MinValue;
                // Фиксация накопленного в предыдущих переменных objs, key, start
                Action fixgroup = () =>
                {
                    int number = objs.Count;
                    if (number > 1)
                    {
                        long[] offs_small = new long[number];
                        for (int j = 0; j < number; j++)
                        {
                            offs_small[j] = offsets[start + j];
                        }
                        // Сортировка отрезка
                        Array.Sort(objs.ToArray(), offs_small, comp);
                        // вернуть отсортированные офсеты на место
                        for (int j = 0; j < number; j++)
                        {
                            offsets[start + j] = offs_small[j];
                        }
                    }
                };
                // Сканирование массивов keys, offsets
                for (int i = 0; i < ne; i++)
                {
                    int k = keys[i];
                    // смена ключа
                    if (i == 0 || k != key)
                    {
                        // фиксируем предыдущий отрезок (key, start), начинаем новый
                        fixgroup();
                        // Начать новый отрезок
                        key   = k;
                        start = i;
                        objs.Clear();
                    }
                    // основное действие
                    object ob = bearing.GetItem(offsets[i]);
                    objs.Add(ob);
                }
                if (objs.Count > 1)
                {
                    fixgroup();
                }
            }

            // Записываем
            keyoffsets.Clear(); // очищаем
            for (int i = 0; i < keys.Length; i++)
            {
                keyoffsets.AppendElement(new object[] { keys[i], offsets[i] });
            }
            keyoffsets.Flush();

            //if (scale != null && keys.Length == 0) scale = null;
            if (scale != null)
            {
                scale.Load(keys);
            }
            keys    = null;
            offsets = null;
            System.GC.Collect();
        }
Пример #2
0
        private object[] rare_elements = null; // --


        public void Build()
        {
            // Формируем последовательность offset_sequ
            offset_sequ.Clear();
            bearing.Scan((off, obj) =>
            {
                bool isapp = applicable(obj);
                if (applicable(obj))
                {
                    offset_sequ.AppendElement(off);
                }
                return(true);
            });
            offset_sequ.Flush();
            // Возможно, нам понадобятся два дополнительных стрима
            FileStream tmp_stream1 = null;
            FileStream tmp_stream2 = null;

            // Определяем рекурсивный метод построения Bld(long start_ind, long number) который в итоге переупорядочивает
            // отрезок последовательности offset_sequ так, что ссылаемые элементы становятся отсортированными.
            void Bld(long start_ind, long number)
            {
                if (number <= volume_of_offset_array)
                {
                    long[]   offsets  = new long[number];
                    object[] elements = new object[number];
                    // берем в массивы
                    for (long i = 0; i < number; i++)
                    {
                        long off = (long)offset_sequ.GetByIndex(start_ind + i);
                        offsets[i]  = off;
                        elements[i] = bearing.GetItem(off);
                    }
                    // Сортируем
                    Array.Sort(elements, offsets, comp_default);
                    // кладем из массивов в последовательность
                    for (long i = 0; i < number; i++)
                    {
                        if (i == 0)
                        {
                            offset_sequ.SetElement(offsets[i], offset_sequ.ElementOffset(start_ind));
                        }
                        else
                        {
                            offset_sequ.SetElement(offsets[i]);
                        }
                    }
                }
                else
                {
                    // надо разбить отрезок на два, в каждом сделать сортировку, а результаты слить.
                    long firsthalf_start   = start_ind;
                    long firsthalf_number  = number / 2;
                    long secondhalf_start  = start_ind + firsthalf_number;
                    long secondhalf_number = number - firsthalf_number;

                    Bld(firsthalf_start, firsthalf_number);
                    Bld(secondhalf_start, secondhalf_number);

                    if (tmp_stream1 == null)
                    {
                        tmp_stream1 = File.Open(tmpdir + "tmp1.$$$", FileMode.OpenOrCreate, FileAccess.ReadWrite);
                    }
                    if (tmp_stream2 == null)
                    {
                        tmp_stream2 = File.Open(tmpdir + "tmp2.$$$", FileMode.OpenOrCreate, FileAccess.ReadWrite);
                    }
                    tmp_stream1.Position = 0L;
                    tmp_stream2.Position = 0L;

                    byte[] buffer = new byte[buffersize];

                    Stream source1 = offset_sequ.Media;
                    source1.Position = 8 + firsthalf_start * 8;
                    long nbytes1 = firsthalf_number * 8;
                    while (nbytes1 > 0)
                    {
                        int nb = source1.Read(buffer, 0, nbytes1 >= buffer.Length ? buffer.Length : (int)nbytes1);
                        tmp_stream1.Write(buffer, 0, nb);
                        nbytes1 -= nb;
                    }
                    Stream source2 = offset_sequ.Media;
                    source2.Position = 8 + secondhalf_start * 8;
                    long nbytes2 = secondhalf_number * 8;
                    while (nbytes2 > 0)
                    {
                        int nb = source2.Read(buffer, 0, nbytes2 >= buffer.Length ? buffer.Length : (int)nbytes2);
                        tmp_stream2.Write(buffer, 0, nb);
                        nbytes2 -= nb;
                    }
                    tmp_stream1.Position = 0L;
                    BinaryReader br1  = new BinaryReader(tmp_stream1);
                    long         off1 = br1.ReadInt64();
                    object       obj1 = bearing.GetItem(off1);
                    long         nom1 = 0; // номер обрабатываемого элемента
                    tmp_stream2.Position = 0L;
                    BinaryReader br2     = new BinaryReader(tmp_stream2);
                    long         off2    = br2.ReadInt64();
                    object       obj2    = bearing.GetItem(off2);
                    long         nom2    = 0; // номер обрабатываемого элемента
                    long         out_ind = start_ind;
                    while (nom1 < firsthalf_number && nom2 < secondhalf_number)
                    {
                        if (comp_default.Compare(obj1, obj2) <= 0)
                        {
                            offset_sequ.SetElement(off1, offset_sequ.ElementOffset(out_ind));
                            nom1++;
                            if (nom1 < firsthalf_number)
                            {
                                off1 = br1.ReadInt64();
                                obj1 = bearing.GetItem(off1);
                            }
                        }
                        else
                        {
                            offset_sequ.SetElement(off2, offset_sequ.ElementOffset(out_ind));
                            nom2++;
                            if (nom2 < secondhalf_number)
                            {
                                off2 = br2.ReadInt64();
                                obj2 = bearing.GetItem(off2);
                            }
                        }
                        out_ind++;
                    }
                    // Перепись остатков
                    if (nom1 < firsthalf_number)
                    {
                        for (long ii = nom1; ii < firsthalf_number; ii++)
                        {
                            if (ii != nom1)
                            {
                                off1 = br1.ReadInt64();
                            }
                            offset_sequ.SetElement(off1, offset_sequ.ElementOffset(out_ind));
                            out_ind++;
                        }
                    }
                    else if (nom2 < secondhalf_number)
                    {
                        for (long ii = nom2; ii < secondhalf_number; ii++)
                        {
                            if (ii != nom2)
                            {
                                off2 = br2.ReadInt64();
                            }
                            offset_sequ.SetElement(off2, offset_sequ.ElementOffset(out_ind));
                            out_ind++;
                        }
                    }
                }
            };

            // Исполним
            Bld(0L, offset_sequ.Count());

            if (tmp_stream1 != null)
            {
                tmp_stream1.Close();
                File.Delete(tmpdir + "tmp1.$$$");
            }
            if (tmp_stream2 != null)
            {
                tmp_stream2.Close();
                File.Delete(tmpdir + "tmp2.$$$");
            }
            Refresh();
        }