void KeyFile::init() {
KeyFileHeader header;
readHead(header, false);
header.checkFileVersion(getName());
SETCONST(m_keydef, header.m_keydef, KeyFileDefinition);
((KeyPageInfo&)m_pageInfo).init(m_keydef.getSize());
}
// reads an existing edb header at a given recno and sets header values
EDB_Status EDB::open(uint32_t head_ptr)
{
EDB_head_ptr = head_ptr;
EDB_table_ptr = sizeof(EDB_Header) + EDB_head_ptr;
readHead();
return EDB_OK;
}
void KeyFile::setRoot(KeyPageAddr addr, int delta) {
KeyFileHeader header;
readHead(header, false);
header.m_root = addr;
header.m_keyCount += delta;
writeHead(header);
}
AsfFile::AsfFile(const char *fileName, int memoryLimitInBytes)
: _memoryLimitInBytes(memoryLimitInBytes)
{
char last = *std::string(fileName).rbegin();
if (last == 'z')
{
_stream = (std::istream*) new igzstream(fileName,
std::ios::in | std::ios::binary);
_isPositioningDenied = true;
}
else if (last == 'f')
{
_stream = new std::ifstream(fileName,
std::ios::in | std::ios::binary);
_isPositioningDenied = false;
}
else
{
THROW_EXCEPTION("Unknown file format.");
}
if (!_stream->good())
{
THROW_EXCEPTION("Can't open ASF file.");
}
readHead();
readBody();
}
// reads an existing edb header at a given recno and sets header values
EDB_Status EDB::open(unsigned long head_ptr)
{
EDB_head_ptr = head_ptr;
// Thanks to Steve Kelly for the next line...
EDB_table_ptr = sizeof(EDB_Header) + EDB_head_ptr; // this line was originally missing in the downloaded library
readHead();
return EDB_OK;
}
void KeyFile::truncate() { // remove all data!!! be careful
KeyFileHeader header;
readHead(header, false);
const KeyFileDefinition keydef = header.m_keydef;
header.init(keydef);
DbFile::truncate();
writeHead(header);
}
// reads an existing edb header at a given recno and sets header values
EDB_Status EDB::open(unsigned long head_ptr)
{
EDB_head_ptr = head_ptr;
EDB_table_ptr = sizeof(EDB_Header) + EDB_head_ptr;
readHead();
return EDB_OK;
}
KeyFileInfo KeyFile::getInfo() {
KeyFileHeader header;
readHead(header,false);
KeyPage page(header.m_keydef.getSize());
KeyFileInfo result;
result.m_header = header;
result.m_size = getSize();
result.m_pageInfo = m_pageInfo;
if(header.m_root == DB_NULLADDR) {
result.m_rootPageAddress = 0;
result.m_rootPageItemCount = 0;
result.m_treeHeight = 0;
} else {
result.m_rootPageAddress = getPageOffset(header.m_root);
KeyPage page(m_keydef.getSize());
readPage(header.m_root,page);
result.m_rootPageItemCount = page.getItemCount();
result.m_treeHeight = 1;
for(KeyPageAddr addr = page.getChild(0); addr; addr = page.getChild(0)) {
readPage(addr,page);
result.m_treeHeight++;
}
}
result.m_rootPageIndex = header.m_root;
result.m_dataPageCount = (UINT)((result.m_size - sizeof(header)) / m_pageInfo.m_pageSize - header.m_freeListSize);
UINT nonLeafPageCount = 0;
UINT leafPageCount = 0;
CompactIntArray &pageCountPerLevel = result.m_pageCountPerLevel;
if(result.m_treeHeight == 0) { // file is empty
pageCountPerLevel.add(0);
} else {
for(UINT l = 0; l < result.m_treeHeight; l++) {
pageCountPerLevel.add(0);
}
pageCountPerLevel.first() = 1;
KeyPageCounter pageCounter(pageCountPerLevel);
pageScan(result.m_header.m_root, 0, pageCounter, max(0, result.m_treeHeight-3));
if(result.m_treeHeight >= 3) {
for(size_t i = 0; i < pageCountPerLevel.size()-1; i++) {
nonLeafPageCount += pageCountPerLevel[i];
}
leafPageCount = pageCountPerLevel.last() = result.m_dataPageCount - nonLeafPageCount;
}
}
const ULONG totalPageCount = result.m_dataPageCount + header.m_freeListSize;
if(totalPageCount == 0) {
result.m_utilizationRate = 100;
} else {
const INT64 maxKeys = (INT64)nonLeafPageCount * m_pageInfo.m_maxItemCount + (INT64)leafPageCount * m_pageInfo.m_maxKeyCount;
result.m_utilizationRate = PERCENT(header.m_keyCount, maxKeys);
}
return result;
}
void KeyFile::setFreeList(KeyPageAddr addr, int dsize) {
KeyFileHeader header;
readHead(header, true);
header.m_freeList = addr;
header.m_freeListSize += dsize;
if(header.m_freeListSize < 0) {
throwSqlError(SQL_FATAL_ERROR,_T("KeyFile::setFreeList:m_header.m_freeListSize<0. (=%d)"),header.m_freeListSize);
} else if(header.m_freeListSize == 0 && header.m_freeList != DB_NULLADDR) {
throwSqlError(SQL_FATAL_ERROR,_T("KeyFile::setFreeList:m_header.m_freeListSize=0 and m_freeList != NULLADDR."));
} else if(header.m_freeListSize > 0 && header.m_freeList == DB_NULLADDR) {
throwSqlError(SQL_FATAL_ERROR,_T("KeyFile::setFreeList:m_header.m_freeListSize>0 and m_freeList == NULLADDR."));
}
writeHead(header);
}
void KeyFile::dump(FILE *f, int flags) {
KeyFileHeader header;
readHead(header, false);
KeyPage page(m_pageInfo);
dbAddrDump(header.m_root, 1,f,flags);
if(flags & DUMP_HEADER) {
_ftprintf(f,_T("Root:%s Last:%s Freelist:("), toString(header.m_root).cstr(), toString(header.m_last).cstr());
}
if(flags & DUMP_FREELIST) {
for(KeyPageAddr list = header.m_freeList;list != DB_NULLADDR; list = page.getNextFree()) {
_ftprintf(f,_T("%s "),toString(list).cstr());
readPage(list, page);
}
_ftprintf(f,_T(")\n"));
}
}
int main()
{
static struct LMF_ccs_encodingHeader *pEncoH = NULL;
double x1, y1, z1, x2, y2, z2;
FILE *pfCCS = NULL;
system("ls *ccs *cch");
if (LMFcchReader(""))
exit(EXIT_FAILURE);
pfCCS = open_CCS_file2(ccsFileName); /* // LMF binary file */
fseek(pfCCS, 0L, 0);
pEncoH = readHead(pfCCS); /* // read head of ccs */
while (findXYZinLMFfile(pfCCS, &x1, &y1, &z1, &x2, &y2, &z2, pEncoH)) {
printf("\n\nOne coinci event read : \n");
printf("first : %f\t", x1);
printf("%f\t", y1);
printf("%f\t and second : ", z1);
printf("%f\t", x2);
printf("%f\t", y2);
printf("%f\n", z2);
}
if (pfCCS) {
fclose(pfCCS);
printf("File CCS closed\n");
}
destroy_findXYZinLMFfile(pEncoH);
LMFcchReaderDestructor();
destroyReadHead();
printf("\nmain over\n");
return (EXIT_SUCCESS);
}
void DetailExcelWidget::getSheetData(Worksheet* sheet)
{
sheetName.push_back(sheet->sheetName());
readHead(sheet);
readType(sheet);
}
KeyPageAddr KeyFile::getFreeList() {
KeyFileHeader header;
readHead(header, false);
return header.m_freeList;
}
void readIpc (unsigned char* bufferedData) {
// fix the data length so if the interrupt adds data
// during execution of this block, it will be read
// until the next readIpc
unsigned int tmpLen = getLength(protBuffer);
unsigned int i=0;
unsigned int availBytes = 0, sendMore = 0;
unsigned char failureTrue = 0;
//static unsigned long long timeStamp = 0;
// Set the output size accordingly
bufferedData[0] = (tmpLen > MAXLOGLEN)? MAXLOGLEN: tmpLen;
// TODO: Remove debugging info from readIPC
//if ((timeStamp % 1000)== 0){
// printToUart2("T: %6.0f\n\r\0",(float) timeStamp*0.01);
//}
//timeStamp++;
// write the data
for(i = 1; i <= bufferedData[0]; i += 1 )
{
bufferedData[i] = readFront(protBuffer);
}
if (getOverflow(protBuffer)>0) {
// disable the SPI module
SPI1STATbits.SPIEN = 0;
// Disable the interrupts
IEC0bits.SPI1IE = 0;
IFS0bits.SPI1IF = 0;
printToUart2("\n=== %s =====\n\r\n\r\n\r", "BEGIN DUMP ");
//printToUart2("Ts: %f\n\r\0",(float) timeStamp*0.01);
printToUart2("Ovrflw: %d\n\r", getOverflow(protBuffer));
printToUart2("Head: %d\n\r", readHead(protBuffer));
printToUart2("Tail: %d\n\r", readTail(protBuffer));
printToUart2("Len: %d\n\r", getLength(protBuffer));
printToUart2("Siz: %d\n\r", protBuffer->size);
for(i = 0; i <BSIZE; i ++ )
{
printToUart2("%d ", protBuffer->buffer[i]);
}
printToUart2("\n=== %s =====\n\r\n\r\n\r", "END ");
// Empty the buffer
makeEmpty(protBuffer);
// Enable the interrupts
IFS0bits.SPI1IF = 0;
IEC0bits.SPI1IE = 1;
// Enable the SPI module
SPI1STATbits.SPIEN = 1;
}
}
UINT KeyFile::getFreePageCount() {
KeyFileHeader header;
readHead(header,false);
return header.m_freeListSize;
}
UINT64 KeyFile::getKeyCount() {
KeyFileHeader header;
readHead(header, false);
return header.m_keyCount;
}
void KeyFile::setLast(KeyPageAddr addr) {
KeyFileHeader header;
readHead(header, true);
header.m_last = addr;
writeHead(header);
}
KeyPageAddr KeyFile::getLast() {
KeyFileHeader header;
readHead(header, false);
return header.m_last;
}
void DB::open(int head_ptr)
{
DB_head_ptr = head_ptr;
DB_tbl_ptr = head_ptr + DB_HEAD_SIZE;
readHead();
}
// reads an existing edb header at a given recno and sets header values
EDB_Status EDB::open(unsigned long head_ptr)
{
EDB_head_ptr = head_ptr;
readHead();
return EDB_OK;
}
// truncates the queue by resetting the internal pointers
void EDB::clear()
{
readHead();
create(EDB_head_ptr, EDB_head.table_size, EDB_head.rec_size);
}
