void selStat(TABLE table)
{
FILE *stat; //for reading stat.tbl
DATA *data; //record array
FIELD field; //filed name
int record/* # of record */, fld/*# of field*/, i;//for loop
findRecord(table, &record, &fld); //find # of records
strcat(table, ".tbl"); //make table name file name
stat = fopen(table, "rb");
//If stat.tbl does not exist
if(stat == NULL){
printf("There is no stat.tbl!!\n");
}
//read field name
fread(field, sizeof(FIELD), 1, stat);
//print field names
printf("%10s%10s%10s\n", field, "TOT", "AVG");
data = calloc(sizeof(DATA), record); //dynamic allocation for records
for(i = 0 ; i < record ; i++){
fread(data[i].id, sizeof(ID), 1, stat); //read id
fread(&(data[i].tot), sizeof(int), 1, stat); //read total score
fread(&(data[i].avg), sizeof(double), 1, stat); //read average score
printf("%10s%10d%10.3lf\n", data[i].id, data[i].tot, data[i].avg); //print records
}
printf("Show %d records...\n", record);
free(data); //free dynamic allocation
fclose(stat);
}
PVDatabase::~PVDatabase()
{
if(DEBUG_LEVEL>0) cout << "PVDatabase::~PVDatabase()\n";
size_t len = recordMap.size();
shared_vector<string> names(len);
PVRecordMap::iterator iter;
size_t i = 0;
for(iter = recordMap.begin(); iter!=recordMap.end(); ++iter) {
names[i++] = (*iter).first;
}
for(size_t i=0; i<len; ++i) removeRecord(findRecord(names[i]));
}
void _ccFree(void* ptr, const char* file, int line) {
// basic validation
if(!ptr)
return;
// find record and remove it
ccMemoryRecord* r = findRecord(ptr);
if(r) {
removeRecord(r);
free(r);
}
// even record is not found, we must release it
free(ptr);
}
void* _ccRealloc(void* ptr, size_t size, const char* file, int line) {
ccMemoryRecord* r = findRecord(ptr);
if(r) {
// realloc
void* newPtr = _ccMalloc(size, file, line, "REALLOC");
memcpy(newPtr, ptr, r->size);
free(ptr);
// remove record
removeRecord(r);
free(r);
return newPtr;
} else {
return realloc(ptr, size);
}
}
//func. for showing score.tbl
void selScore(TABLE table)
{
FILE *scr; //for reading score.tbl
DATA *data; //record array
FIELD *fields; //filed names
int record/*# of record*/, fld/*# of filed*/, i, j;//for loop
findRecord(table, &record, &fld); //find # of record & field
strcat(table, ".tbl"); //make table name file name
scr = fopen(table, "rb");
//if score.tbl does not exist
if(scr == NULL){
printf("There is no score.tbl!!\n");
return ;
}
fields = calloc(sizeof(FIELD), fld); //dynamic allocation for # of fields
//read field names
fread(fields, sizeof(FIELD), fld, scr);
//print field names
for(i = 0 ; i < fld ; i++){
printf("%7s", fields[i]);
}
printf("\n");
data = calloc(sizeof(DATA), record); //dynamic allocation for records
//read records
for(i = 0 ; i < record ; i++){
fread(data[i].id, sizeof(ID), 1, scr); //read id
data[i].score = calloc(sizeof(int), (fld - 1)); //dynamic allocation for scores
fread(data[i].score, sizeof(int), (fld - 1), scr); //read scores
printf("%7s", data[i].id);
for(j = 0 ; j < (fld - 1) ; j++){
printf("%7d", data[i].score[j]); //print scores
}
printf("\n");
free(data[i].score); //free dynamic allocation
}
printf("Show %d records...\n", record);
free(data); //free dynamic allocation
fclose(scr);
}
void _ccFree(void* ptr, const char* file, int line) {
// basic validation
if(!ptr)
return;
// find record and remove it
ccMemoryRecord* r = findRecord(ptr);
if(r) {
#if CC_CFLAG_ALLOCATION_LOG
CCLOG("[FREE](%p)(record=%p):%d [%s:%d]", r->start, r, r->size, r->file, r->line);
#endif
removeRecord(r);
free(r);
}
// even record is not found, we must release it
free(ptr);
}
//func. for showing student.tbl
void selStudent(TABLE table)
{
FILE *stu; //for reading student.tbl
DATA *data; //record array
FIELD fields[BASEFLD];//field name array
int record,/*# of records*/ fld, /*# of fields*/ i;/*for loop*/
findRecord(table, &record, &fld); //call func. for finding # of records
strcat(table, ".tbl"); //make table name file name
stu = fopen(table, "rb");
//if student.tbl does not exist
if(stu == NULL){
printf("There is no student.tbl!!\n");
return ;
}
//read field names
fread(fields, sizeof(FIELD), BASEFLD, stu);
//print field names
for(i = 0 ; i < BASEFLD ; i++){
printf("%10s", fields[i]);
}
printf("\n");
//dynamic allocation for record array
data = calloc(record, sizeof(DATA));
//read records
for(i = 0 ; i < record ; i++){
fread(data[i].id, sizeof(ID), 1, stu); //read id
fread(data[i].name, sizeof(NAME), 1, stu); //read name
fread(data[i].dept, sizeof(DEPT), 1, stu); //read department
printf("%10s%10s%10s\n", data[i].id, data[i].name, data[i].dept); //print id, name, and department
}
printf("Show %d records...\n", record);
free(data); //free dynamic allocation
fclose(stu);
}
RecordData KVRecordStore::dataFor( OperationContext* txn, const RecordId& loc) const {
RecordData rd;
bool found = findRecord(txn, loc, &rd);
massert(28923, "Didn't find RecordId in record store", found);
return rd;
}
//func. for showing all fields
void selALL()
{
FILE *stu, /* student.tbl */*scr, /*score.tbl*/ *stat; /*stat.tbl*/
DATA *data; //records
FIELD *fields; //field names
int record, /*# of records*/ fld, /*# of all fields*/
sFld, /*# of score field */ i, j; //for loop
findRecord("score", &record, &sFld); //find # of score records and # of score fields
fld = sFld + BASEFLD + TOTAVG - 2; //calculate # of all fields
stu = fopen("student.tbl", "rb");
scr = fopen("score.tbl", "rb");
stat = fopen("stat.tbl", "rb");
//table files does not exist
if(stu == NULL || scr == NULL || stat ==NULL){
printf("There is no table file!!\n");
return ;
}
fields = calloc(sizeof(FIELD), fld); //dynamic allocation for field names
//read field names
for(i = 0 ; i < BASEFLD ; i++){
fread(fields[i], sizeof(FIELD), 1, stu);
}
fseek(scr, sizeof(FIELD), SEEK_SET);
for(i = BASEFLD ; i < (sFld - 1 + BASEFLD) ; i++){
fread(fields[i], sizeof(FIELD), 1, scr);
}
fseek(stat, sizeof(FIELD), SEEK_SET);
for(i = (sFld + BASEFLD) ; i < fld ; i++){
fread(fields[i], sizeof(FIELD), 1, stat);
}
//print field names
for(i = 0 ; i < (fld - 1) ; i++){
printf("%10s", fields[i]);
}
printf("%10s%10s\n", "TOT", "AVG");
free(fields); //free dynamic allocation
//dynamic allocation for records
data = calloc(sizeof(DATA), record);
//read record
for(i = 0 ; i < record ; i++){
fread(data[i].id, sizeof(ID), 1, stu); //read id
fread(data[i].name, sizeof(NAME), 1, stu); //read name
fread(data[i].dept, sizeof(DEPT), 1, stu); //read department
fseek(scr, sizeof(ID), SEEK_CUR); //skip id
data[i].score = calloc(sizeof(int), sFld - 1); //dynamic allocation for score
fread(data[i].score, sizeof(int), sFld - 1, scr); //read scores
fseek(stat, sizeof(ID), SEEK_CUR); //skip id
fread(&(data[i].tot), sizeof(int), 1, stat); //read total score
fread(&(data[i].avg), sizeof(double), 1, stat); //read average score
}
//print record
for(i = 0 ; i < record ; i++){
printf("%10s%10s%10s", data[i].id, data[i].name, data[i].dept);
for(j = 0 ; j < (sFld - 1) ; j++){
printf("%10d", data[i].score[j]);
}
printf("%10d%10.3lf\n", data[i].tot, data[i].avg);
free(data[i].score); //free dynamic allocation for scores
}
printf("show %d records...\n", record);
free(data); //free dynamic allocation for records
fclose(stu);
fclose(scr);
fclose(stat);
}
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
//
//
// Constructor
//
//
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
dicomDir::dicomDir(ptr<dataSet> pDataSet):
m_pDataSet(pDataSet)
{
if(m_pDataSet == 0)
{
m_pDataSet =new dataSet;
}
// Parse the dataset
///////////////////////////////////////////////////////////
lockObject lockDataSet(pDataSet);
// Get the DICOMDIR sequence
///////////////////////////////////////////////////////////
typedef std::map<std::uint32_t, ptr<directoryRecord> > tOffsetsToRecords;
tOffsetsToRecords offsetsToRecords;
for(std::uint32_t scanItems(0); ; ++scanItems)
{
ptr<dataSet> pDataSet(m_pDataSet->getSequenceItem(0x0004, 0, 0x1220, scanItems));
if(pDataSet == 0)
{
break;
}
ptr<directoryRecord> newRecord(new directoryRecord(pDataSet));
offsetsToRecords[pDataSet->getItemOffset()] = newRecord;
m_recordsList.push_back(newRecord);
}
// Scan all the records and update the pointers
///////////////////////////////////////////////////////////
for(tOffsetsToRecords::iterator scanRecords(offsetsToRecords.begin()); scanRecords != offsetsToRecords.end(); ++scanRecords)
{
std::uint32_t nextRecordOffset(scanRecords->second->getRecordDataSet()->getUnsignedLong(0x0004, 0, 0x1400, 0));
std::uint32_t childRecordOffset(scanRecords->second->getRecordDataSet()->getUnsignedLong(0x0004, 0, 0x1420, 0));
std::uint32_t referencedRecordOffset(scanRecords->second->getRecordDataSet()->getUnsignedLong(0x0004, 0, 0x1504, 0));
tOffsetsToRecords::iterator findNextRecord(offsetsToRecords.find(nextRecordOffset));
if(findNextRecord != offsetsToRecords.end())
{
scanRecords->second->setNextRecord(findNextRecord->second);
}
tOffsetsToRecords::iterator findChildRecord(offsetsToRecords.find(childRecordOffset));
if(findChildRecord != offsetsToRecords.end())
{
scanRecords->second->setFirstChildRecord(findChildRecord->second);
}
tOffsetsToRecords::iterator findReferencedRecord(offsetsToRecords.find(referencedRecordOffset));
if(findReferencedRecord != offsetsToRecords.end())
{
scanRecords->second->setReferencedRecord(findReferencedRecord->second);
}
}
// Get the position of the first record
///////////////////////////////////////////////////////////
tOffsetsToRecords::iterator findRecord(offsetsToRecords.find(m_pDataSet->getUnsignedLong(0x0004, 0, 0x1200, 0)));
if(findRecord == offsetsToRecords.end())
{
return;
}
setFirstRootRecord(findRecord->second);
}
