fileworks.cs

按照Clifford A . Shaffer《数据结构与算法分析（第二版）》指导

using System;
using System.Collections.Generic;
using System.Collections;
using System.Text;
using System.IO;
//using Microsoft.VisualBasic.CompilerServices;

namespace DSwork
{
    class Fileworks
    {
        //这里是MainRec中最大的Offset//实际上是记录数(包括已删除但还在文件中的)
        //最重要的一点, MaxOffset指向的是空记录
        int MaxOffset;

        //记录每个索引项的长度(in Byte)
        public ArrayList sizeofRec = new ArrayList();

        //每条记录的长度(in Byte)
        int sizeofLine;

        //public class sizeofLine
        //{
        //    ArrayList sizeofRec = new ArrayList();
        //    int sizeoftheLine = 
        //}

        public Fileworks()
        {
            //重载了应该也可以互相调用啊.....
            //Fileworks("index.bin");
        }

        public Fileworks(string anyFileIndex)
        {
            //这个是为了可以由管理员增加和删除索引项而做准备的,也不知道可不可以写到那么完整
            //sizeofRec.Add(25);
            //sizeofRec.Add(25);
            //sizeofRec.Add(25);
            //sizeofRec.Add(25);
            
            
            readAllFromFile(anyFileIndex);
            //下面代码已经移去readAllFromFile()
            //foreach (Object size in sizeofRec)
            //{
            //    sizeofLine += (int)size + 1;//1 for blank// +sizeof(char);//char for blank
            //}
        }

        public ArrayList insertBuffer = new ArrayList();//储存插入的记录们
        public ArrayList removeBuffer = new ArrayList();//(储存删除的记录们)
        public ArrayList EmptyRecs = new ArrayList();
        public ArrayList Trees = new ArrayList();//储存trees
        public ArrayList filenames_Of_trees = new ArrayList();//储存trees的文件名

        public string nameofIndex;
        string nameofMainRecs;
        string nameofEmptyRecs;

        //不会重载ArrayList.Equals()
        //public override bool Equals(ArrayList arraylist)
        //{
        //    foreach (object obj in arraylist)
        //    {
        //        if (!obj.Equals(this.))
        //        {
        //            return false;
        //        }
        //    }
        //    return true;
        //}

        public bool findRange(ArrayList userCareList, ArrayList lowerBoundaryList, ArrayList higherBoundaryList, ArrayList trees, ArrayList resultslists)
        {
            int count = 0;
            foreach (bool care in userCareList)
            {
                
                if (care == true)
                {
                    if ( !lowerBoundaryList[count].ToString().Equals("") )
                    {
                        //(trees[0]);
                    }

                }
                                   
                count++;
            }
            
            return true;
        }

        public bool findMulti(ArrayList userCareList, ArrayList keyList, ArrayList trees, ArrayList finalResults)
        {
            int count = 0;
            //ArrayList finalResults = new ArrayList();
            ArrayList firstCareResult = new ArrayList();

            //找出第一个有用的值
            foreach(bool care in userCareList)
            {
                //第一个care的查询项
                if (care == true)
                {
                    //且不为空
                    if (!keyList[count].ToString().Equals(""))
                    {
                        if (trees[count] is Treeworks.BPTree<int, int, intintCompare>)
                        {
                            //没找到就返回
                            if( !findSingleKey(Int32.Parse(keyList[count].ToString()), (Treeworks.BPTree<int, int, intintCompare>)(trees[count]), firstCareResult))
                                return false;
                        }
                        else if (trees[count] is Treeworks.BPTree<string, int, strstrCompare>)
                        {
                            //没找到就返回
                            if( !findSingleKey(keyList[count].ToString(), (Treeworks.BPTree<string, int, strstrCompare>)(trees[count]), firstCareResult))
                                return false;
                        }
                        //找到就跳出
                        break;
                    }
                }
                count++;
            }

            //用户没有选择查找项
            if(count == userCareList.Count -1)
            {
                return false;
            }

            //将记录插入最终要返回的list
            foreach(int offset in firstCareResult)
            {
                ArrayList thisLine = new ArrayList ();
                readSingleLine(offset, thisLine);
                finalResults.Add(thisLine);
            }

            //移除不符合后面key值的项
            //int thiscount = 0;
            for (int i = count + 1; i < userCareList.Count; i++)
            {
                if ((bool)userCareList[i])
                {
                    //thiscount = 0;
                    foreach (ArrayList list in finalResults)
                    {
                        if (!list[count].Equals(keyList[count]))
                        {
                            //被注释掉的这个应该不行
                            //finalResults.RemoveAt(thiscount);
                            finalResults.Remove(list);
                        }
                        //thiscount++;
                    }
                    //如果finalResults都被移完了,没找到
                    if (finalResults.Count == 0)
                        return false;
                }
             }

             return true;
        }

        //重载三次真是傻,前期没有设计好接口就是这样
        public bool findSingleKey(Object thisKey, Treeworks.BPTree<int, int, intintCompare> tree, ArrayList results)
        {
            Object Elem = null;
            if (!tree.find((int)thisKey, ref Elem))//没找到
            {
                return false;
            }
            else //找到
            {
                if (Elem is Treeworks.Link<int>)//有下挂链表
                {
                    while (Elem != null)
                    {
                        object e = ((Treeworks.Link<int>)Elem).ptr;
                        results.Add(e);
                        Elem = ((Treeworks.Link<int>)Elem).lptr;
                    }
                }
                else//无下挂链表
                {
                    results.Add(Elem);
                }
                return true;
            }
        }

        public bool findSingleKey(Object thisKey, Treeworks.BPTree<string, int, strstrCompare> tree, ArrayList results)
        {
            Object Elem = null;
            if (!tree.find(thisKey.ToString(), ref Elem))//没找到
            {
                return false;
            }
            else //找到
            {
                if (Elem is Treeworks.Link<string>)//有下挂链表
                {
                    while (Elem != null)
                    {
                        object e = ((Treeworks.Link<string>)Elem).ptr;
                        results.Add(e);
                        Elem = ((Treeworks.Link<string>)Elem).lptr;
                    }
                }
                else//无下挂链表
                {
                    results.Add(Elem);
                }
                return true;
            }
        }

        public bool findSingleKey(Object thisKey, Object tree, ArrayList results)
        {
            Object Elem = null;
            
            if (tree is Treeworks.BPTree<int, int, intintCompare>)
            {
                if (!((Treeworks.BPTree<int, int, intintCompare>)tree).find(Int32.Parse(thisKey.ToString()), ref Elem))//没找到
                {
                    return false;
                }
                else //找到
                {
                    if (Elem is Treeworks.Link<int>)//有下挂链表
                    {
                        while (Elem != null)
                        {
                            object e = ((Treeworks.Link<int>)Elem).ptr;
                            results.Add(e);
                            Elem = ((Treeworks.Link<int>)Elem).lptr;
                        }
                    }
                    else//无下挂链表
                    {
                        results.Add(Elem);
                    }
                    return true;
                }
            }
            else if (tree is Treeworks.BPTree<string, int, strstrCompare>)
            {
                if (!((Treeworks.BPTree<string, int, strstrCompare>)tree).find(thisKey.ToString(), ref Elem))//没找到
                {
                    return false;
                }
                else //找到
                {
                    if (Elem is Treeworks.Link<string>)//有下挂链表
                    {
                        while (Elem != null)
                        {
                            object e = ((Treeworks.Link<string>)Elem).ptr;
                            results.Add(e);
                            Elem = ((Treeworks.Link<string>)Elem).lptr;
                        }
                    }
                    else//无下挂链表
                    {
                        results.Add(Elem);
                    }
                    return true;
                }
            }
            else
            {//nothing to do 
                return false;
            }
        }

        //读MainRecs.bin的指定行,将结果分离之后存入resultLine
        public bool readSingleLine(int thisOffset, ArrayList resultLine)
        {
            FileInfo ofd;
            FileStream reader;
            ofd = new FileInfo(nameofMainRecs);
            if (ofd.Exists && ((ofd.Attributes & FileAttributes.ReadOnly) == 0))
            {
                byte[] thisline = new byte[sizeofLine];
                reader = ofd.Open(FileMode.Open, FileAccess.Read, FileShare.Read);
                reader.Seek((long)thisOffset * sizeofLine, SeekOrigin.Begin);
                reader.Read(thisline, 0, thisline.Length);
                string tStr = Encoding.Default.GetString(thisline);
                string [] strArray;//= new string [];
                strArray = tStr.Split(new char []{' '}, StringSplitOptions.RemoveEmptyEntries);
                foreach (string str in strArray)