dbbufferc.nc

nesC写的heed算法

    default:
      break;
    }
    return SUCCESS;
  }
  
  event result_t HeaderFileRead.remaining(filesize_t n, fileresult_t result) {
    return SUCCESS;
  }


  event result_t HeaderFileRead.opened(fileresult_t result) {
    
    switch (mState) {
    case kHEADER_READ:
    case kWRITE_BUFFER: //can read header file while writing buffer
      if (mHeaderFileState != kIDLE) {
	if (result != FS_OK) {
	  //DEBUG("open bad", 8);
	  headerReadFailed(err_EepromFailure);
	} else {
	  //DEBUG("got open", 8);
	  post loadBufferTask();
	}
      }
      break;
    case kREAD_FILE_COUNT:
      if (result != FS_OK) {
	mState = kIDLE;
	readCountDone(err_EepromFailure);
      } else {
	//	DEBUG("getCnt", 6);
	if (call HeaderFileRead.read(&mNumFiles, 1) != SUCCESS) {
	  mState = kIDLE;
	  call HeaderFileRead.close();
	  readCountDone(err_EepromFailure);
	}
      }
    default:
      break;

      
    }
    return SUCCESS;
  }


  //HeaderFileWrite routines
  event result_t HeaderFileWrite.opened(filesize_t sz, fileresult_t result) {
    switch (mState) {
    case kWRITE_BUFFER:
      if (result != FS_OK) {
	//DEBUG("failOpen", 8);
	mState = kIDLE;
	if (mDelete) 
	  signal DBBuffer.deleteBufferDone(mReplaceBufId, err_EepromFailure);
	else
	  signal DBBuffer.writeBufferDone(mReplaceBufId,err_EepromFailure);
      } else {
	if (mNumFiles == mCurWriteIdx) {
	  mAppendState = kWRITE_NEXT_BUFFER;
	  post appendBufferTask(); //move on out...
	} else {
	  //DEBUG("bufOpen", 7);
	  call DBBuffer.loadEEPROMBufferIdx(mCurWriteIdx);
	  
	}
      }
      break;
    case kWRITE_FILE_COUNT:
      if (result != FS_OK) {
	mState = kIDLE;
	writeCountDone(err_EepromFailure);
      } else {
/*  	{ */
/*  	  char readStr[5]; */
	  
/*  	  mDbgBuf[0] = 0;  */
/*  	  strcat(mDbgBuf, "wcnt:");  */
/*  	  itoa(mNumFiles, readStr, 10);  */
/*  	  strcat(mDbgBuf, readStr);  */
/*  	  DEBUG(mDbgBuf, strlen(mDbgBuf));  */
/*  	} */

	if (call HeaderFileWrite.append(&mNumFiles, 1) != SUCCESS) {
	  mState = kIDLE;
	  writeCountDone(err_EepromFailure);
	}
      }
      break;
    default:
      break;
    }
    return SUCCESS;

  }

  event result_t HeaderFileWrite.appended(void *buffer, filesize_t nWritten, fileresult_t result) {
    switch (mState) {
    case kWRITE_BUFFER:
      if (result != FS_OK) {
	//make sure we clean up
	call MemAlloc.unlock((Handle)mAppendBuf->name);
	call MemAlloc.unlock((Handle)mAppendBuf->qh);
	mState = kIDLE; //HACK: unset state so we don't renamed files, etc after close
	call HeaderFileWrite.close();
	if (mDelete) 
	  signal DBBuffer.deleteBufferDone(mReplaceBufId, err_EepromFailure);
	else
	  signal DBBuffer.writeBufferDone(mReplaceBufId,err_EepromFailure);
      } else {
	post appendBufferTask();
      }
      break;
    case kWRITE_FILE_COUNT:
      //close, even if there was an error
      call HeaderFileWrite.close();

      break;
    default:
      break;
    }
    return SUCCESS;
  }


  event result_t HeaderFileWrite.closed(fileresult_t result) {
    switch (mState) {
    case kWRITE_BUFFER:
      if (result == FS_OK) {
	//remove the old "tdbBufs" file
	call FileDelete.delete("tdbBufs");
      } else {
	mState = kIDLE;
	if (mDelete) 
	  signal DBBuffer.deleteBufferDone(mReplaceBufId, err_EepromFailure);
	else
	  signal DBBuffer.writeBufferDone(mReplaceBufId,err_EepromFailure);

      }
      break;
    case kWRITE_FILE_COUNT:
      mState = kIDLE;
      writeCountDone(result == FS_OK ? err_NoError : err_EepromFailure);
      break;
    default:
      break;
    }
    return SUCCESS;
  }



  event result_t HeaderFileWrite.reserved(filesize_t reservedSize, fileresult_t result) {
    return SUCCESS;
  }

  event result_t HeaderFileWrite.synced(fileresult_t result) {
    return SUCCESS;
  }



  //FileDelete Routines
  event result_t FileDelete.deleted(fileresult_t result) {
    if (mState == kWRITE_BUFFER) {
      if (result == FS_OK || result == FS_ERROR_NOT_FOUND) {
	call FileRename.rename("tdbBufs2", "tdbBufs");
      } else {
	mState = kIDLE;
	if (mDelete) 
	  signal DBBuffer.deleteBufferDone(mReplaceBufId, err_EepromFailure);
	else
	  signal DBBuffer.writeBufferDone(mReplaceBufId,err_EepromFailure);
      }
    } else if (mState == kCLEANUP) {
      if (result == FS_OK) {
	mHasName = FALSE;
	call FileDir.start();
	call FileDir.readNext();
      } else {
	mState = kIDLE;
	signal DBBuffer.cleanupDone(FAIL);
      }
    }
    return SUCCESS;
  }


  //FileRename Routines
  event result_t FileRename.renamed(fileresult_t result) {
    if (result == FS_OK) {
      mState = kIDLE;
      writeFileCount();
    } else {
      mState = kIDLE;
      if (mDelete) 
	signal DBBuffer.deleteBufferDone(mReplaceBufId, err_EepromFailure);
      else
	signal DBBuffer.writeBufferDone(mReplaceBufId ,err_EepromFailure);
    }
    return SUCCESS;
  }

#endif
  

  /* --------------------- Default event handlers ------------------------- */
  default event result_t DBBuffer.resultReady(uint8_t bufferId) {
    return SUCCESS;
  }

  default event result_t DBBuffer.getNext(uint8_t bufferId) {
    return SUCCESS;
  }

  default event result_t DBBuffer.allocComplete(uint8_t bufferId, TinyDBError result) {

    return SUCCESS;
  }

  default event result_t DBBuffer.putComplete(uint8_t bufferId, QueryResult *buf, TinyDBError result) {

    return SUCCESS;
  }

#ifdef kMATCHBOX
  default event result_t DBBuffer.writeBufferDone(uint8_t bufId, TinyDBError err) {
    return SUCCESS;
  }

  default event result_t DBBuffer.cleanupDone(result_t success) {
    readCountDone(success == SUCCESS ? err_NoError : err_EepromFailure);
  }
#endif

  /* --------------------- Event handlers ------------------------- */

  event result_t MemAlloc.allocComplete(HandlePtr handle, result_t success) {
    Handle *bufList;


	//Handle h = bufList[buf->nextFull];
      if (mState == kIDLE || mState == kREAD_ROW) //not for us
        return SUCCESS; 



      if (success) {
        switch (mState) { 
        case kALLOC_SCHEMA:
	  //need to copy schema over!
	  memcpy (**handle,(char *)mAllocSchema,call ParsedQueryIntf.pqSize(mAllocSchema));
	  //now we have to alloc the memory buffer */
	  mState = kALLOC_BUFFER; 
	  switch (mBuffers[mCurBuffer].type) {
	  case kRAM:
	    if (call MemAlloc.allocate((HandlePtr)&mBuffers[mCurBuffer].u.bufdata, mBuffers[mCurBuffer].len) == FAIL) { 
	      mState = kIDLE;  //error!
	      cleanupBuffer(mCurBuffer, __LINE__);
	      signal DBBuffer.allocComplete(mCurBuffer, err_UnknownError); 
	    } 
	    break;
	  case kEEPROM:
	    //DEBUG("write", 5);
#ifdef kMATCHBOX
	    if (call FileWrite.open(mNamePtr, FS_FCREATE | FS_FTRUNCATE) == FAIL) {
#ifdef kUART_DEBUGGER
	      //	      DEBUG("DBBuf:write open fail", 21);	  
#endif
	      mState = kIDLE;  //error!
	      cleanupBuffer(mCurBuffer, __LINE__);
	      signal DBBuffer.allocComplete(mCurBuffer, err_EepromFailure); 
	    }
#else
	    {
	      //HACK -- this code below to make this somewhat useable on 
	      // PC
	      //cleanupBuffer(mCurBuffer, __LINE__);
	      Buffer *buf = &mBuffers[mCurBuffer];
	      //need to allocate name
	      mState = kALLOC_NAME;
	      buf->u.eeprom.isOpen = TRUE; //mark as open
	      buf->u.eeprom.isWrite = TRUE;
	      if (call MemAlloc.allocate((HandlePtr)&mBuffers[mCurBuffer].name, strlen(mNamePtr) + 1) == FAIL) {
		mState = kIDLE;  //error!
		cleanupBuffer(mCurBuffer, __LINE__);
		signal DBBuffer.allocComplete(mCurBuffer, err_OutOfMemory); 
	      }
	      //signal DBBuffer.allocComplete(mCurBuffer, /*err_EepromFailure*/ err_NoError); 
	    }
#endif
	    break;
	  default:
	    //shouldn't happen!
	    break;
	  }
	  break; 
	case kEEPROM_ALLOC_ROW: {
	  Buffer *buf = &mBuffers[mCurBuffer];

	  call MemAlloc.lock(*handle);
	  call QueryResultIntf.toBytes(mCurResult, *buf->qh, ((char *)**handle) + 1);
	  (**handle)[0] = (char)(call MemAlloc.size(*handle) - 1); //make the first byte a size byte
	  mState = kEEPROM_WRITE;
#ifdef kMATCHBOX
	  if (call FileWrite.append(**handle, call MemAlloc.size(*handle)) == FAIL) {
	    call MemAlloc.unlock(*handle);
	    mState = kIDLE;
	    cleanupBuffer(mCurBuffer, __LINE__);
	    signal DBBuffer.putComplete(mCurBuffer, mCurResult, err_EepromFailure);
	  }
#else
	    call MemAlloc.unlock(*handle);
	    mState = kIDLE;
	    cleanupBuffer(mCurBuffer, __LINE__);
	    signal DBBuffer.putComplete(mCurBuffer, mCurResult, err_EepromFailure);
#endif
	}
	break;
        case kALLOC_BUFFER: 

      	  memset(**handle, 0, mBuffers[mCurBuffer].len); //clear to 0
	  if (mNamePtr != NULL) {
	    mState = kALLOC_NAME;
	    if (call MemAlloc.allocate((HandlePtr)&mBuffers[mCurBuffer].name, strlen(mNamePtr) + 1) == FAIL) {
	      mState = kIDLE;  //error!
	      cleanupBuffer(mCurBuffer, __LINE__);
	      signal DBBuffer.allocComplete(mCurBuffer, err_UnknownError); 
	    }
	  } else {
	    mState = kIDLE; 
#ifdef kDEBUG
	    enqueueResult();
#endif	    
	    mUsedBufs |= (1 << mCurBuffer); 
	    signal DBBuffer.allocComplete(mCurBuffer, err_NoError); 
	  }
	  break; 
	case kALLOC_NAME: 
	  mUsedBufs |= (1 << mCurBuffer); 
	  strcpy(*mBuffers[mCurBuffer].name, mNamePtr);
	  mState = kIDLE;
#ifdef kMATCHBOX
	  if (mBuffers[mCurBuffer].type == kEEPROM) {
	    mAllocing = TRUE;
	    call DBBuffer.writeEEPROMBuffer(mCurBuffer);
	  } else
#endif
	    signal DBBuffer.allocComplete(mCurBuffer, err_NoError);
	  break;
	case kALLOC_ROW: {

	  Buffer *buf = &mBuffers[mCurBuffer];
	  bufList = (Handle *)(*buf->u.bufdata);
	  bufList[mCurRow] = *handle;
	  call MemAlloc.lock(*handle);
	  call QueryResultIntf.toBytes(mCurResult, *buf->qh, (char *)**handle);
	  call MemAlloc.unlock(*handle);
	  mState = kIDLE;

#ifdef kDEBUG
	  readResult();
	  enqueueResult();
#endif
	  signal DBBuffer.putComplete(mCurBuffer, mCurResult, err_NoError);
	}
	break;
#ifdef kMATCHBOX
	case kALLOC_FOR_READ:
	  post readEEPROMRow();
	  break;
	case kHEADER_READ:
	case kWRITE_BUFFER:  //can write buffer while reading header
	  if (mHeaderFileState == kALLOC_NAME || mHeaderFileState == kALLOC_QUERY ||
	      mHeaderFileState == kALLOC_FIELD_DATA) {

	    post loadBufferTask();
	  }
	  break;
#endif
	default:
	  break;
	}
      } else { 

	switch (mState) {
	case kALLOC_BUFFER:
	case kALLOC_SCHEMA:
	case kALLOC_NAME:
	  cleanupBuffer(mCurBuffer, __LINE__);
	  signal DBBuffer.allocComplete(mCurBuffer, err_UnknownError); 
	  break;
	case kALLOC_ROW:
	  //this is bad news -- we should probably abort this query -- for now
	  //just do our best to clean up
	  cleanupBuffer(mCurBuffer, __LINE__);
	  signal DBBuffer.putComplete(mCurBuffer, mCurResult, err_UnknownError);
	  break;
	case kALLOC_FOR_READ:
	  signal DBBuffer.getComplete(mCurBuffer, mCurResult, err_OutOfMemory);
	  break;
#ifdef kMATCHBOX
	case kHEADER_READ:
	case kWRITE_BUFFER: //can write buffer while reading header
	  headerReadFailed(err_OutOfMemory);
	  break;
#endif
	default:
	  break; 
	}
        mState = kIDLE;  //reset state
      }
    
    return SUCCESS;
  }

  event result_t MemAlloc.compactComplete() {
    return SUCCESS;
  }

  event result_t MemAlloc.reallocComplete(Handle handle, result_t success) {
    if (mState != kIDLE && handle == mCurRowHandle)
      return signal MemAlloc.allocComplete(&mCurRowHandle,success);
    else
      return SUCCESS; //not for us
    //return SUCCESS;
  }


  event result_t QueryProcessor.queryComplete(ParsedQueryPtr q) {
      uint8_t bufid; 

      if (call DBBuffer.getBufferId(q->qid, FALSE,  &bufid) == err_NoError) { 
	cleanupBuffer(bufid, __LINE__);
      }  else {
	
#ifdef kMATCHBOX
	TinyDBError err;

	if (q->fromBuffer != kNO_QUERY) { //we're reading from some buffer
	  err = call DBBuffer.getBufferId(q->fromBuffer, q->fromCatalogBuffer, &bufid);
	  if (err == err_NoError) {
	    Buffer *buf = &mBuffers[bufid];

	    if (buf->type == kEEPROM && buf->u.eeprom.isOpen) {
	      if (!buf->u.eeprom.isWrite)
		call FileRead.close();
	      buf->u.eeprom.isOpen = FALSE; //mark as closed
	    }

	  }
	} 
	//we're writing to some buffer
	if (q->bufferType == kEEPROM && q->buf.ram.hasOutput) {
	  Buffer *buf = &mBuffers[q->bufferId];

	  //DEBUG("done query", 10);

	  if (buf->type == kEEPROM && buf->u.eeprom.isOpen) {
	    if (buf->u.eeprom.isWrite)
	      call FileWrite.close();
	    buf->u.eeprom.isOpen = FALSE; //mark as closed
	  }

	}
#endif
      }

	    
      return SUCCESS;
  }

  event result_t CommandUse.commandDone(char *commandName, char *resultBuf, SchemaError