//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;
}
