public unsafe string HSearch(string _fn, string _SI)
        {
            int    hcode, k;
            string tmp;

            CFileMngm.TbCars *bCars  = stackalloc CFileMngm.TbCars[1];
            byte[]            bbCars = new byte[sizeof(CFileMngm.TbCars)];
            FileStream        fCarsH = File.OpenRead(_fn);

            hcode = Hash(_SI);
            fCarsH.Seek(hcode * sizeof(CFileMngm.TbCars), SeekOrigin.Begin);
            fCarsH.Read(bbCars, 0, bbCars.Length);
            Marshal.Copy(bbCars, 0, (IntPtr)bCars, bbCars.Length);
            tmp = bCars->S.ToString("D3");
            for (k = 0; k < 30; k++)
            {
                tmp = tmp + Convert.ToChar(bCars->Mark[k]);
            }
            tmp = tmp + bCars->V.ToString("0.0");
            if (String.Compare(tmp, _SI) == 0)
            {
                return("Yes! " + hcode.ToString());
            }
            else
            {
                return("No!");
            }
        }
        public unsafe void CreHSH(string _fn, DataGridView _dgHCodes)
        {
            int    i, j, k;
            int    flen;
            int    hcode;
            string tmp, fnh;

            CFileMngm.TbCars *bCars  = stackalloc CFileMngm.TbCars[1];
            byte[]            bbCars = new byte[sizeof(CFileMngm.TbCars)];
            CFileMngm.TbCars  tmpCar;
            //Load file to array
            fnh = "";
            for (i = 0; i <= _fn.IndexOf("."); i++)
            {
                fnh = fnh + _fn[i];
            }
            fnh = fnh + "hsh";
            FileStream fCarsH = File.OpenWrite(fnh);

            tmpCar.S = 0;
            tmpCar.V = 0;
            for (i = 0; i < 30; i++)
            {
                bCars->Mark[i] = 32;
            }
            flen = h;
            _dgHCodes.Visible  = true;
            _dgHCodes.RowCount = 1;
            j = 0;
            for (i = 0; i < flen; i++)
            {
                Marshal.Copy((IntPtr)bCars, bbCars, 0, bbCars.Length);
                fCarsH.Write(bbCars, 0, bbCars.Length);
            }
            FileStream fCars = File.OpenRead(_fn);

            flen = (Int32)fCars.Length / sizeof(CFileMngm.TbCars);  // длина файла в байтах делим на количество байт в записи
            for (i = 0; i < flen; i++)
            {
                fCars.Read(bbCars, 0, bbCars.Length);
                Marshal.Copy(bbCars, 0, (IntPtr)bCars, bbCars.Length);
                tmpCar = bCars[0];
                tmp    = tmpCar.S.ToString("D3");
                for (k = 0; k < 30; k++)
                {
                    tmp = tmp + Convert.ToChar(tmpCar.Mark[k]);
                }
                tmp   = tmp + tmpCar.V.ToString("0.0");
                hcode = Hash(tmp);
                fCarsH.Seek(hcode * sizeof(CFileMngm.TbCars), SeekOrigin.Begin);
                fCarsH.Write(bbCars, 0, bbCars.Length);
                _dgHCodes.RowCount = _dgHCodes.RowCount + 1;
                _dgHCodes.Rows[j].Cells[0].Value = hcode.ToString("D2") + " - " + tmp;
                j = j + 1;
            }
            fCars.Close();
            fCarsH.Close();
        }
        public unsafe int DSearch(string _fn, string _SI)
        {
            int    left, middle, right;
            int    k, flen;
            string key;
            object SI;

            //object SI;
            CFileMngm.TbCars *bCars  = stackalloc CFileMngm.TbCars[1];
            byte[]            bbCars = new byte[sizeof(CFileMngm.TbCars)];
            FileStream        fCars  = File.OpenRead(_fn);

            flen  = (Int32)fCars.Length / sizeof(CFileMngm.TbCars); // number of records
            left  = 0;                                              // initialized
            right = flen - 1;                                       // the last element before the last one
            key   = "";                                             // initialized
            while (left < right)
            {
                middle = (left + right) / 2;
                fCars.Seek(middle * sizeof(CFileMngm.TbCars), SeekOrigin.Begin);
                fCars.Read(bbCars, 0, bbCars.Length);
                Marshal.Copy(bbCars, 0, (IntPtr)bCars, bbCars.Length);
                key = bCars->S.ToString("D3");
                for (k = 0; k < 30; k++)
                {
                    key = key + Convert.ToChar(bCars->Mark[k]);
                }
                key = key + bCars->V.ToString("0.0");
                if (String.Compare(key, _SI, true) < 0)
                {
                    left = middle + 1;
                }
                else
                {
                    right = middle;
                }
            }
            fCars.Seek(right * sizeof(CFileMngm.TbCars), SeekOrigin.Begin);
            fCars.Read(bbCars, 0, bbCars.Length);
            Marshal.Copy(bbCars, 0, (IntPtr)bCars, bbCars.Length);
            key = bCars->S.ToString("D3");
            for (k = 0; k < 30; k++)
            {
                key = key + Convert.ToChar(bCars->Mark[k]);
            }
            key = key + bCars->V.ToString("0.0");
            if (String.Compare(key, _SI, true) == 0)
            {
                return(right);
            }
            else
            {
                return(-1);
            }
        }
示例#4
0
        public unsafe void Divide(string _fn)
        {
            int i, j, k, lena;
            int flen;

            CFileMngm.TbCars *bCars  = stackalloc CFileMngm.TbCars[1];
            byte[]            bbCars = new byte[sizeof(CFileMngm.TbCars)];
            File.Delete(wfn[0]);
            File.Delete(wfn[1]);
            wf[0] = File.OpenWrite(wfn[0]);
            wf[1] = File.OpenWrite(wfn[1]);
            FileStream fCars = File.OpenRead(_fn);

            flen    = (Int32)fCars.Length / sizeof(CFileMngm.TbCars);
            fswitch = 0;
            lena    = 0;
            for (i = 0; i < flen; i++)
            {
                if ((i > (psize - 1)) & (i % psize == 0))
                {
                    InsSort(lena);
                    for (k = 0; k < lena; k++)
                    {
                        bCars[0] = arCars[k];
                        Marshal.Copy((IntPtr)bCars, bbCars, 0, bbCars.Length);
                        wf[fswitch].Write(bbCars, 0, bbCars.Length);
                    }
                    fswitch = (fswitch + 1) % 2;
                    fCars.Read(bbCars, 0, bbCars.Length);
                    Marshal.Copy(bbCars, 0, (IntPtr)bCars, bbCars.Length);
                    arCars[i % psize] = bCars[0];
                    lena = 1;
                }
                else
                {
                    fCars.Read(bbCars, 0, bbCars.Length);
                    Marshal.Copy(bbCars, 0, (IntPtr)bCars, bbCars.Length);
                    arCars[i % psize] = bCars[0];
                    lena = lena + 1;
                }
            }
            InsSort(lena);
            for (k = 0; k < lena; k++)
            {
                bCars[0] = arCars[k];
                Marshal.Copy((IntPtr)bCars, bbCars, 0, bbCars.Length);
                wf[fswitch].Write(bbCars, 0, bbCars.Length);
            }
            fCars.Close();
            wf[0].Close();
            wf[1].Close();
        }
示例#5
0
        public unsafe void Load(string _fn, DataGridView _dgCars)
        {
            int    i, j, k;
            int    flen;
            string s;

            CFileMngm.TbCars *bCars  = stackalloc CFileMngm.TbCars[1];
            byte[]            bbCars = new byte[sizeof(CFileMngm.TbCars)];
            FileStream        fCars  = File.OpenRead(_fn);

            flen             = (Int32)fCars.Length / sizeof(CFileMngm.TbCars);
            _dgCars.RowCount = flen + 1;
            for (i = 0; i < flen; i++)
            {
                fCars.Read(bbCars, 0, bbCars.Length);
                Marshal.Copy(bbCars, 0, (IntPtr)bCars, bbCars.Length);
                s = Encoding.UTF8.GetString(bbCars, 0, 30);
                _dgCars.Rows[i].Cells[0].Value = s;
                _dgCars.Rows[i].Cells[1].Value = bCars->V.ToString();
                _dgCars.Rows[i].Cells[2].Value = bCars->S.ToString();
            }
            fCars.Close();
        }
        public unsafe void FileSort(string _fn)
        {
            int    i, j, k;         /* + */
            int    flen;
            string key_tmp, key_ar; /* + */
            bool   eoc;             /* + */
            string s;               // is not used.

            CFileMngm.TbCars *bCars  = stackalloc CFileMngm.TbCars[1];
            byte[]            bbCars = new byte[sizeof(CFileMngm.TbCars)];
            CFileMngm.TbCars  tmpCar;
            //Load file to array
            FileStream fCars = File.OpenRead(_fn);

            flen = (Int32)fCars.Length / sizeof(CFileMngm.TbCars);
            CFileMngm.TbCars[] arCars = new CFileMngm.TbCars[flen];
            for (i = 0; i < flen; i++)
            {
                fCars.Read(bbCars, 0, bbCars.Length);
                Marshal.Copy(bbCars, 0, (IntPtr)bCars, bbCars.Length);
                arCars[i] = bCars[0];
            }

            //Sort array
            for (i = 1; i < flen; i++) /* + */     // begin with the second one
            {
                tmpCar  = arCars[i]; /* + */       // chose it
                key_tmp = tmpCar.S.ToString("D3"); // key field Speed
                for (k = 0; k < 30; k++)
                {
                    key_tmp = key_tmp + tmpCar.Mark[k].ToString();
                }
                key_tmp = key_tmp + tmpCar.V.ToString("0.0");
                j       = i - 1; /* + */                   // artificially generated an index of the previous one
                eoc     = false; /* + */                   // falsed end of circle
                while (!eoc) /* + */                       // check
                {
                    key_ar   = arCars[j].S.ToString("D3"); // next
                    bCars[0] = arCars[j];                  // removed to the buffer
                    for (k = 0; k < 30; k++)
                    {
                        key_ar = key_ar + bCars->Mark[k].ToString();  // chose the record with field and the key field
                    }
                    key_ar = key_ar + arCars[j].V.ToString("0.0");    // and added it the next key field
                    if (String.Compare(key_ar, key_tmp) <= 0) /* + */ // аналог A[j] < tmp
                    {
                        eoc = true;                                   /* + */
                    }
                    else                                              /* + */
                    {
                        arCars[j + 1] = arCars[j];                    /* + */
                        j             = j - 1;                        /* + */
                        if (j < 0)
                        {
                            eoc = true;
                        }
                    }
                }
                arCars[j + 1] = tmpCar;            /* + */
            }
            fCars.Close();
            fCars = File.OpenWrite(_fn);
            for (i = 0; i < flen; i++)
            {
                bCars[0] = arCars[i];
                Marshal.Copy((IntPtr)bCars, bbCars, 0, bbCars.Length);
                fCars.Write(bbCars, 0, bbCars.Length);
            }
            fCars.Close();
        }
示例#7
0
        public unsafe string Merge()
        {
            int[]             flen = new int[2];
            CFileMngm.TbCars *bw0 = stackalloc CFileMngm.TbCars[1];
            byte[]            bbw0 = new byte[sizeof(CFileMngm.TbCars)];
            CFileMngm.TbCars *bw1 = stackalloc CFileMngm.TbCars[1];
            byte[]            bbw1 = new byte[sizeof(CFileMngm.TbCars)];
            int    wpsize = psize;
            bool   eopm, eom;
            string keyw0, keyw1, fres;
            int    ip0, ip1;

            eom      = false;
            fgswitch = 0;
            fres     = "";
            while (!eom)
            {
                eopm    = false;
                fswitch = 0;
                wf[0]   = File.OpenRead(wfn[fgswitch]);
                flen[0] = (Int32)wf[0].Length / sizeof(CFileMngm.TbCars);
                wf[1]   = File.OpenRead(wfn[fgswitch + 1]);
                flen[1] = (Int32)wf[1].Length / sizeof(CFileMngm.TbCars);
                File.Delete(wfn[(fgswitch + 2) % 4]);
                File.Delete(wfn[(fgswitch + 2) % 4 + 1]);
                wf[2] = File.OpenWrite(wfn[(fgswitch + 2) % 4]);
                wf[3] = File.OpenWrite(wfn[(fgswitch + 2) % 4 + 1]);
                keyw0 = "";
                keyw1 = "";
                wf[0].Read(bbw0, 0, bbw0.Length);
                Marshal.Copy(bbw0, 0, (IntPtr)bw0, bbw0.Length);
                keyw0   = bw0->S.ToString("D3") + bw0->V.ToString("0.0");
                flen[0] = flen[0] - 1;
                ip0     = 1;
                wf[1].Read(bbw1, 0, bbw1.Length);
                Marshal.Copy(bbw1, 0, (IntPtr)bw1, bbw1.Length);
                keyw1   = bw1->S.ToString("D3") + bw1->V.ToString("0.0");
                flen[1] = flen[1] - 1;
                ip1     = 1;
                while (!eopm)
                {
                    switch (keyw0.CompareTo(keyw1))
                    {
                    case -1:
                        Marshal.Copy((IntPtr)bw0, bbw0, 0, bbw0.Length);
                        wf[2 + fswitch].Write(bbw0, 0, bbw0.Length);
                        if ((ip0 < wpsize) & (flen[0] > 0))
                        {
                            wf[0].Read(bbw0, 0, bbw0.Length);
                            Marshal.Copy(bbw0, 0, (IntPtr)bw0, bbw0.Length);
                            keyw0   = bw0->S.ToString("D3") + bw0->V.ToString("0.0");
                            ip0     = ip0 + 1;
                            flen[0] = flen[0] - 1;
                        }
                        else
                        {
                            keyw0 = "9999";
                        }
                        break;

                    case 0:
                        Marshal.Copy((IntPtr)bw0, bbw0, 0, bbw0.Length);
                        wf[2 + fswitch].Write(bbw0, 0, bbw0.Length);
                        if ((ip0 < wpsize) & (flen[0] > 0))
                        {
                            wf[0].Read(bbw0, 0, bbw0.Length);
                            Marshal.Copy(bbw0, 0, (IntPtr)bw0, bbw0.Length);
                            keyw0   = bw0->S.ToString("D3") + bw0->V.ToString("0.0");
                            ip0     = ip0 + 1;
                            flen[0] = flen[0] - 1;
                        }
                        else
                        {
                            keyw0 = "9999";
                        }
                        Marshal.Copy((IntPtr)bw1, bbw1, 0, bbw1.Length);
                        wf[2 + fswitch].Write(bbw1, 0, bbw1.Length);
                        if ((ip1 < wpsize) & (flen[1] > 0))
                        {
                            wf[1].Read(bbw1, 0, bbw1.Length);
                            Marshal.Copy(bbw1, 0, (IntPtr)bw1, bbw1.Length);
                            keyw1   = bw1->S.ToString("D3") + bw1->V.ToString("0.0");
                            ip1     = ip1 + 1;
                            flen[1] = flen[1] - 1;
                        }
                        else
                        {
                            keyw1 = "9999";
                        }
                        break;

                    case 1:
                        Marshal.Copy((IntPtr)bw1, bbw1, 0, bbw1.Length);
                        wf[2 + fswitch].Write(bbw1, 0, bbw1.Length);
                        if ((ip1 < wpsize) & (flen[1] > 0))
                        {
                            wf[1].Read(bbw1, 0, bbw1.Length);
                            Marshal.Copy(bbw1, 0, (IntPtr)bw1, bbw1.Length);
                            keyw1   = bw1->S.ToString("D3") + bw1->V.ToString("0.0");
                            ip1     = ip1 + 1;
                            flen[1] = flen[1] - 1;
                        }
                        else
                        {
                            keyw1 = "9999";
                        }
                        break;
                    }  //switch
                    if ((keyw0.CompareTo("9999") == 0) & (keyw1.CompareTo("9999") == 0))
                    {
                        if ((flen[0] == 0) & (flen[1] == 0))
                        {
                            eopm = true;
                        }
                        else
                        if (!(flen[0] == 0))
                        {
                            keyw0 = "";
                            wf[0].Read(bbw0, 0, bbw0.Length);
                            Marshal.Copy(bbw0, 0, (IntPtr)bw0, bbw0.Length);
                            keyw0   = bw0->S.ToString("D3") + bw0->V.ToString("0.0");
                            flen[0] = flen[0] - 1;
                            ip0     = 1;
                        }
                        if (!(flen[1] == 0))
                        {
                            keyw1 = "";
                            wf[1].Read(bbw1, 0, bbw1.Length);
                            Marshal.Copy(bbw1, 0, (IntPtr)bw1, bbw1.Length);
                            keyw1   = bw1->S.ToString("D3") + bw1->V.ToString("0.0");
                            flen[1] = flen[1] - 1;
                            ip1     = 1;
                        }
                        fswitch = (fswitch + 1) % 2;
                    }
                } // eopm
                if ((wf[2].Length > 0) & (wf[3].Length > 0))
                {
                    fgswitch = (fgswitch + 2) % 4;
                    wpsize   = wpsize * 2;
                }
                else
                {
                    if (wf[2].Length > 0)
                    {
                        fres = wfn[(fgswitch + 2) % 4];
                    }
                    else
                    {
                        fres = wfn[(fgswitch + 2) % 4 + 1];
                    }
                    eom = true;
                }
                wf[0].Close();
                wf[1].Close();
                wf[2].Close();
                wf[3].Close();
            } // eom
            return(fres);
        }     // Merge