bfile.cpp

在n维空间（每维范围为0-1）内对插入的数值根据坐标进行分区。从一个没有分区的空间开始插入

#include "BFile.h"

extern int qtree_level;
extern Cache cache_memory;
extern filename[];
extern BlockFile myblockfile;

BlockFile::BlockFile(char* name,int b_length) {
   char *buffer;
   int l;
   
   //printf("BlockFile Version 1.0\n");
   filename = new char[strlen(name) + 1];
   strcpy(filename,name);
   blocklength = b_length;
   number = 0;         //number is the # of blocks stored in a file, excluding the head


   file_cont = new string[FBLOCKNO];
   file_cont_no = new int[FBLOCKNO];
	for (int i = 0; i < FBLOCKNO; i++) {
    	file_cont[i] = "";
		file_cont_no[i] = 0;
	}

   if ((fp=fopen(name,"rb+"))!=0) { //file with this name exists, not a new one
      new_flag = false;
      blocklength = fread_number();
      number = fread_number();
   } else {  // not exists, is a new one
      if (blocklength < BFHEAD_LENGTH)
    	 printf("Blocklength too short\n");
      fp=fopen(filename,"wb+");
      if (fp == NULL)
		 printf("Failed to create the file\n");
      new_flag = true;
      fwrite_number(blocklength);
      fwrite_number(0);       //write total number of blocks
	  buffer = new char[(l=blocklength-(int)ftell(fp))];
      memset(buffer, '#', l);
      put_bytes(buffer,l);    //fill in the rest of block with #   (FIRST　BLOCK)
      delete [] buffer;
   }
   fseek(fp,0,SEEK_SET);  // set fp to the beginning of the file
   act_block=0;	// indicates that fp pointing at the 0th blk of this file		
}

BlockFile::~BlockFile() {
   delete[] filename;
   delete[] file_cont;
   delete[] file_cont_no;

   fclose(fp);
   remove("dtfile.txt");
}


void BlockFile::fwrite_number(int value) {
   put_bytes((char *) &value, sizeof(int));
}

int BlockFile::fread_number() {
   char ca[sizeof(int)];
   get_bytes(ca,sizeof(int));
   return *((int *)ca);
}


void BlockFile::fread_header(char* buffer) {
  //note that this func does not read the header of blockfile.  it
  //fetches the info in the first block excluding the header of blockfile
   fseek(fp,BFHEAD_LENGTH,SEEK_SET);
   get_bytes(buffer,blocklength-BFHEAD_LENGTH);
   if(number<1) {
       fseek(fp,0,SEEK_SET);
       act_block=0;  // only 1 blk in this file, so fp points to it
   } else
       act_block=1; // more than 1 blk, fp points to the second (since the first has been read)
}

void BlockFile::fset_header(char* header) {
   fseek(fp,BFHEAD_LENGTH,SEEK_SET);
   put_bytes(header,blocklength-BFHEAD_LENGTH);
   if(number<1) {
       fseek(fp,0,SEEK_SET);
       act_block=0;
   } else
       act_block=1;
}

bool BlockFile::fread_block(Entry** dataArray,int pos) {

	char b[sizeof(float)];
	float load;
   pos++;     //external block to internal block
   if (pos<=number && pos>0)
       seek_block(pos);
   else {
	   printf("Requested block %d is illegal.", pos - 1);  
	   error("\n", true);
   } 

   for (int i=0;i<myblockfile.file_cont_no[pos-1] ;i++)
       {
         for (int j=0; j<DIMENSION; j++)
         {
		  get_bytes(b, sizeof(float));
		  memcpy(&load, b, sizeof(float));
          memcpy(&(dataArray[i]->data[j]) ,&load, sizeof(float));         
          
         }
       }     

   if (pos+1>number) {
       fseek(fp,0,SEEK_SET);
       act_block=0;  //if the file pointer reaches the end, rewind to the beginning
   } else 
	{
       act_block=0;
	   fseek(fp,0,SEEK_SET);
	}
   return true;

}
/*
bool BlockFile::fwrite_block(Block block, int pos) {
  //note that this function can only write to an already allocated block.  to 
  //allocate a new block, use append_block instead. (append then use this to write)
   pos++;      //external # to interal #

   if (pos<=number && pos>0)
       seek_block(pos);
   else {
	   printf("Requested block %d is illegal.", pos - 1);  
	   error("\n", true);
   }
   put_bytes(block,blocklength);
   if (pos+1>number) {
       fseek(fp,0,SEEK_SET);
       act_block=0;
   } else
       act_block=pos+1;
   return true;
}
*/

bool BlockFile::fmove_one_data(char* data, int pos){ //used to move data from cache to file
													 //similar to fwrite_one_data, which is used for direct insertion

   pos++;	
   if (pos<=number && pos>0)
       seek_block(pos);
   else {
	   printf("Requested block %d is illegal.", pos - 1);  
//	   error("\n", true);
   } 

   fseek(fp, file_cont_no[pos-1]*sizeof(float)*DIMENSION, SEEK_CUR);
   file_cont_no[pos-1]++;

   put_bytes(data, sizeof(float)*DIMENSION);    // move one data in cache
   
   fseek(fp,0,SEEK_SET);
   act_block=0; //after inserted one data, fp goes back to beginning
   return true;
}



bool BlockFile::fwrite_one_data(Entry* data, int pos){
     
   pos++;	// fseek(fp,0,SEEK_END);
   if (pos<=number && pos>0)
       seek_block(pos);
   else {
	   printf("Requested block %d is illegal.", pos - 1);  
//	   error("\n", true);
   }    
// treat overflow later
//   char testbyte;


   fseek(fp, file_cont_no[pos-1]*sizeof(float)*DIMENSION, SEEK_CUR);
   file_cont_no[pos-1]++;

/*   fread(&testbyte,1,1,fp);
   while (testbyte!='^')  {
         fseek(fp,sizeof(float),SEEK_CUR);
		 fread(&testbyte,1,1,fp);
   }
  */
///   fseek(fp,-blocklength,SEEK_END); 
   for (int j=0; j<DIMENSION; j++) 
         put_bytes((char*)&(data->data[j]), sizeof(float));    // write one data in cache
   
   fseek(fp,0,SEEK_SET);
   act_block=0; //after inserted one data, fp goes back to beginning
    return true;
}


int BlockFile::fappend_block() {
   char *buffer;
   
   fseek(fp,0,SEEK_END);
   buffer = new char[blocklength];
   memset(buffer, '^', blocklength);
   put_bytes(buffer,blocklength);    //fill in the rest of block with #   (FIRST　BLOCK)

   /*
   act_block=number+1;
   seek_block(0);
   memset(buffer, '*', blocklength);
   put_bytes(buffer,blocklength);  
   */
   number++;

   if (number>FBLOCKNO) printf("File block number exceeds limit!\n");

   fseek(fp,sizeof(int),SEEK_SET);
   fwrite_number(number);
   fseek(fp,-blocklength,SEEK_END);
   return (act_block=number)-1;
   delete [] buffer;
}



bool BlockFile::fdelete_last_blocks(int num) {
   if (num>number)
      return false;
   number -= num;
   fseek(fp,sizeof(int),SEEK_SET);
   fwrite_number(number);
   fseek(fp,0,SEEK_SET);
   act_block=0;
     //note that blocks are deleted logically (only modifying the total # of
     //blocks).
   return true;
}


int BlockFile::retrieve_index(string node_id){
	int index=-1;
	for(int i=0; i<FBLOCKNO; i++)
		if (file_cont[i]==node_id)	{
			index=i;
			break;
		}
	return index;
}