//Construct Response Header char *constructHeader(char* FilePath) { FILE *fp; fp=fopen(FilePath+1,"r"); if(fp==NULL) return NULL; else { char *header =malloc(sizeof(char)*BUF_SIZE); memset(header,0,sizeof(char)*BUF_SIZE); strcpy(header,"HTTP/1.1 200 OK\nConnection: close\nDate: "); char *time = CurrentTime(); strcat(header,time); strcat(header,"Last-Modified: "); char *modtime = LastModified(FilePath); strcat(header,modtime); strcat(header,"Content-Length: "); int leng = Length(FilePath); char len[32]; sprintf(len,"%d",leng); strcat(header,len); strcat(header,"\nContent-Type: "); char *type = FileType(FilePath); strcat(header,type); strcat(header,"\r\n\r\n"); return header; free(header); } fclose(fp); }
FileTypes CellMLSupportPlugin::fileTypes() const { // Return the CellML file type that the CellMLSupport plugin supports return FileTypes() << FileType(qobject_cast<FileInterface *>(this), CellmlMimeType, CellmlFileExtension); }
//------------------------------------------------------------------------------------------------- inline bool_t Dir::isDir() const { bool_t bRv = FileType( dirPath() ).isExists(FileType::faDirectory); xCHECK_RET(!bRv, false); return true; }
static bool SearchDirectory(TCHAR *pathName){ HANDLE SearchHandle; WIN32_FIND_DATA FindData; DWORD FType; TCHAR cpy[100]; lstrcpy(cpy,pathName); bool sw = false; //_tprintf(_T("\n---> Plain Run on %s:\n"),cpy); SetCurrentDirectory(pathName); SearchHandle = FindFirstFile(_T("*"), &FindData); do { FType = FileType(&FindData); if (FType == TYPE_FILE){ //_tprintf(_T("FILE: %s\n"),FindData.cFileName); strcpy(compa, FindData.cFileName); ReleaseSemaphore(cmp, 1, NULL); WaitForSingleObject(rd, INFINITE); } if (FType == TYPE_DIR) { //_tprintf(_T("DIR : %s\n"), FindData.cFileName); strcpy(compa, FindData.cFileName); ReleaseSemaphore(cmp, 1, NULL); WaitForSingleObject(rd, INFINITE); lstrcat(cpy, "\\"); lstrcat(cpy, FindData.cFileName); if (SearchDirectory(cpy) == true){ sw = true; } lstrcpy(cpy,pathName); } } while (FindNextFile(SearchHandle, &FindData)); FindClose(SearchHandle); if (sw == true){ return sw; } else{ return false; } }
static bool TraverseDirectory(TCHAR* pathName,TCHAR* newPathName) { HANDLE SearchHandle; WIN32_FIND_DATA FindData; DWORD FType; TCHAR cpy[100]; lstrcpy(cpy, pathName); bool sw = false; //_tprintf(_T("\n---> Compare %s:\n"),newPathName); SetCurrentDirectory(pathName); SearchHandle = FindFirstFile(_T("*"), &FindData); do { FType = FileType(&FindData); if (FType == TYPE_FILE){ // _tprintf(_T("FILE: %s\n"),FindData.cFileName); if (strcmp(newPathName, FindData.cFileName) == 0){ sw= true; } } if (FType == TYPE_DIR) { //_tprintf(_T("DIR : %s\n"), FindData.cFileName); if (strcmp(newPathName, FindData.cFileName) == 0){ sw = true; } lstrcat(cpy, "\\"); lstrcat(cpy, FindData.cFileName); if (TraverseDirectory(cpy,newPathName) == true){ sw = true; } lstrcpy(cpy, pathName); } } while (FindNextFile(SearchHandle, &FindData)); FindClose(SearchHandle); if (sw == true){ return true; } else{ return false; } }
void FileSystemDevice::complete_getFileType(PacketHeader *packet_) { Packet<uint8,Sys::AsyncFileSystem::FileTypeExt,GetFileTypeExt> packet=packet_; auto ext=packet.getExt(); auto ext2=packet.getDeepExt<1>(); if( ext->isOk() ) { ext2->setFileType(FileType(ext->type)); } else { ext2->setError(MakeError(ext,FileError_OpFault)); } packet.popExt().complete(); }
bool ImagesVideo::LoadFrame(size_t i) { if( (int)i < num_files) { Frame& frame = loaded[i]; for(size_t c=0; c< num_channels; ++c) { const std::string& filename = Filename(i,c); const ImageFileType file_type = FileType(filename); if(file_type == ImageFileTypeUnknown && unknowns_are_raw) { frame.push_back( LoadImage( filename, raw_fmt, raw_width, raw_height, raw_fmt.bpp * raw_width / 8) ); }else{ frame.push_back( LoadImage( filename, file_type ) ); } } return true; } return false; }
void CPreview::Update(const char *fpath) { cmpack_preview_set_model(CMPACK_PREVIEW(m_Preview), NULL); cmpack_preview_set_text(CMPACK_PREVIEW(m_Preview), NULL); gtk_text_buffer_set_text(m_Buffer, "", -1); if (m_Data) { g_object_unref(m_Data); m_Data = NULL; } m_FileType = TYPE_UNKNOWN; if (fpath) { SetPath(fpath); switch (FileType(fpath)) { case TYPE_IMAGE: LoadImage(fpath); break; case TYPE_PHOT: LoadChart(fpath); break; case TYPE_CAT: LoadCatalog(fpath); break; case TYPE_TABLE: LoadTable(fpath); break; case TYPE_VARFIND: LoadVarFind(fpath); break; case TYPE_PROJECT: LoadProject(fpath); break; case TYPE_PROFILE: LoadProfile(fpath); break; default: break; } if (m_Data) cmpack_preview_set_model(CMPACK_PREVIEW(m_Preview), m_Data); } }
static int lpafFillEntries(LP_ANSWER_FILE *lpaf, char *fname, int entryno) { int nentries, type, i, num ; char buf[100], *base_name, line[200], *cp ; FILE *fp ; nentries = FileNumberOfEntries(fname) ; type = FileType(fname) ; base_name = FileFullName(fname) ; for (i = 0 ; i < nentries ; i++) { switch (type) { case LIST_FILE: fp = fopen(base_name, "rb") ; if (!fp) ErrorReturn(0, (ERROR_NO_FILE, "lpafFillEntries: could not open %s\n", base_name)) ; cp = fgetl(line, 199, fp) ; nentries = 0 ; while (cp) { sscanf(cp, "%s", buf) ; num = lpafFillEntries(lpaf, buf, entryno+nentries) ; nentries += num ; cp = fgetl(line, 199, fp) ; } fclose(fp) ; break ; default: sprintf(buf, "%s#%d", base_name, i) ; lpaf->filelist[entryno+i] = (char *)calloc(strlen(buf)+1, sizeof(char)); strcpy(lpaf->filelist[entryno+i], buf) ; break ; } } return(nentries) ; }
VOID exploreDirectory(LPTSTR dirName, DWORD threadId, DWORD threadNb) { HANDLE dir; WIN32_FIND_DATA fileInfo; DWORD ret; TCHAR pattern[LENGTH], newDirName[LENGTH]; _tcscpy(pattern, dirName); _tcscat(pattern, _T("*")); dir = FindFirstFile(pattern, &fileInfo); if (dir == INVALID_HANDLE_VALUE) { _ftprintf(stderr, _T("Error %i when opening directory %s\n"), GetLastError(), pattern); return; } do { entries[threadNb] = fileInfo.cFileName; EnterCriticalSection(&criticalSection); counter++; if (counter == nbThreads) { PulseEvent(eventComparator); } LeaveCriticalSection(&criticalSection); WaitForSingleObject(eventReaders, INFINITE); if (FileType(&fileInfo) == TYPE_DIR) { _tcscpy(newDirName, dirName); _tcscat(newDirName, fileInfo.cFileName); _tcscat(newDirName, _T("/")); exploreDirectory(newDirName, threadId, threadNb); } } while (FindNextFile(dir, &fileInfo)); ret = FindClose(dir); if (ret == FALSE) { _ftprintf(stderr, _T("Error when closing directory %s\n"), dirName); } }
void ReadPrependDef(unsigned typ, OBJECT encl) { OBJECT t, fname; FILE_NUM fnum; t = LexGetToken(); if( type(t) != LBR ) { Error(5, 5, "left brace expected here in %s declaration", WARN, &fpos(t), KW_PREPEND); Dispose(t); return; } fname = Parse(&t, encl, FALSE, FALSE); fname = ReplaceWithTidy(fname, ACAT_TIDY); if( !is_word(type(fname)) ) { Error(5, 6, "name of %s file expected here", WARN, &fpos(fname),KW_PREPEND); DisposeObject(fname); return; } debug0(DFS, D, " calling DefineFile from ReadPrependDef"); fnum = FileNum(string(fname), STR_EMPTY); if( fnum == NO_FILE || FileType(fnum) != PREPEND_FILE ) DefineFile(string(fname), STR_EMPTY, &fpos(fname), PREPEND_FILE, typ == PREPEND ? INCLUDE_PATH : SYSINCLUDE_PATH); } /* end ReadPrependDef */
TypedImage LoadImage(const std::string& filename) { ImageFileType file_type = FileType(filename); return LoadImage( filename, file_type ); }
/*------------------------------------------------------------------------ Parameters: Description: determine the number of separate entries in a file Return Values: ------------------------------------------------------------------------*/ int FileNumberOfEntries(const char *fname) { int type, num, nentries ; FILE *fp ; char buf[STR_LEN], line[2*STR_LEN], *cp ; strcpy(buf, fname) ; /* we will modify fname, don't ruin callers copy */ num = FileNumber(buf) ; if (num == -1) { type = FileType(buf) ; switch (type) { case LIST_FILE: fp = fopen(FileName(buf), "rb") ; if (!fp) ErrorReturn(-1, (ERROR_NO_FILE, "FileNumberOfEntries: could not open %s", FileName(buf))) ; cp = fgetl(line, 199, fp) ; nentries = 0 ; while (cp) { sscanf(cp, "%s", buf) ; num = FileNumberOfEntries(buf) ; nentries += num ; cp = fgetl(line, 199, fp) ; } fclose(fp) ; break ; case UNKNOWN_FILE: // assume it is text if it has no extension or modifieer case TEXT_FILE: fp = fopen(buf, "rb") ; if (!fp) ErrorReturn(-1, (ERROR_NO_FILE, "FileNumberOfEntries: could not open %s",buf)) ; cp = fgetl(line, 199, fp) ; nentries = 0 ; while (cp) { nentries++ ; cp = fgetl(line, 199, fp) ; } fclose(fp) ; break ; case HIPS_FILE: nentries = ImageNumFrames(buf) ; break ; case MATLAB_FILE: default: nentries = -1 ; break ; } } else nentries = 1 ; return(nentries) ; }
static bool CreateDir( String path ){ mkdir( OS_STR( path ),0777 ); return FileType(path)==2; }
int EXECUTE(int cmdId, CmCParser *script, void **paramTable) { switch(cmdId) { //*************************************************** //set global flags //*************************************************** case CMD_SYNERGISTIC: { CmCToken *token; token = script->GetToken(); //get flag if(!strcmp(token->token_, "ON")) { CmCSynergistic = true; CmCPrompt("Synergistic Segmentation ENABLED.\n"); } else { CmCSynergistic = false; CmCPrompt("Synergistic Segmentation DISABLED.\n"); } script->GetToken(); //skip ';' break; } case CMD_DISPLAY_PROGRESS: { CmCToken *token; token = script->GetToken(); //get flag if(!strcmp(token->token_, "ON")) CmCDisplayProgress = true; else CmCDisplayProgress = false; script->GetToken(); //skip ';' CmCPrompt("Display progress ENABLED.\n"); break; } case CMD_USE_CUSTOM_WEIGHT_MAP: { CmCToken *token; token = script->GetToken(); //get flag if(!strcmp(token->token_, "ON")) { CmCUseCustomWeightMap = true; CmCPrompt("Custum weight map IN-USE (if defined).\n"); } else { CmCUseCustomWeightMap = false; CmCPrompt("Custum weight map IN-ACTIVE.\n"); } script->GetToken(); //skip ';' break; } //*************************************************** //load a file //*************************************************** case CMD_LOAD: { CmCToken *token; script->GetToken(); //skip "('" script->GetToken(); token = script->GetToken(); //get filename char *filename = new char[strlen(token->token_)+1]; strcpy(filename, token->token_); script->GetToken(); //skip "'," script->GetToken(); token = script->GetToken(); //get input type int inputtype = InputType(token->token_); script->GetToken(); //skip ");" script->GetToken(); //load file int error = edison.Load(filename, inputtype); if(!error) CmCPrompt("File '%s' has been successfully loaded!\n", filename); delete [] filename; //return any errors if(error) return error; break; } //*************************************************** //save a file //*************************************************** case CMD_SAVE: { CmCToken *token; script->GetToken(); //skip "('" script->GetToken(); token = script->GetToken(); //get filename char *filename = new char [strlen(token->token_) + 1]; strcpy(filename, token->token_); script->GetToken(); //skip "'," script->GetToken(); token = script->GetToken(); //filetype int filetype = FileType(token->token_); script->GetToken(); //skip ',' token = script->GetToken(); //get output type int outputtype = OutputType(token->token_); script->GetToken(); //skip ");" script->GetToken(); //save file int error = edison.Save(filename, filetype, outputtype); if(!error) CmCPrompt("File '%s' has been successfully saved!\n", filename); delete [] filename; //return any errors if(error) return error; break; } //*************************************************** //route output to input //*************************************************** case CMD_USE_RESULT: { CmCToken *token; script->GetToken(); //skip '(' token = script->GetToken(); //get output type int outputtype = OutputType(token->token_); script->GetToken(); //skip ");" script->GetToken(); //route output to input int error = edison.UseResult(outputtype); if(!error) { if(outputtype == OUTPUT_SEGM_IMAGE) { CmCPrompt("Segmented image result has been set as input.\n"); } else { CmCPrompt("Filtered image result has been set as input.\n"); } } if(error) return error; break; } //*************************************************** //edge detect the input image //*************************************************** case CMD_EDGE_DETECT: { edison.SetParameters(paramTable); int error = edison.EdgeDetect(); if(error) return error; script->GetToken(); //skip ';' break; } //*************************************************** //filter the input image //*************************************************** case CMD_FILTER: { edison.SetParameters(paramTable); int error = edison.Filter(); if(error) return error; script->GetToken(); //skip ';' break; } //*************************************************** //fuse the regions of the input image //*************************************************** case CMD_FUSE: { edison.SetParameters(paramTable); int error = edison.Fuse(); if(error) return error; script->GetToken(); //skip ';' break; } //*************************************************** //segment the input image //*************************************************** case CMD_SEGMENT: { edison.SetParameters(paramTable); int error = edison.Segment(); if(error) return error; script->GetToken(); //skip ';' break; } //*************************************************** //does nothing //*************************************************** default: break; } //command executed succesfully! return NO_ERRORS; }
/* * This application substitues in the FASTQ files, the DNA sequence the outside ACGT chars by random ACGT symbols. */ int main(int argc, char *argv[]) { uint32_t streamSize, index, seed = 0; uint8_t value, line = 0; char *bases = "ACGT"; PARSER *Parser = CreateParser(); BUF *Buffer; srand(seed); char *programName = argv[0]; struct argparse_option options[] = { OPT_HELP(), OPT_GROUP("Basic options"), OPT_BUFF('<', "input.fastq", "Input FASTQ file format (stdin)"), OPT_BUFF('>', "output.fastq", "Output FASTQ file format (stdout)"), OPT_END(), }; struct argparse argparse; char usage[250] = "\nExample: "; strcat(usage, programName); strcat(usage, " < input.fastq > output.fastq\n"); argparse_init(&argparse, options, NULL, programName, 0); argparse_describe(&argparse, "\nIt substitues in the FASTQ files, the DNA sequence the outside ACGT chars by random ACGT symbols.", usage); argc = argparse_parse(&argparse, argc, argv); if(argc != 0) argparse_help_cb(&argparse, options); FileType(Parser, stdin); if(Parser->type != 2) { fprintf(stderr, "ERROR: This is not a FASTQ file!\n"); exit(1); } Buffer = CreateBuffer(BUF_SIZE); while((streamSize = fread(Buffer->buf, 1, Buffer->size, stdin))) for(index = 0 ; index < streamSize ; ++index) { value = Buffer->buf[index]; switch(line) { case 0: putchar(value); if(value == '\n') line = 1; break; case 1: if(value == '\n') { putchar('\n'); line = 2; break; } RandIfExtra(value, bases); break; case 2: putchar(value); if(value == '\n') line = 3; break; case 3: putchar(value); if(value == '\n') line = 0; break; } } RemoveBuffer(Buffer); return EXIT_SUCCESS; }
CmCError CheckSyntax(char *filename, CmCParser *synParser) { //***************************************** //parse the file //***************************************** int error; synParser->SetDelimiters("=(){},;'"); synParser->StoreDelimiters(true); error = synParser->Parse(filename); if(error) return (CmCError((CmCToken *) NULL, SYN_INVALID_FILE)); //***************************************** //check syntax //***************************************** int curveId; int parameterId; int commandTypeId, commandId; CmCToken *token, *(tokenSet)[MAX_TOKEN_NUM]; while(token = synParser->GetToken()) { //identify the command... commandId = Command(token->token_); commandTypeId = CommandType(commandId); //based on the command, identify the number of tokens //associated with it and obtain those tokens error = GetTokenSet(commandId, tokenSet, synParser); //if the specified number of tokens does not exist //then return an error if(error == SYN_ERROR) return CmCError((CmCToken *) NULL, error); //if the specified tokens exist, then check them for //their validity switch(commandTypeId) { case CMD_IO: switch(commandId) { case CMD_SAVE: //check structure if(strcmp(tokenSet[0]->token_, "(")) return CmCError(tokenSet[0], SYN_MISSING_LEFT_PARENTHESIS); if(strcmp(tokenSet[1]->token_, "'")) return CmCError(tokenSet[1],SYN_MISSING_QUOTATION); if(strcmp(tokenSet[3]->token_, "'")) return CmCError(tokenSet[3],SYN_MISSING_QUOTATION); if(strcmp(tokenSet[4]->token_, ",")) return CmCError(tokenSet[4],SYN_MISSING_COMMA); if(strcmp(tokenSet[6]->token_, ",")) return CmCError(tokenSet[6],SYN_MISSING_COMMA); if(strcmp(tokenSet[8]->token_, ")")) return CmCError(tokenSet[8],SYN_MISSING_RIGHT_PARENTHESIS); if(strcmp(tokenSet[9]->token_, ";")) return CmCError(tokenSet[9],SYN_MISSING_SEMICOLON); //check constants if(!validFileType(tokenSet[5]->token_)) return CmCError(tokenSet[5],SYN_INVALID_FILETYPE); if(!validOutputType(tokenSet[7]->token_))return CmCError(tokenSet[7],SYN_INVALID_OUTPUTTYPE); if(checkSupported(FileType(tokenSet[5]->token_))) return CmCError(tokenSet[5],SYN_UNSUPPORTED_FILETYPE); break; case CMD_LOAD: //check structure if(strcmp(tokenSet[0]->token_, "(")) return CmCError(tokenSet[0],SYN_MISSING_LEFT_PARENTHESIS); if(strcmp(tokenSet[1]->token_, "'")) return CmCError(tokenSet[1],SYN_MISSING_QUOTATION); if(strcmp(tokenSet[3]->token_, "'")) return CmCError(tokenSet[3],SYN_MISSING_QUOTATION); if(strcmp(tokenSet[4]->token_, ",")) return CmCError(tokenSet[4],SYN_MISSING_COMMA); if(strcmp(tokenSet[6]->token_, ")")) return CmCError(tokenSet[6],SYN_MISSING_RIGHT_PARENTHESIS); if(strcmp(tokenSet[7]->token_, ";")) return CmCError(tokenSet[7],SYN_MISSING_SEMICOLON); //check constants if(!validInputType(tokenSet[5]->token_)) return CmCError(tokenSet[5],SYN_INVALID_INPUTTYPE); break; case CMD_USE_RESULT: if(strcmp(tokenSet[0]->token_, "(")) return CmCError(tokenSet[0], SYN_MISSING_LEFT_PARENTHESIS); if(strcmp(tokenSet[2]->token_, ")")) return CmCError(tokenSet[2], SYN_MISSING_RIGHT_PARENTHESIS); if(strcmp(tokenSet[3]->token_, ";")) return CmCError(tokenSet[3], SYN_MISSING_SEMICOLON); if((OutputType(tokenSet[1]->token_) != OUTPUT_SEGM_IMAGE) && (OutputType(tokenSet[1]->token_) != OUTPUT_FILT_IMAGE)) { if(OutputType(tokenSet[1]->token_) != OUTPUT_UNKNOWN) { return CmCError(tokenSet[1], SYN_ASSIGN_INVALID_ARG); } else { return CmCError(tokenSet[1], SYN_INVALID_OUTPUTTYPE); } } break; } break; case CMD_EXECUTION: if(tokenSet[0]->token_[0] != ';') return CmCError(tokenSet[0],SYN_MISSING_SEMICOLON); break; case CMD_FLAGS: if(!validFlag(tokenSet[0]->token_)) return CmCError(tokenSet[0],SYN_INVALID_FLAG); if(tokenSet[1]->token_[0] != ';') return CmCError(tokenSet[1],SYN_MISSING_SEMICOLON); break; //unknown command default: break; } //if its not a command, then maybe its a parameter if(commandTypeId == UNKNOWN_COMMAND) { //get the parameter type parameterId = Parameter(token->token_); if(parameterId != UNKNOWN_PARAMETER) { //retreive tokens expected given a parameter error = GetParamTokenSet(tokenSet, synParser); if(error == SYN_ERROR) return CmCError(token, SYN_ERROR); //check those tokens for validity if(strcmp(tokenSet[0]->token_, "=")) return CmCError(tokenSet[0],SYN_MISSING_EQUALS); if(strcmp(tokenSet[2]->token_, ";")) return CmCError(tokenSet[2],SYN_MISSING_SEMICOLON); //make sure parameter is of the right type error = CheckParameter(parameterId, tokenSet[1]->token_); if(error) return CmCError(token, error); //if its an unknown parameter then maybe its a curve list } else { //get custom curve curveId = CustomCurve(token->token_); //if its not a custom curve list then flag an error if(curveId == UNKNOWN_CURVE) return CmCError(token,SYN_INVALID_PARAMCMD); //check for equals token = synParser->GetToken(); if(token->token_[0] != '=') return CmCError(token,SYN_MISSING_EQUALS); //if its a curve list, then check that a proper point list //is provided error = CheckList(synParser, &token); if(error) return CmCError(token, error); //check for semicolon token = synParser->GetToken(); if(token->token_[0] != ';') return CmCError(token,SYN_MISSING_SEMICOLON); } } //command/parameter identified and verified for //its validity, next command/parameter } //reset parser synParser->StartOver(); //file is syntaxically correct return CmCError((CmCToken *) NULL, NO_ERRORS); }
static bool DeleteDir( String path ){ rmdir( OS_STR(path) ); return FileType(path)==0; }
static bool DeleteFile( String path ){ remove( OS_STR(path) ); return FileType(path)==0; }
DBInt Read (FILE *file,DBObjData *data) { DBInt i, layer, swap, valueType, valueSize, docLength; DMLayerHeader dmLayerHeader; DBObjRecord *layerRec, *dataRec; DBObjTable *layerTable = data->Table (DBrNLayers); DBObjTable *itemTable = data->Table (DBrNItems); DBObjTableField *rowNumFLD = layerTable->Field (DBrNRowNum); DBObjTableField *colNumFLD = layerTable->Field (DBrNColNum); DBObjTableField *cellWidthFLD = layerTable->Field (DBrNCellWidth); DBObjTableField *cellHeightFLD = layerTable->Field (DBrNCellHeight); DBObjTableField *valueTypeFLD = layerTable->Field (DBrNValueType); DBObjTableField *valueSizeFLD = layerTable->Field (DBrNValueSize); DBObjTableField *layerFLD = layerTable->Field (DBrNLayer); DBGridIF *gridIF; if ((swap = DMFileHeader::Read (file)) == DBFault) return (DBFault); data->Extent (Extent ()); data->Projection (DBMathGuessProjection (data->Extent ())); data->Precision (DBMathGuessPrecision (data->Extent ())); if (FileType () != DMMatrix) { CMmsgPrint (CMmsgAppError, "Wrong File Type in: %s %d",__FILE__,__LINE__); return (DBFault); } switch (DataType ()) { case DMFloat: valueType = DBTableFieldFloat; valueSize = sizeof (DBFloat4);break; case DMInt: valueType = DBTableFieldInt; valueSize = sizeof (DBInt); break; case DMByte: valueType = DBTableFieldInt; valueSize = sizeof (DBByte); break; default: CMmsgPrint (CMmsgAppError, "Wrong Data Value Type in: %s %d",__FILE__,__LINE__); return (DBFault); } for (layer = 0;layer < LayerNum ();++layer) { if (dmLayerHeader.Read (file,swap) == DBFault) return (DBFault); if (strlen (dmLayerHeader.Description ()) > 0) layerName = dmLayerHeader.Description (); else { sprintf (layerNameSTR,"GHAASLayer%4d",layer + 1); layerName = layerNameSTR; } layerTable->Add (layerName); if ((layerRec = layerTable->Item ()) == (DBObjRecord *) NULL) return (DBFault); rowNumFLD->Int (layerRec,RowNum ()); colNumFLD->Int (layerRec,ColNum ()); cellWidthFLD->Float (layerRec,CellWidth ()); cellHeightFLD->Float (layerRec,CellHeight ()); valueTypeFLD->Int (layerRec,((DBInt) DBTypeGridDiscrete) == data->Type () ? DBTableFieldInt : valueType); valueSizeFLD->Int (layerRec,valueSize); if ((dataRec = new DBObjRecord (layerName,((size_t) ColNum ()) * RowNum () * valueSize,valueSize)) == (DBObjRecord *) NULL) return (DBFault); (data->Arrays ())->Add (dataRec); layerFLD->Record (layerRec,dataRec); } if (fread (&docLength,sizeof (int),1,file) != 1) { CMmsgPrint (CMmsgSysError, "File Reading Error in: %s %d",__FILE__,__LINE__); return (DBFault); } if (swap) DBByteOrderSwapWord (&docLength); if (docLength > 0) { char *docString; if ((docString = (char *) calloc (docLength,sizeof (char))) == (char *) NULL) { CMmsgPrint (CMmsgSysError, "Memory Allocation Error in: %s %d",__FILE__,__LINE__); return (DBFault); } if (fread (docString,docLength,1,file) != 1) { CMmsgPrint (CMmsgSysError, "File Reading Error in: %s %d",__FILE__,__LINE__); return (DBFault); } data->Document (DBDocComment,docString); free (docString); } for (dataRec = (data->Arrays ())->First ();dataRec != (DBObjRecord *) NULL;dataRec = (data->Arrays ())->Next ()) if (fread (dataRec->Data (),ColNum () * valueSize * RowNum (),1,file) != 1) { CMmsgPrint (CMmsgSysError, "File Reading Error in: %s %d",__FILE__,__LINE__); return (DBFault); } if (swap && valueSize > 1) { int i; void (*swapFunc) (void *); switch (valueSize) { case 2: swapFunc = DBByteOrderSwapHalfWord; break; case 4: swapFunc = DBByteOrderSwapWord; break; case 8: swapFunc = DBByteOrderSwapLongWord; break; default: CMmsgPrint (CMmsgAppError, "Wrong Data Value Size in: %s %d",__FILE__,__LINE__); return (DBFault); } for (dataRec = (data->Arrays ())->First ();dataRec != (DBObjRecord *) NULL;dataRec = (data->Arrays ())->Next ()) for (i = 0;i < ColNum () * RowNum ();++i) (*swapFunc) ((char *) dataRec->Data () + i * valueSize); } switch (data->Type ()) { case DBTypeGridDiscrete: { DBInt value; char nameStr [DBStringLength]; DBObjRecord *symRec = (data->Table (DBrNSymbols))->Add ("Default Symbol"); DBObjRecord *itemRec; DBObjTableField *gridValueFLD = itemTable->Field (DBrNGridValue); DBObjTableField *gridSymbolFLD = itemTable->Field (DBrNSymbol); DBObjTableField *symbolIDFLD = (data->Table (DBrNSymbols))->Field (DBrNSymbolID); DBObjTableField *foregroundFLD = (data->Table (DBrNSymbols))->Field (DBrNForeground); DBObjTableField *backgroundFLD = (data->Table (DBrNSymbols))->Field (DBrNBackground); DBObjTableField *styleFLD = (data->Table (DBrNSymbols))->Field (DBrNStyle); symbolIDFLD->Int (symRec,0); foregroundFLD->Int (symRec,1); backgroundFLD->Int (symRec,0); styleFLD->Int (symRec,0); for (dataRec = (data->Arrays ())->First ();dataRec != (DBObjRecord *) NULL;dataRec = (data->Arrays ())->Next ()) { for (i = 0;i < ColNum () * RowNum ();++i) { switch (valueType) { case DBTableFieldFloat: value = (DBInt) rint (*((float *) ((char *) dataRec->Data () + i * valueSize))); break; case DBTableFieldInt: switch (valueSize) { case sizeof (DBByte): value = (DBInt) (*((DBByte *) ((char *) dataRec->Data () + i * valueSize))); break; case sizeof (DBShort): value = (DBInt) (*((DBShort *) ((char *) dataRec->Data () + i * valueSize))); break; case sizeof (DBInt): value = (DBInt) (*((DBInt *) ((char *) dataRec->Data () + i * valueSize))); break; default: CMmsgPrint (CMmsgAppError, "Wrong Data Size in: %s %d",__FILE__,__LINE__); return (DBFault); } break; default: CMmsgPrint (CMmsgAppError, "Wrong Data Type in: %s %d",__FILE__,__LINE__); return (DBFault); } sprintf (nameStr,"Category%04d",value); if ((itemRec = itemTable->Item (nameStr)) == (DBObjRecord *) NULL) { if ((itemRec = itemTable->Add (nameStr)) == (DBObjRecord *) NULL) { CMmsgPrint (CMmsgAppError, "Item Object Creation Error in: %s %d",__FILE__,__LINE__); return (DBFault); } gridValueFLD->Int (itemRec,value); gridSymbolFLD->Record (itemRec,symRec); } value = itemRec->RowID (); switch (valueSize) { case sizeof (DBByte): *((DBByte *) ((char *) dataRec->Data () + i * valueSize)) = value; break; case sizeof (DBShort): *((DBShort *) ((char *) dataRec->Data () + i * valueSize)) = value; break; case sizeof (DBInt): *((DBInt *) ((char *) dataRec->Data () + i * valueSize)) = value; break; default: CMmsgPrint (CMmsgAppError, "Wrong Data Size in: %s %d",__FILE__,__LINE__); return (DBFault); } } } itemTable->ListSort (gridValueFLD); for (dataRec = (data->Arrays ())->First ();dataRec != (DBObjRecord *) NULL;dataRec = (data->Arrays ())->Next ()) { for (i = 0;i < ColNum () * RowNum ();++i) { switch (valueSize) { case sizeof (DBByte): value = (DBInt) (*((DBByte *) ((char *) dataRec->Data () + i * valueSize))); break; case sizeof (DBShort): value = (DBInt) (*((DBShort *) ((char *) dataRec->Data () + i * valueSize))); break; case sizeof (DBInt): value = (DBInt) (*((DBInt *) ((char *) dataRec->Data () + i * valueSize))); break; default: CMmsgPrint (CMmsgAppError, "Wrong Data Size in: %s %d",__FILE__,__LINE__); return (DBFault); } itemRec = itemTable->Item (value); value = itemRec->ListPos (); switch (valueSize) { case sizeof (DBByte): *((DBByte *) ((char *) dataRec->Data () + i * valueSize)) = value; break; case sizeof (DBShort): *((DBShort *) ((char *) dataRec->Data () + i * valueSize)) = value; break; case sizeof (DBInt): *((DBInt *) ((char *) dataRec->Data () + i * valueSize)) = value; break; default: CMmsgPrint (CMmsgAppError, "Wrong Data Size in: %s %d",__FILE__,__LINE__); return (DBFault); } } } itemTable->ItemSort (); gridIF = new DBGridIF (data); gridIF->DiscreteStats (); delete gridIF; } break; case DBTypeGridContinuous: { DBObjTableField *missingValueFLD = itemTable->Field (DBrNMissingValue); for (dataRec = (data->Arrays ())->First ();dataRec != (DBObjRecord *) NULL;dataRec = (data->Arrays ())->Next ()) { itemTable->Add (dataRec->Name ()); missingValueFLD->Float (itemTable->Item (),MissingValue ()); } gridIF = new DBGridIF (data); gridIF->RecalcStats (); delete gridIF; data->Flags (DBDataFlagDispModeContBlueRed,DBSet); break; } default: break; } return (DBSuccess); }
//---------------------------------------------------------------------------------------------- BOOL FileManager::TraverseDirectory(LPTSTR parentPath, LPTSTR searchPattern, DWORD numFlags, LPBOOL flags, CHAR* filter, vector<string>& filePathes) /* Traverse a directory, carrying out an implementation specific "action" for every name encountered. The action in this version is "list, with optional attributes". */ /* searchPattern: Relative or absolute searchPattern to traverse in the parentPath. */ /* On entry, the current directory is parentPath, which ends in a \ */ { HANDLE searchHandle; WIN32_FIND_DATA findData; BOOL recursive = flags[0]; DWORD fType, iPass, lenParentPath; /* Open up the directory search handle and get the first file name to satisfy the path name. Make two passes. The first processes the files and the second processes the directories. */ if ( _tcslen(searchPattern) == 0 ) { _tcscat(searchPattern, _T("*")); } /* Remove a backslash, if any, at the end of the parent path */ if (parentPath[_tcslen(parentPath)-1] != _T('\\') ) { /* Add a \ to the end of the parent path, unless there already is one */ _tcscat (parentPath, _T("\\")); } /* Open up the directory search handle and get the first file name to satisfy the path name. Make two passes. The first processes the files and the second processes the directories. */ CHAR* szDirct = (CHAR*)malloc(MAX_PATH); GetCurrentDirectory(MAX_PATH, szDirct); for (iPass = 1; iPass <= 2; iPass++) { searchHandle = FindFirstFile("*", &findData); if (searchHandle == INVALID_HANDLE_VALUE) { std::cerr << "Error opening Search Handle."; return FALSE; } /* Scan the directory and its subdirectories for files satisfying the pattern. */ do { /* For each file located, get the type. List everything on pass 1. On pass 2, display the directory name and recursively process the subdirectory contents, if the recursive option is set. */ fType = FileType(&findData); if (iPass == 1) /* ProcessItem is "print attributes". */ { if (CompareExtension(findData.cFileName, filter)) { string filePath = currPath; filePath += findData.cFileName; filePathes.push_back(filePath); } } lenParentPath = (DWORD)_tcslen(parentPath); /* Traverse the subdirectory on the second pass. */ if (fType == TYPE_DIR && iPass == 2 && recursive) { _tprintf(_T("\n%s%s:"), parentPath, findData.cFileName); SetCurrentDirectory(findData.cFileName); if (_tcslen(parentPath) + _tcslen(findData.cFileName) >= MAX_PATH_LONG-1) { std::cerr << "Path Name is too long"; } _tcscat (parentPath, findData.cFileName); /* The parent path terminates with \ before the _tcscat call */ TraverseDirectory(parentPath, _T("*"), numFlags, flags, filter, filePathes); /* Restore parent path - It will then terminate with \ */ parentPath[lenParentPath] = _T('\0'); SetCurrentDirectory(parentPath); /* SetCurrentDirectory(_T("..")); would also work */ } /* Get the next file or directory name. */ } while (FindNextFile(searchHandle, &findData)); FindClose(searchHandle); } return TRUE; }