开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 其他数据库 > 查看源码
Buffer.cpp
资源名称：minisqlc.rar　[点击查看]
上传用户：lkd6667
上传日期：2015-05-13
资源大小：1448k
文件大小：21k
源码类别：

其他数据库

开发平台：

C/C++

Buffer.cpp：源码内容
  1. #include "Buffer.h"
  2. _M_Buffer  Buffer;
  3. unsigned int SizeOfPageHead = sizeof(_TB_PAGEHEAD);
  4. unsigned int BTreeNodeSize = (FILE_PAGESIZE - SizeOfPageHead)/4;
  6. //////////////////////////////////////////////////////////////////
  7. //初始化文件页的头信息
  8. void _TB_PAGEHEAD::Initial(unsigned long mypageid,bool myisfixed)
  9. {
  10. this->ulPageID = mypageid;
  11. this->bIsFixed = myisfixed;
  12. }
  14. //////////////////////////////////////////////////////////////////
  15. //初始化文件头信息
  16. void _TB_FILECOND::InitialFileCond()
  17. {
  18.     this->ulPageTotal = 1;
  19.     this->DelFirst.Initialize();
  20.     this->DelLast.Initialize();
  21.     this->NewInsert.ulFilePageID = 1;
  22.     this->NewInsert.uiOffset = SizeOfPageHead;
  23. }
  25. //////////////////////////////////////////////////////////////////
  26. //class _M_Page
  27. //取得文件头信息
  28. _TB_FILECOND* _M_Page::Ptr2FileCond()
  29. {
  30.     return (_TB_FILECOND* )((char*)this->Ptr2PageBegin + SizeOfPageHead);
  31. }
  33. //构造函数
  34. _M_Page::_M_Page()
  35. {
  36. this->Ptr2PageBegin = malloc(FILE_PAGESIZE);
  37.     if(!this->Ptr2PageBegin)  throw 1000;   // 内存开辟失败
  38. this->Ptr2Head = (_TB_PAGEHEAD*)this->Ptr2PageBegin;
  39. this->ulFilePageID = 0;
  40. this->uiFileID = 0;
  41. }
  43. //析构函数
  44. _M_Page::~_M_Page()
  45. {
  46.     this->ulFilePageID = 0;
  47. this->uiFileID = 0;
  48. free(this->Ptr2PageBegin);
  49.     this->Ptr2Head = 0;
  50.     this->Ptr2PageBegin = 0;
  51. }
  53. //把内存中的页写回到文件中
  54. void _M_Page::Back2File() const
  55. {
  56.     int temp = 0;
  57. temp = lseek(Buffer.GetPtr2File(this->uiFileID),this->ulFilePageID*FILE_PAGESIZE,0);
  58.     if(temp==-1L) throw 1005; 
  59. temp = write(Buffer.GetPtr2File(this->uiFileID),this->Ptr2PageBegin,FILE_PAGESIZE); // 写回文件
  60.     if(temp!= FILE_PAGESIZE) throw 1002;  // 写失败
  61. }
  63. //从文件中调入页至开辟好的内存空间中
  64. void _M_Page::LoadFromFile(unsigned int fileid, unsigned long filepageid)
  65. {
  66.     this->uiFileID = fileid;
  67.     this->ulFilePageID = filepageid;
  69.     if( Buffer.GetIsNew(fileid) )   //  文件新建，只有一个页
  70.     {
  71.         this->Ptr2Head->Initial(filepageid,1);   // 初始化页头信息
  72.         this->Ptr2FileCond()->InitialFileCond(); // 初始化文件头信息
  73.         Buffer.SetIsNew(fileid,0);               // 设置使文件不再为新建状态(以免下次访问这个内存页又要进行头信息初始化)
  74.     }
  75. //文件页是新建的，不是新建文件
  76.     else if( filepageid >= Buffer.GetPageTotal(fileid) ) // 比现有文件总页面要多,那么开辟新的页面加到文件末尾
  77.     {
  78.         if( filepageid - Buffer.GetPageTotal(fileid) > 0) 
  79. {
  80. //cout<<"";
  81. throw 1004; // 页编号比现有文件最后一个页编号+1 还要大(浪费磁盘空间)
  82. }
  83.         this->Ptr2Head->Initial(filepageid,0);   // 初始化页头信息
  84.         Buffer.AddPageTotal(fileid,1);           // 使文件总页数加1
  85.     }
  86. // 其他情况从磁盘中读信息
  87.     else     
  88.     {
  89. // 定位到将要取出的文件页的首地址
  90.     lseek(Buffer.GetPtr2File(fileid),filepageid*FILE_PAGESIZE,0); 
  91. // 读到内存中
  92.     int temp = read(Buffer.GetPtr2File(fileid),this->Ptr2PageBegin,FILE_PAGESIZE); 
  93.         if( temp!= FILE_PAGESIZE)  
  94. {
  95. //cout<<"
  96. throw 1031; // 读失败
  97. //return;
  98. }
  99.     }
  100. }
  102. //////////////////////////////////////////////////////////////////
  103. //class _M_Clock
  104. //construct　＿M＿Clock 成员初始化
  105. _M_Clock::_M_Clock()
  106. {
  107. uiClockSize=MEM_PAGEAMOUNT;
  108. uiCurrClockPtr=1;
  109. for(int i=0;i<=MEM_PAGEAMOUNT;i++)
  110. {
  111. Ptr2MemPageInfo[i]= new  _M_PageInfo;
  112. }
  113. }
  115. //destruct  _M_Clock  析构
  116. _M_Clock::~_M_Clock()
  117. {
  118. for(unsigned int i=0;i<=this->uiClockSize;i++)
  119. delete  Ptr2MemPageInfo[i];
  120. }
  122. //查找Clock中尚未分配内存空间的页
  123. unsigned int _M_Clock::GetNullPage()
  124. {
  125.     for(unsigned int i=this->uiCurrClockPtr;i<=this->uiClockSize;i++)
  126.     {
  127.         if( !this->Ptr2MemPageInfo[i]->Ptr2Page ) // 尚未分配内存页
  128.         {
  129.             this->uiCurrClockPtr = i;
  130.             return this->uiCurrClockPtr;
  131.         }
  132.     }
  133.     return 0;
  134. }
  136. //查找Clock中已经被抛弃的页
  137. unsigned int _M_Clock::GetFreePage()
  138. {
  139.     for(unsigned int i=1;i<=this->uiClockSize;i++)
  140.     {
  141.         // 被抛弃内存页已经把文件编号置为 0 做为标记
  142.         if( this->Ptr2MemPageInfo[i]->Ptr2Page && !this->Ptr2MemPageInfo[i]->GetFileID() )
  143.         {
  144.             this->uiCurrClockPtr = i;
  145.             return this->uiCurrClockPtr;
  146.         }
  147.     }
  148.     return 0;
  149. }
  152. // 查找Clock中最近一页可被替换的页
  153. unsigned int _M_Clock::GetSwapPage(unsigned int fileid)
  154. {
  155.     if(! this->GetFreePage() )   // 查找被抛弃的内存页
  156.         // 查找Clock中最早打开的文件所占用的内存页,如果是常驻内存页则关闭该文件(该写回的写回)
  157.     if(! this->NR_Search(fileid) )
  158.     if(! this->U_M_Search(0,0,0) ) // 上次没有用,没有被修改,不变动bIsLastUsed,返回符合这样条件的内存页
  159.     if(! this->U_M_Search(0,1,1) ) // 上次没有用,有被修改,变动bIsLastUsed,返回符合这样条件的内存页
  160.     if(! this->U_M_Search(0,0,0) ) // 上次没有用,没有被修改,不变动bIsLastUsed,返回符合这样条件的内存页
  161.      this->U_M_Search(0,1,1);  // 上次没有用,有被修改,变动bIsLastUsed,返回符合这样条件的内存页
  162. return this->uiCurrClockPtr;
  163. }
  165. // 查找Clock中最早打开的文件所占用的内存页,如果是常驻内存页则关闭该文件(该写回的写回)
  166. // 所有打开的文件已经由_M_Buffer类组织成链表
  167. unsigned int _M_Clock::NR_Search(unsigned int tarfileid)
  168. {
  169.     unsigned int NR_FileIDTemp = 0;     // 临时文件编号
  170.     unsigned int NR_FileID = 20000;     // 欲替换的内存页所属文件编号(程序运行期分配),20000为不可能的一个数字(打开20000个文件方有可能)
  171.     unsigned int ClockPtr = 0;          // 与替换的页编号
  172.     unsigned int relativefileid = Buffer[tarfileid]->GetRelativeFileID(); // 取得关联文件编号
  173. for(unsigned int i=1;i<=this->uiClockSize;i++)
  174. {
  175.         NR_FileIDTemp = this->Ptr2MemPageInfo[i]->GetFileID();
  176.         // 文件编号不能为当前文件编号及其关联文件的编号,在符合这个条件的基础上,文件编号越小,越早打开,所以更适合被替换
  177. if( NR_FileIDTemp < NR_FileID && NR_FileIDTemp != tarfileid && NR_FileIDTemp != relativefileid )
  178.         {
  179.             NR_FileID = NR_FileIDTemp;
  180.             ClockPtr = i;
  181.         }
  182. }
  183.     if( NR_FileID != 20000 )
  184.     {
  185.         // 如果被替换页是第 0 页,则关闭该文件及其关联文件
  186.         if( this->Ptr2MemPageInfo[ClockPtr]->GetFilePageID() == 0 )
  187.             Buffer[NR_FileID]->Close();
  188.         this->uiCurrClockPtr = ClockPtr;
  189.         return this->uiCurrClockPtr;
  190.     }
  191.     else
  192.     return 0;
  193. }
  195. // Clock算法实现,通过U_M_Search()四次调用,完成Clock算法
  196. unsigned int _M_Clock::U_M_Search(bool islastused,bool ismodified,bool changeused)
  197. {
  198. for(unsigned int i=1;i<=this->uiClockSize;i++)
  199. {
  200. if( this->Ptr2MemPageInfo[this->uiCurrClockPtr]->GetPtr2Head()->bIsFixed == 0 &&
  201. this->Ptr2MemPageInfo[this->uiCurrClockPtr]->bIsLastUsed == islastused &&
  202. this->Ptr2MemPageInfo[this->uiCurrClockPtr]->bIsModified == ismodified )
  203. return this->uiCurrClockPtr;
  204. else
  205. {
  206. if( changeused ) this->Ptr2MemPageInfo[this->uiCurrClockPtr]->bIsLastUsed = 0;
  207. this->uiCurrClockPtr = (this->uiCurrClockPtr+1)%this->uiClockSize;
  208. if(!this->uiCurrClockPtr)
  209. this->uiCurrClockPtr = this->uiClockSize;
  210. }
  211. }
  212. return 0;
  213. }
  214. // 查找已经存在的页(假设要找的页已经存在的话)
  215. unsigned int _M_Clock::GetExsitPage(unsigned int fileid,unsigned long filepageid)
  216. {
  217. if( this->Ptr2MemPageInfo[this->uiCurrClockPtr]->Ptr2Page &&
  218. this->Ptr2MemPageInfo[this->uiCurrClockPtr]->GetFileID() == fileid &&
  219. this->Ptr2MemPageInfo[this->uiCurrClockPtr]->GetFilePageID() == filepageid )
  220. return this->uiCurrClockPtr;
  222. for(unsigned int i=1;i<=this->uiClockSize;i++)
  223. {
  224.         if(!this->Ptr2MemPageInfo[i]->Ptr2Page) break;
  225. if( this->Ptr2MemPageInfo[i]->GetFileID() == fileid &&
  226. this->Ptr2MemPageInfo[i]->GetFilePageID() == filepageid )
  227. {
  228. this->uiCurrClockPtr = i;
  229. return this->uiCurrClockPtr;
  230. }
  231. }
  233. return 0;
  234. }
  236. // 根据文件编号和页号取得内存页(通过上面各种方法)
  237. _M_PageInfo* _M_Clock::GetTargetPage(unsigned int fileid,unsigned long filepageid)
  238. {
  239.     unsigned int tempint = this->GetExsitPage(fileid,filepageid);  // 先找内存页是否已经存在
  240. if(tempint) return this->Ptr2MemPageInfo[tempint];
  242. tempint = this->GetNullPage();         // 看看有没有空的内存页尚未开辟使用
  243.     if(!tempint) tempint = this->GetSwapPage(fileid); // 得到替换页
  244. this->Ptr2MemPageInfo[tempint]->UpdatePageInfo(fileid,filepageid); // 调入文件页至内存,并更新相关信息
  246.     return this->Ptr2MemPageInfo[tempint];
  247. }
  249. //关闭内存中的文件页　文件id==fileid
  250. void _M_Clock::CloseFilePages(unsigned int fileid)
  251. {
  252. for(unsigned int i=1;i<this->uiClockSize;i++)
  253. {
  254. if( !this->Ptr2MemPageInfo[i]->Ptr2Page ) break;
  255. if(Ptr2MemPageInfo[i]->GetFileID()==fileid)
  256. {
  257. //如果是dirty data写回磁盘 并将　ifmodified 改回0；
  258. if(Ptr2MemPageInfo[i]->bIsModified)
  259. {
  260. Ptr2MemPageInfo[i]->Ptr2Page->Back2File();
  261. Ptr2MemPageInfo[i]->bIsModified=0;
  262. }
  263. //放弃内存页的使用
  264. this->Ptr2MemPageInfo[i]->SetFileID(0);
  265. }
  266. }
  267. }
  268. // 设置当前页使之为脏页
  269. void _M_Clock::SetPageModified()
  270. {
  271.     this->Ptr2MemPageInfo[this->uiCurrClockPtr]->bIsModified = 1;
  272. }
  274. ///////////////////////////////////////////////////////////////////////////////////////
  275. //class _M_PageInfo
  276. //构造函数,初始化成员
  277. _M_PageInfo::_M_PageInfo()
  278. {
  279. this->bIsLastUsed = 0;
  280. this->bIsModified = 0;
  281. this->Ptr2Page = 0;
  282. }
  284. // 析构，根据bIsModified决定是否需要写会文件
  285. _M_PageInfo::~_M_PageInfo()
  286. {
  287.     if(this->Ptr2Page){
  288.         if(this->Ptr2Page->uiFileID && this->Ptr2Page->ulFilePageID==0)
  289.             // 把文件页总数写到磁盘中,已备下次读取
  290.             this->Ptr2Page->Ptr2FileCond()->ulPageTotal = Buffer.GetPageTotal(this->Ptr2Page->uiFileID);
  291.         if(this->Ptr2Page->uiFileID && this->bIsModified){ // 若为脏页,写回
  292.             this->Ptr2Page->Back2File();
  293.         }
  294.         delete this->Ptr2Page;
  295.         this->Ptr2Page = 0;
  296.     }
  297.     this->bIsLastUsed = 0;
  298.     this->bIsModified = 0;
  299. }
  301. // 页替换、开辟等
  302. void _M_PageInfo::UpdatePageInfo(unsigned int fileid,unsigned long filepageid)
  303. {
  304. if( this->bIsModified) // 若为脏页,写回
  305. this->Ptr2Page->Back2File();
  307. this->bIsLastUsed = 1;
  308. this->bIsModified = 0;
  309.     if( !this->Ptr2Page ){ // 尚未开辟内存空间
  310. this->Ptr2Page = new _M_Page; // 新的内存页对象
  311.     }
  312.     
  313.     // 若文件新建 或者 该页为文件第0页 后者 该页在原来文件中不存在 则要求写回
  314.     if( Buffer.GetIsNew(fileid) || filepageid >= Buffer.GetPageTotal(fileid) || filepageid==0 )
  315.         this->bIsModified = 1;
  316.     
  317. this->Ptr2Page->LoadFromFile(fileid,filepageid);  // 读到内存中
  318. }
  320. // 取得文件头信息地址
  321. _TB_FILECOND* _M_PageInfo::GetPtr2FileCond() const
  322. {
  323.     return this->Ptr2Page->Ptr2FileCond();
  324. }
  326. // 取得页头信息地址
  327. _TB_PAGEHEAD* _M_PageInfo::GetPtr2Head() const
  328. {
  329.     return this->Ptr2Page->Ptr2Head;
  330. }
  332. // 取得所分配的内存页目前内容所属的文件编号
  333. unsigned int _M_PageInfo::GetFileID() const
  334. {
  335.     return this->Ptr2Page->uiFileID;
  336. }
  338. // 设置新的文件编号(抛弃页时设为0即可)
  339. void _M_PageInfo::SetFileID(unsigned int fileid)
  340. {
  341.   this->Ptr2Page->uiFileID = fileid;
  342. }
  344. // 取得所分配的内存页目前内容在文件中的页编号
  345. unsigned long _M_PageInfo::GetFilePageID() const
  346. {
  347.     return this->Ptr2Page->ulFilePageID;
  348. }
  349. ///////////////////////////////////////////////////////////////////////////////////////
  350. //class _M_File
  351. // 初始化,打开和新建文件,若当前文件开的太多,导致无法再打开新文件,可自动关闭最早打开的文件
  352. _M_File::_M_File(const char *name,unsigned int fileid)
  353. {
  354. this->uiFileID = fileid;
  355.         this->IsNew = 0;
  356.         this->ulPageTotal = 1;
  357. strcpy(this->FileName,name);
  358. this->Ptr2File = open(name,_O_BINARY|O_RDWR,0664); 
  359.         if(this->Ptr2File==-1){ // 文件不存在
  360.             this->Ptr2File = open(name,_O_BINARY|O_RDWR|O_CREAT,0664); // 新建文件(打开文件)
  361.             if(this->Ptr2File==-1)  // 文件不能被打开(新建)
  362.             {
  363.                 if( Buffer._F_First) 
  364.                     Buffer._F_First->Close(); // 关闭最早打开的文件
  365.                 this->Ptr2File = open(name,_O_BINARY|O_RDWR|O_CREAT,0664); // 新建文件(打开文件)
  366.     if(this->Ptr2File==-1)  // 文件不能被新建(打开)
  367.                     throw 1006; // 文件还是不能被打开(新建),可能为磁盘空间不足等意外
  368.             }
  369.             this->IsNew = 1;
  370.         }
  371. this->_F_Next = 0;
  372. }
  374. //取相关文件
  375. unsigned int _M_File::GetRelativeFileID() const
  376. {
  377. int FNLength =strlen(this->FileName);//记录文件名长度，以便修改文件扩展名
  378. char FNTemp1[MAX_FILENAME_LEN];//存文件名
  379. char FNTemp2[MAX_FILENAME_LEN];
  380. strcpy(FNTemp1,this->FileName);
  381. FNTemp1[FNLength-3]='';//除去扩展名
  382. _M_File * pMFTemp;
  383. pMFTemp=Buffer._F_First;
  384. while(pMFTemp)//对所有打开文件进行搜索
  385. {
  386. strcpy(FNTemp2,pMFTemp->FileName);
  387. FNTemp2[FNLength-3]='';//除去扩展名
  388. if((strcmp(FNTemp1,FNTemp2)==0)&&(pMFTemp->uiFileID!=this->uiFileID))
  389. return pMFTemp->uiFileID;
  390. pMFTemp=pMFTemp->_F_Next;
  391. }
  392. //error
  393. //throw:没有找到相关文件
  394. return 0;
  395. }
  396. // 析构,关闭文件
  397. void _M_File::Deconstruct()
  398. {
  399.     if(this->Ptr2File)
  400.         close(this->Ptr2File);
  401. }
  402. // 关闭文件,同时属于该文件的内存页改写回的写回.为保证一致性,同时关闭关联文件
  403. void _M_File::Close()
  404. {
  405. Buffer.CloseTable(this->uiFileID);
  406. }
  408. // 根据页号取得属于该文件的内存页
  409. _M_PageInfo* _M_File::GetPageInfo(unsigned long filepageid) const
  410. {
  411.     return Buffer.MemPageClock->GetTargetPage(this->uiFileID,filepageid);
  412. }
  413. // 取得目前总的页数
  414. unsigned long _M_File::GetPageTotal() const
  415. {
  416.       return this->ulPageTotal;
  417. }
  419. // 取得文件内记录删除维护信息
  420. _F_FileAddr _M_File::GetDelListCond() const
  421. {
  422.     _F_FileAddr temp;
  423.     temp.ulFilePageID = 0;
  424.     temp.uiOffset = SizeOfPageHead;
  425.     return temp;
  426. }
  428. // 取得Catalog模块在文件中可写的第一个位置
  429. _F_FileAddr _M_File::GetCataPoint() const
  430. {
  431.     _F_FileAddr temp;
  432.     temp.ulFilePageID = 0;
  433.     temp.uiOffset = SizeOfPageHead + sizeof(_TB_FILECOND);
  434.     return temp;
  435. }
  437. // 取得Catalog模块在文件中可写的第一个位置
  438. _F_FileAddr _M_File::GetIdxPoint() const
  439. {
  440.     _F_FileAddr temp;
  441.     temp.ulFilePageID = 0;
  442.     temp.uiOffset = SizeOfPageHead + sizeof(_TB_FILECOND);
  443.     return temp;
  444. }
  446. ///////////////////////////////////////////////////////////////////////////////////////
  447. //_F_FileAddr
  448. //初始化
  449. void _F_FileAddr::Initialize()
  450. {
  451.     this->ulFilePageID = 0;
  452.     this->uiOffset = 0;
  453. }
  455. //根据页编号和偏移量，取出当前文件该地址在内存中的地址,同时测试页偏移量是否溢出
  456. //根据页编号和偏移量，取出当前文件该地址在内存中的地址,同时测试页偏移量是否溢出
  457. void* _F_FileAddr::MemAddr() const
  458. {
  459.  if( this->ulFilePageID==0 && this->uiOffset==0 )return NULL;
  460. return (void*)((char*)Buffer._F_Current->GetPageInfo(this->ulFilePageID)->Ptr2Page->Ptr2PageBegin + this->uiOffset);
  461. }
  463. //根据页编号和偏移量，取出当前文件该地址在内存中的地址,同时测试页偏移量是否溢出
  464. void* _F_FileAddr::MemAddr(_M_File *TargetMFile) const
  465. {
  466. if( this->ulFilePageID==0 && this->uiOffset==0 )return NULL;
  467. return (void*)((char*)TargetMFile->GetPageInfo(this->ulFilePageID)->Ptr2Page->Ptr2PageBegin + this->uiOffset);
  468. }
  470. //根据页编号和偏移量，取出当前文件该地址在内存中的地址,同时测试页偏移量是否溢出
  471. void* _F_FileAddr::MemAddr(_M_File &TargetMFile) const
  472. {
  473. if( this->ulFilePageID==0 && this->uiOffset==0 )return NULL;
  474. return (void*)((char*)TargetMFile.GetPageInfo(this->ulFilePageID)->Ptr2Page->Ptr2PageBegin + this->uiOffset);
  475. }
  477. // _F_FileAddr >= 操作
  478. bool _F_FileAddr::operator>=(_F_FileAddr& other) const
  479. {
  480. if( (this->ulFilePageID > other.ulFilePageID) || (this->uiOffset >= other.uiOffset && this->ulFilePageID >= other.ulFilePageID))
  481. return true;
  482. return false;
  483. }
  485. // _F_FileAddr > 操作
  486. bool _F_FileAddr::operator>(_F_FileAddr& other) const
  487. {
  488. if( (this->ulFilePageID > other.ulFilePageID) || (this->uiOffset > other.uiOffset && this->ulFilePageID >= other.ulFilePageID))
  489. return true;
  490. return false;
  491. }
  493. // _F_FileAddr == 操作
  494. bool _F_FileAddr::operator==(_F_FileAddr& other) const
  495. {
  496. if((this->ulFilePageID == other.ulFilePageID) && (this->uiOffset == other.uiOffset))
  497. return true;
  498. return false;
  499. }
  501. // _F_FileAddr != 操作
  502. bool _F_FileAddr::operator!=(_F_FileAddr& other) const
  503. {
  504. if((this->ulFilePageID != other.ulFilePageID) || (this->uiOffset != other.uiOffset))
  505. return true;
  506. return false;
  507. }
  509. // _F_FileAddr == const int 操作只对0操作
  510. bool _F_FileAddr::operator==(const int zero) const
  511. {
  512. if( (this->ulFilePageID==0) &&( this->uiOffset==0) )
  513. return true;
  514. return false;
  515. }
  517. //在当前页中滑动offset量(可正可负)
  518. void _F_FileAddr::ShiftOffset(int offset)
  519. {
  520. int temp=(int)this->uiOffset+offset;
  521. //if temp <0 出错
  522. this->uiOffset =(unsigned int) temp;
  523. }
  526. /////////////////////////////////////////////////////////////////////////////////////////
  527. //class _M_Buffer
  528. // Buffer初始化
  529. void _M_Buffer::Start()
  530. {
  531.     if( MEM_PAGEAMOUNT < 3) throw 1033; // 至少要求有 3 页,2页头信息(目录管理和索引管理各一页),另外 1 页记录存取
  532. this->_F_First = 0;
  533. this->_F_Last = 0;
  534.     this->_F_Current = 0;
  535. this->uiFileCount = 0;
  536.     this->MemPageClock = new _M_Clock();
  537. }
  539. // Buffer结束,写回内存页,关闭文件
  540. void _M_Buffer::End()
  541. {
  542.     delete this->MemPageClock;
  543.     this->_F_Last = 0;
  544.     this->uiFileCount = 0;
  545. _M_File* temp = this->_F_First;
  546.     this->_F_First = 0;
  547.     _M_File* temp2 = 0;
  548. while(temp)
  549. {
  550. temp2 = temp->_F_Next;
  551.         temp->Deconstruct();
  552. temp = temp2;
  553. }
  554. }
  556. // 根据文件编号返回内存文件对象是否为新建
  557. bool _M_Buffer::GetIsNew(unsigned int fileid) const
  558. {
  559.     return (*this)[fileid]->IsNew;
  560. }
  561. // 根据文件编号设置内存文件对象是否为新建
  562. void _M_Buffer::SetIsNew(unsigned int fileid,bool isnew)
  563. {
  564.     (*this)[fileid]->IsNew = isnew;
  565. }
  566. unsigned long _M_Buffer::GetPageTotal(unsigned int fileid) const
  567. {
  568.     return (*this)[fileid]->ulPageTotal;
  569. }
  570. void _M_Buffer::AddPageTotal(unsigned int fileid,int add)
  571. {
  572.     (*this)[fileid]->ulPageTotal += add;
  573. }
  574. int _M_Buffer::GetPtr2File(unsigned int fileid) const
  575. {
  576.     return (*this)[fileid]->Ptr2File;
  577. }
  578. // 根据文件编号返回内存文件对象
  579. _M_File* _M_Buffer::operator [](unsigned int fileid) const
  580. {
  581. //Error Dispatch 0< fileid <= Buffer->uiFileCount
  582.     _M_File* temp = 0;
  583.     _M_File* temp2 = this->_F_First;
  584.     while( temp2 )
  585.     {
  586.         if( temp2->uiFileID == fileid ){
  587.             temp = temp2;
  588.             break;
  589.         }
  590.         temp2 = temp2->_F_Next;
  591.     }
  592. return temp;
  593. }
  595. //找到文件名为filename的＿M＿File
  596. _M_File _M_Buffer::operator [](const char* filename)
  597. {
  598. //先找当前文件，概率比较大
  599. if( this->_F_Current && strcmp(filename,this->_F_Current->FileName)==0)
  600.         return *(this->_F_Current);
  601. _M_File * pMFTemp;
  602. pMFTemp = this->_F_First;
  603. while(pMFTemp)                    //对所有打开文件进行遍历
  604. {
  605. if(strcmp(filename,pMFTemp->FileName)==0)
  606. {
  607. this->_F_Current=pMFTemp;
  608. return *pMFTemp;            //找到返回文件信息并将当前Buffer的指针针向当前文件
  609. }
  610. pMFTemp=pMFTemp->_F_Next;
  611. }
  612. //在打开文件中没有要找的文件开始如下操作
  613. pMFTemp = new _M_File(filename,++this->uiFileCount);
  614. if(!this->_F_First)//没有文件打开
  615. this->_F_First=this->_F_Last=pMFTemp;
  616. else
  617. {
  618. this->_F_Last->_F_Next=pMFTemp;
  619. this->_F_Last=pMFTemp;
  620. }
  621. this->_F_Current=pMFTemp;
  622. if(pMFTemp->IsNew)
  623. this->MemPageClock->GetTargetPage(pMFTemp->uiFileID,0);
  624. else //将文件的总页数读到＿M＿File 中
  625. pMFTemp->ulPageTotal=this->MemPageClock->GetTargetPage(pMFTemp->uiFileID,0)->GetPtr2FileCond()->ulPageTotal;
  626. return *pMFTemp;
  627. }
  629. // 根据文件编号关闭内存文件对象
  630. void _M_Buffer::CloseFile(unsigned int fileid)
  631. {
  632. this->MemPageClock->CloseFilePages(fileid);
  633. _M_File* temp = this->_F_First;
  634. _M_File* temp2 = 0;
  635. while(temp->uiFileID != fileid)
  636. {
  637. temp2 = temp;
  638. temp = temp->_F_Next;
  639. }
  640. if( temp == this->_F_First )
  641. this->_F_First = this->_F_First->_F_Next;
  642. else
  643. temp2->_F_Next = temp->_F_Next;
  644. temp->Deconstruct();
  645. }
  646. void _M_Buffer::CloseTable(unsigned int fileid)
  647. {
  648.     unsigned int tempfileid = (*this)[fileid]->GetRelativeFileID();
  649.     if( tempfileid )
  650.         this->CloseFile(tempfileid);
  651.     this->CloseFile(fileid);
  652. }
  654. //根据欲写入的文件地址，把其他模块内存中的数据写入buffer中，最终自动写入文件中
  655. _F_FileAddr MemWrite(const void* source,size_t length,_F_FileAddr* dest)
  656. {
  657.     if( (int)(FILE_PAGESIZE - dest->uiOffset) - (int)length < 0) // 判断是否溢出
  658.     {
  659.         dest->ulFilePageID = Buffer._F_Current->GetPageTotal(); // 若溢出修正 dest
  660. //Buffer.MemPageClock->GetTargetPage(Buffer._F_Current->uiFileID,dest->ulFilePageID);
  661.         dest->uiOffset = sizeof(_TB_PAGEHEAD);
  662.     }
  663.     memcpy(dest->MemAddr(),source,length);
  664.     Buffer.MemPageClock->SetPageModified();
  666.     _F_FileAddr end = *dest;
  667.     end.ShiftOffset((int)length);
  668.     return end;
  669. }
  671. //根据欲写入的文件地址，测试把其他模块内存中的数据写入实际未写入。
  672. _F_FileAddr MemWriteTest(size_t length,_F_FileAddr* dest)
  673. {
  674. if((int)(FILE_PAGESIZE - dest->uiOffset) - (int)length < 0) // 判断是否溢出
  675.    {
  676. dest->ulFilePageID = Buffer._F_Current->GetPageTotal(); // 若溢出修正 dest
  677. dest->uiOffset = SizeOfPageHead;
  678. }
  680. _F_FileAddr end = *dest;
  681. end.ShiftOffset((int)length);
  682. return end;
  683. }