void Decryptor::empty() {
if (outFile.good()) {
outFile.close();
}
if (inFile.good()) {
inFile.close();
}
}
bool JobClass::LoadJobFile(fstream &JobStream)
{
const vector <string> TheTagWords = InitTagWords();
string FileLine = "";
FileLine = ReadNoComments(JobStream);
while (JobStream.good() && !FoundStartTag(FileLine, TheTagWords[0])) // Job
{
FileLine = ReadNoComments(JobStream);
}
FileLine = ReadNoComments(JobStream);
bool BadObject = false;
while (JobStream.good() && !FoundEndTag(FileLine, TheTagWords[0])) // Job
{
if (!BadObject)
{
if (FoundStartTag(FileLine, TheTagWords[1])) // Volume
{
FileLine = ReadNoComments(JobStream);
VolumeClass TempVolume;
VolID_t VolumeID = TempVolume.ReadJobInfo(FileLine, JobStream);
if (!TempVolume.ValidConfig())
{
cerr << "Problem in JobClass object... Bad Volume..." << endl;
BadObject = true;
}
else
{
AddVolume(VolumeID, TempVolume);
}
}
else
{
cerr << "Unknown tags in JobClass object... Here is the line: " << FileLine << endl;
BadObject = true;
}
}
FileLine = ReadNoComments(JobStream);
}
if (JobStream.eof())
{
cerr << "Early end reading job file." << endl;
}
myIsConfigured = !BadObject;
return(myIsConfigured);
}
void second_pass(){
reset();
myReadFile.open(FILE_NAME,ios::in | ios::out);
if(myReadFile.good() && !myReadFile.eof()){
getNextTokens();
cout << "Memory Map" << endl;
while (!tokens.empty()) {
defListRead(true);
useListRead(true);
programTextRead(true);
useList.clear();
}
//Warning messages
for(vector<string>::iterator it = symbols.begin() ; it != symbols.end() ; ++it){
if ((useListSymbols.count(*it) > 0)){
if (useListSymbols[*it].second == 0){
cout << "Warning: Module " << symDefModuleNum[*it]<< ": " << *it << " was defined but never used " << endl;
}
}
else{
cout << "Warning: Module " << symDefModuleNum[*it]<< ": " << *it << " was defined but never used " << endl;
}
}
myReadFile.close();
}
}
void first_pass(){
string multipleDefinitions = "Error: This variable is multiple times defined; first value used";
myReadFile.open(FILE_NAME,ios::in | ios::out);
if(myReadFile.good() && !myReadFile.eof()){
getNextTokens();
while (!tokens.empty()) {
defListRead(false);
useListRead(false);
programTextRead(false);
useList.clear();
}
vector<string>::iterator it;
cout << "Symbol Table" << endl;
// cout << symbols.front() << endl;
for(it=symbols.begin() ; it < symbols.end(); it++) {
cout << *it << "=" <<symbolTable[*it].first;
if (symbolTable[*it].second == 1){
cout <<" "<< multipleDefinitions;
}
cout << endl;
}
tokens.clear();
cout << endl;
}
myReadFile.close();
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
// InterpolationFunction
//--------------------------------------------------------------------
//--------------------------------------------------------------------
void InterpolationFunction::initialize(int npts, fstream &fileId, double coef)
{ // read data
npts_ = npts;
xs_.reset(npts);
fs_.reset(npts);
fps_.reset(npts);
double x,f,fp;
int i = 0;
while(fileId.good() && i < npts) {
fileId >> x >> f >> fp;
xs_(i)=x;
fs_(i)=coef*f;
fps_(i)=coef*fp;
i++;
}
// scale tangents
double dx, dx0 = xs_(1)-xs_(0);
for (int i = 0; i < npts_ ; i++) {
if (i == 0) { dx = xs_(1)-xs_(0); }
else if (i+1 == npts_) { dx = xs_(npts_-1)-xs_(npts_-2); }
else { dx= 0.5*(xs_(i+1)-xs_(i-1)); }
if (abs(dx-dx0) > 1.e-8) throw ATC_Error("InterpolationFunction::initialize non-uniform data spacing not handled currently");
fps_(i) *= dx;
}
// options: calculate / adjust tangents for monotonicity
}
Boolean PrimesTable::TableBuffer::RetrieveBlock(Ulong Index_, long Offset_, fstream& Fin_)
{
Ulong BlockNum_ = Index_ / PrimesTable::TABLESIZE;
Fin_.seekg(0, ios::end);
Fin_.clear();
long StartPos_ = BlockNum_ * TABLESIZE * sizeof(long);
long Fsize_ = Fin_.tellg();
Fsize_ -= Offset_;
if (StartPos_ < Fsize_)
if (Fin_.seekg(StartPos_ + Offset_).good())
{
Fin_.read((char*)_Table, TABLESIZE * sizeof(long));
size_t i;
long BufSize_ = TABLESIZE;
for (i = TABLESIZE - 1; i != size_t(-1); --i)
if (!_Table[i])
--BufSize_;
else
break;
if (BufSize_)
{
StartPos_ /= sizeof(long);
SetLimit(StartPos_, BufSize_);
return Fin_.good();
}
}
return FALSE;
}
ElectronPhononExchangeHertel::ElectronPhononExchangeHertel(fstream &fileId,
map<string,double> & parameters,
Material * material)
: ElectronPhononExchange(),
exchangeCoef_(0),
debeyeTemperature_(1),
massEnhancement_(0),
material_(material)
{
if (!fileId.is_open()) throw ATC_Error("cannot open material file");
vector<string> line;
while(fileId.good()) {
command_line(fileId, line);
if (line.size() == 0) continue;
if (line[0] == "end") break;
else if (line[0] == "debeye_temperature") {
debeyeTemperature_ = str2dbl(line[1]);
parameters["debeye_temperature"] = debeyeTemperature_;
}
else if (line[0] == "mass_enhancement") {
massEnhancement_ = str2dbl(line[1]);
parameters["mass_enhancement"] = massEnhancement_;
}
else {
throw ATC_Error( "unrecognized material function "+line[0]);
}
}
// coupling coefficient, eqn. 15 of Hertel 2002
double kb = LammpsInterface::instance()->kBoltzmann();
double hbar = LammpsInterface::instance()->hbar();
double PI = 3.141592653589793238;
exchangeCoef_ = 144.*1.0369*kb/(PI*hbar);
exchangeCoef_ *= massEnhancement_/pow(debeyeTemperature_,2);
}
// return nabber of filled objects
int fillFromFile(fstream & fin, employee ** pArr, int nSize)
{
int id;
int i = 0;
while (i < nSize && fin.good() && fin.peek() != EOF)
{
fin >> id;
switch(id)
{
case abstr_emp::EMPLOYEE:
pArr[i] = new employee;
break;
case abstr_emp::MANAGER:
pArr[i] = new manager;
break;
case abstr_emp::FINK:
pArr[i] = new fink;
break;
case abstr_emp::HIGHFINK:
pArr[i] = new highfink;
break;
default:
throw "Error while reading file";
}
fin.get(); // '\n'
pArr[i]->GetAll(fin);
i++;
}
fin.clear();
return i;
}
int main(int argc, char *argv[ ])
{
float CPU_time, StartTime;
string buffer;
ListNode *p;
extern int unique;
//cout << " Purge Program v1.1" << endl;
init(argc, argv);
StartTime = (float) clock( );
/*if(OverWrite)
cout << " Processing input file ... " << flush;
else
cout << " Creating output file ... " << flush;*/
while(!fin.eof( ))
{
fin >> buffer;
if(fin.good( ))
{
entries++;
insert(buffer);
}
//if(entries % 1000 == 0)
// cout << "\b\b\b\b\b\b\b" << setw(7) << entries << flush;
}
//cout << "\b\b\b\b\b\b\b" << setw(7) << entries << endl;
if(OverWrite)
if(duplicates == 0)
cout << " File did not contain duplicates and was not overwritten" << endl;
else
{
fin.close( );
fout.open(argv[1], ios::out);
if(!fout)
{
cout << " Can not open [" << argv[1] << "] as the output file" << endl;
exit(1);
}
cout << " Writing unique entries back to source file ... " << endl;
p = head;
while(p != sentinel)
{
fout << p->entry << endl;
p = p->link;
}
}
cout << " [" << entries << "] entries in file, [" << duplicates << "] duplicates, [" << unique << "] unique entries" << endl;
CPU_time = (float) clock( ) - StartTime;
if(CPU_time < 1000.0)
cout << " CPU time: [" << CPU_time << "] milliseconds" << endl;
else
cout << " CPU time: [" << CPU_time/1000.0 << "] seconds" << endl;
return 0;
}
void showState(fstream &file)
{
cout << "File Status:\n";
cout << " eof bit: " << file.eof() << endl;
cout << " fail bit: " << file.fail() << endl;
cout << " bad bit: " << file.bad() << endl;
cout << " good bit: " << file.good() << endl;
file.clear(); // Clear any bad bits
}
void search(){
//std::cout << "search start" << endl;
int stl, n=0;
string str, str2;
while(ifs.good()){
int i,j=0;
getline(ifs, str);
stl = str.length();
str2 = str;
transform(str.begin(), str.end(), str.begin(), ::tolower); //全部 小文字に
/*int h,rep = 0;
for(int m=0;m <= stl; m++){
if(str[m] == 0x27){
rep = 1;
h=m;
break;
}
}
if(rep == 1){
str.replace(h,1,"");
stl= stl - 1;
}*/
sort(str.begin(), str.end()); //abc順に
for(i=0; i<16; i++){
if(str[j] == table[i]){
j++;
}
/*if(j == stl){
break;
}*/
}
if((j==stl) && (n < stl)){
//cout << str2 << endl;
answer = str2;
n = stl;
}
}
}
void wczytajWezly() {
plik.open( "plik.txt", ios::in | ios::out );
if(plik.good()==true) {
float temp;
for(int i=0;i<rozmiar;i++) {
for(int j=0;j<i+2;j++) {
plik >> temp;
wezly[i].push_back(temp);
}
}
plik.close();
}
int addNewEmployees(fstream & fout, employee ** pArr, int nSize)
{
int i = 0;
char choice;
while (i < nSize && fout.good())
{
cout << "Wich character you want to create: \n"
<< "1: employee 2: manager" << endl
<< "3: fink 4: highfink" << endl
<< "q: quit" << endl
<< ">";
cin >> choice;
while (strchr("1234q", choice) == NULL)
{
cout << "Please enter 1, 2, 3, 4 or q: ";
cin >> choice;
}
cin.ignore(cin.rdbuf()->in_avail());
if (choice == 'q')
break;
switch(choice)
{
case '1':
pArr[i] = new employee;
fout << abstr_emp::EMPLOYEE << endl; // mark obj type in file
break;
case '2':
pArr[i] = new manager;
fout << abstr_emp::MANAGER << endl;
break;
case '3':
pArr[i] = new fink;
fout << abstr_emp::FINK << endl;
break;
case '4':
pArr[i] = new highfink;
fout << abstr_emp::HIGHFINK << endl;
break;
}
pArr[i]->SetAll();
pArr[i]->WriteAll(fout);
cout << endl;
i++;
}
return i;
}
/************************************************************************
* Maintainence and Administrative *
************************************************************************/
bool JobClass::WriteJobFile(fstream &JobStream) const
{
const vector <string> TheTagWords = InitTagWords();
JobStream << "<" << TheTagWords[0] << ">\n";
for (VolumeIter_Const AVol = myVolumes.begin(); AVol != myVolumes.end(); AVol++)
{
AVol->second.WriteJobList(AVol->first, JobStream);
}
JobStream << "</" << TheTagWords[0] << ">\n";
JobStream.flush(); // makes sure everything has been written
return(JobStream.good());
}
int check_flags(const fstream& fh)
{
int status = 0;
//cout << "file is:\n";
if (fh.good())
status+=16;
if (fh.bad())
status+=2;
if (fh.fail())
status+=4;
if (fh.eof())
status+=8;
if (0 == status)
status = -1;
return status;
}
void VectorRead4(fstream& saveFile,vector<T>& items){
unsigned int numberofItems = 0;
saveFile.read((char *) &numberofItems,4);
items.clear();
if(numberofItems){
items.reserve(numberofItems);
for(unsigned int i=0;i<numberofItems;i++){
if(!saveFile.good()){
cerr << "Error in void VectorRead(fstream& saveFile,vector<T> aVector,int version)" << endl;
cerr << "FileStream is not good" << endl;
exit(1);
}
T anItem;
saveFile.read((char *) &anItem,4);
items.push_back(anItem);
}
}
}
ElectronHeatCapacityLinear::ElectronHeatCapacityLinear(
fstream &fileId, map<string,double> & parameters)
: ElectronHeatCapacity(),
electronHeatCapacity_(0)
{
if (!fileId.is_open()) throw ATC_Error(0,"cannot open material file");
vector<string> line;
while(fileId.good()) {
get_command_line(fileId, line);
if (line.size() == 0) continue;
if (line[0] == "end") return;
else if (line[0] == "capacity") {
electronHeatCapacity_ = str2dbl(line[1]);
parameters["electron_heat_capacity"] = electronHeatCapacity_;
}
else {
throw ATC_Error(0, "unrecognized material function: " + line[0]);
}
}
}
ElectronPhononExchangeLinear::ElectronPhononExchangeLinear(
fstream &fileId, map<string,double> & parameters)
: ElectronPhononExchange(),
exchangeCoef_(0)
{
if (!fileId.is_open()) throw ATC_Error("cannot open material file");
vector<string> line;
while(fileId.good()) {
command_line(fileId, line);
if (line.size() == 0) continue;
if (line[0] == "end") return;
else if (line[0] == "coefficient") {
exchangeCoef_ = str2dbl(line[1]);
parameters["electron_phonon_exchange_coefficient"] = exchangeCoef_;
}
else {
throw ATC_Error( "unrecognized material function "+line[0]);
}
}
}
// ==================================================================================================
bool c4s::search_file(fstream &target, const string &needle)
/*! Uses Boyer-Moore algorithm to search for a text in a given stream. Stream needs to be
opened before this function is called. Search begins from the current position. If match is found
the file pointer is positioned to the start of the next needle.
On error an exception is thrown.
\param target Opened file stream to search for.
\param needle String that should be found
\retval bool True if needle was found, false if not.
*/
{
const SIZE_T BMAX = 0x1000;
char buffer[BMAX];
streamsize tg;
SIZE_T br, boffset, total_offset, overlap=0;
SIZE_T nsize = needle.size();
if(!target.good())
throw c4s_exception("search_file: given stream does not have 'good' status.");
if(nsize >= BMAX)
throw c4s_exception("search_file: size of search text exceeds internal read buffer size.");
tg = target.tellg();
if(tg<0)
throw c4s_exception("search_file: unable to get file position information.");
total_offset = SIZE_T(tg);
do {
target.read(buffer+overlap,BMAX-overlap);
br = SIZE_T(target.gcount());
if(search_bmh((unsigned char*)buffer, br+overlap, (unsigned char*)needle.c_str(), nsize, &boffset)) {
target.clear();
target.seekg(total_offset+boffset,ios_base::beg);
return true;
}
total_offset += br;
memcpy(buffer, buffer+BMAX-nsize, nsize);
if(!overlap) {
overlap = nsize;
total_offset -= nsize;
}
}while(!target.eof());
return false;
}
int main(int argc, char* argv[]) {
//Determine the number of threads to use
if (USE_MULTIPLE_THREADS) {
SYSTEM_INFO SysInfo;
GetSystemInfo(&SysInfo);
NumThreads = SysInfo.dwNumberOfProcessors;
if (NumThreads > MAXTHREADS)
NumThreads = MAXTHREADS;
} else
NumThreads = 1;
string resultFileName =
"wynik_" + TEST_NAME + "_" + to_string(NSIZE) + "_"
+ to_string(RSIZE) + "_" + to_string(NumThreads) + ".txt";
fileStream.open(resultFileName, std::ios::out | std::ios::trunc);
if (!fileStream.good()) {
fprintf(stderr, "Nie mozna otworzyc pliku wyniku %s\n", resultFileName);
}
fileStream << "File: " << resultFileName << "\n";
printf("%s\n\n", resultFileName);
initialize_matrices();
multiply_matrices_IJK_sequence();
start = (double)clock() / CLK_TCK;
multiply_matrices_JKI();
print_elapsed_time("JKI3");
initialize_matricesZ();
multiply_matrices_IJK_sequence();
start = (double)clock() / CLK_TCK;
multiply_matrices_IJK6();
print_elapsed_time("IJK6");
fileStream.close();
system("PAUSE");
return(0);
}
//(TABLICA -> PLIK) Definicja funkcji zapisującej dane z tablicy do pliku "studenci.dat"
void zapiszTabliceDoPliku(string FILE_NAME, Student *tablica, int liczbaStruktur){
studenci.open(FILE_NAME, ios::out);
//Sprawdzenie czy plik został otwarty poprawnie
if (studenci.good() == true) {
//Pętla wczytująca i zapisująca w pliku "studenci.dat" imiona i nazwiska studentów (oprócz ostatniego wpisu) - z znakiem nowej linii "\n" na końcu
for (int i = 0; i < (liczbaStruktur - 1); i++){
//Zapisanie z struktur imion i nazwisk do pliku "studenci.dat"
studenci << tablica[i].imie << " " << tablica[i].nazwisko << " " << tablica[i].rokStudiow << "\n";
}
//Dodanie ostatniego wpisu (bez znaku nowej linii \n")
studenci << tablica[liczbaStruktur - 1].imie << " " << tablica[liczbaStruktur - 1].nazwisko << " " << tablica[liczbaStruktur - 1].rokStudiow;
//Zamknięcie pliku "studenci.dat" otwartego w trybie "wyjście/zapis"
studenci.close();
}
//Usunięcie tablicy
delete[] tablica;
}
//(PLIK -> TABLICA) Definicja funkcji wczytującej informacje o studentach z pliku "studenci.dat" do tablicy;
tuple<Student *, int> wczytajPlikDoTablicy(string FILE_NAME){
//Otworzenie pliku "studenci.dat" w trybie "wejście/odczyt"
studenci.open(FILE_NAME, ios::in);
//Sprawdzenie czy plik został otwarty poprawnie
if (studenci.good() == true) {
int liczbaStruktur = 0;
string linia;
//Pętla zliczająca liczbę linii - rekordów
while (getline(studenci, linia)) {
liczbaStruktur++;
}
//Powrót do początku pliku tekstowego
studenci.clear();
studenci.seekg(0, ios::beg);
//Utworzenie tablicy o zadanej liczbie struktur typu student
Student *tablica = new Student[liczbaStruktur];
//Pętla zapisująca dane z pliku do struktur;
int i = 0;
while (!studenci.eof()) {
studenci >> tablica[i].imie >> tablica[i].nazwisko >> tablica[i].rokStudiow;
i++;
}
//Zamknięcie pliku "studenci.dat" otwartego w trybie "wejście/odczyt"
studenci.close();
//Funkcja zwraca dwa wyniki: tablicę z danymi oraz jej wielkość;
return make_tuple((Student *)tablica, liczbaStruktur);
}
//When called in a loop, implements end-host send file functionality
void hostTryToSend(void) {
static enum {
STATE_LOOKFORFILE,
STATE_FOUNDFILE,
STATE_SENDPACKET,
STATE_TRYAGAIN,
STATE_FINISHED,
STATE_IDLE
} state = STATE_LOOKFORFILE;
static fstream sendFile;
static u_int32_t destIP;
static u_int16_t srcPort, destPort;
static u_int8_t buffer[PAYLOAD_LEN] = "";
static int bufLen;
static u_int16_t sequence = 0; //host byte order
static int totalBytes = 0;
char tempDestIP[32] = "";
int sendResult;
switch(state) {
case STATE_LOOKFORFILE:
sendFile.open("send.txt", fstream::in);
if(sendFile.is_open()) {
state = STATE_FOUNDFILE;
}
else {
break;
}
case STATE_FOUNDFILE:
sendFile.getline((char*)buffer, PAYLOAD_LEN-1);
sscanf((char*)buffer, "%s %hu %hu", tempDestIP, &srcPort, &destPort);
destIP = strIPtoBin(tempDestIP);
srcPort = htons(srcPort);
destPort = htons(destPort);
state = STATE_SENDPACKET;
case STATE_SENDPACKET:
if(sendFile.good()) {
bufLen = 0;
memset(buffer, 0, PAYLOAD_LEN);
sendFile.read((char*)buffer, PAYLOAD_LEN);
bufLen = sendFile.gcount();
sendResult = hostSendPacket(buffer, bufLen, destIP, srcPort, destPort, htons(sequence));
if(sendResult == 0) {
state = STATE_TRYAGAIN;
}
else {
totalBytes += bufLen;
sequence++;
}
}
else {
state = STATE_FINISHED;
}
break;
case STATE_TRYAGAIN:
sendResult = hostSendPacket(buffer, bufLen, destIP, srcPort, destPort, htons(sequence));
if(sendResult == 1) {
sequence++;
totalBytes += bufLen;
state = STATE_SENDPACKET;
}
break;
case STATE_FINISHED:
cout<<"File transmitted."<<endl
<<"Size: "<<totalBytes<<" bytes."<<endl
<<"Packets trasmitted: "<<sequence<<endl;
state = STATE_IDLE;
break;
case STATE_IDLE:
break;
}
}
void clGeometryReader::ReadGeometry(fstream &file, clGeometry &geometry) const
{
int numberSurfaces = 0;
int EndOfBlock = 0;
// Read line
char line[LINE_SIZE];
file.getline(line, LINE_SIZE);
while(!file.eof() && file.good() && !EndOfBlock)
{
// Check first character in trimmed line
switch(*strtrim(line))
{
case '#':
case '*':
// Comment line
file.getline(line, LINE_SIZE);
break;
case '$':
case '&':
{
// Block specifier
int blockCommand = GetBlockSpec(line);
switch(blockCommand)
{
case UNKNOWN_SPEC:
throw clExceptionTree("clGeometryReader", "ReadGeometry", "Unknown block specifier.");
break;
case POINT_SPEC:
// Start of point block
throw clExceptionTree("clGeometryReader", "ReadGeometry", "Unexpected start of block POINT.");
break;
case PATCH_SPEC:
// Start of patch block
throw clExceptionTree("clGeometryReader", "ReadGeometry", "Unexpected start of block PATCH.");
break;
case SURFACE_SPEC:
{
// Start of surface block
clSurface *surface = new clSurface(numberSurfaces++);
ReadSurface(file, *surface);
geometry.AddSurface(surface);
file.getline(line, LINE_SIZE);
break;
}
case GEOMETRY_SPEC:
// Start of geometry block
throw clExceptionTree("clGeometryReader", "ReadGeometry", "Unexpected start of block GEOMETRY.");
break;
case END_SPEC:
// End of geometry block specification
EndOfBlock = 1;
break;
default:
throw clExceptionTree("clGeometryReader", "ReadGeometry", "Function GetBlockSpec returned unknown value.");
break;
}
break;
}
case '/':
// End of geometry block specification
EndOfBlock = 1;
break;
default:
file.getline(line, LINE_SIZE);
break;
}
}
}
void clGeometryReader::ReadSurface(fstream &file, clSurface &surface) const
{
int EndOfBlock = 0;
// Read line
char line[LINE_SIZE];
file.getline(line, LINE_SIZE);
while(!file.eof() && file.good() && !EndOfBlock)
{
// Check first character in trimmed line
switch(*strtrim(line))
{
case '#':
case '*':
// Comment line
file.getline(line, LINE_SIZE);
break;
case '$':
case '&':
{
// Block specifier
int blockCommand = GetBlockSpec(line);
switch(blockCommand)
{
case UNKNOWN_SPEC:
throw clExceptionTree("clGeometryReader", "ReadSurface", "Unknown block specifier.");
break;
case POINT_SPEC:
{
// Start of point block
dMatrix pointsX, pointsY, pointsZ;
ReadPoints(file, pointsX, pointsY, pointsZ);
surface.CreatePatches(pointsX, pointsY, pointsZ);
file.getline(line, LINE_SIZE);
break;
}
case PATCH_SPEC:
{
// Start of patch block
clPatch *patch = new clPatch;
ReadPatch(file, *patch);
surface.AddPatch(patch);
file.getline(line, LINE_SIZE);
break;
}
case SURFACE_SPEC:
// Start of surface block
throw clExceptionTree("clGeometryReader", "ReadSurface", "Unexpected start of block SURFACE.");
break;
case GEOMETRY_SPEC:
// Start of geometry block
throw clExceptionTree("clGeometryReader", "ReadSurface", "Unexpected start of block GEOMETRY.");
break;
case END_SPEC:
// End of geometry block specification
EndOfBlock = 1;
break;
default:
throw clExceptionTree("clGeometryReader", "ReadSurface", "Function GetBlockSpec returned unknown value.");
break;
}
break;
}
case '/':
// End of geometry block specification
EndOfBlock = 1;
break;
default:
file.getline(line, LINE_SIZE);
break;
}
}
}
void clGeometryReader::ReadPoints(fstream &file, dMatrix &pointsX, dMatrix &pointsY, dMatrix &pointsZ) const
{
int EndOfBlock;
int AllRead;
char line[LINE_SIZE];
char *ptrLine = line;
const char *tkn = " ;:";
int countData;
int rmax = 0;
int cmax = 0;
// Read line
file.getline(line, LINE_SIZE);
EndOfBlock = 0;
AllRead = 0;
countData = 0;
while(!file.eof() && file.good() && !EndOfBlock)
{
// Check first character in trimmed line
switch(*strtrim(line))
{
case '#':
case '*':
// Comment line, read next line
file.getline(line, LINE_SIZE);
break;
case '&':
case '$':
{
// Block specifier
int blockCommand = GetBlockSpec(line);
switch(blockCommand)
{
case UNKNOWN_SPEC:
throw clExceptionTree("clGeometryReader", "ReadPoints", "Unknown block specifier.");
break;
case POINT_SPEC:
throw clExceptionTree("clGeometryReader", "ReadPoints", "Unexpected start of block POINT.");
break;
case PATCH_SPEC:
throw clExceptionTree("clGeometryReader", "ReadPoints", "Unexpected start of block PATCH.");
break;
case SURFACE_SPEC:
throw clExceptionTree("clGeometryReader", "ReadPoints", "Unexpected start of block SURFACE.");
break;
case GEOMETRY_SPEC:
throw clExceptionTree("clGeometryReader", "ReadPoints", "Unexpected start of block GEOMETRY.");
break;
case END_SPEC:
EndOfBlock = 1;
break;
default:
throw clExceptionTree("clGeometryReader", "ReadPoints", "Function GetBlockSpec returned unknown value.");
break;
}
break;
}
case '/':
// End of block specifier
EndOfBlock = 1;
break;
default:
if(strlen(strtrim(line)) > 0)
{
// Data line
countData++;
// Matrix specifiers
if(countData==1)
{
// column defines constant u-values
ptrLine = strtok(line, tkn);
cmax = str2int(ptrLine);
// row defines constant v-values
ptrLine = strtok(NULL, tkn);
rmax = str2int(ptrLine);
// Set matrix dimensions
pointsX.SetNumberRows(rmax);
pointsX.SetNumberColumns(cmax);
pointsY.SetNumberRows(rmax);
pointsY.SetNumberColumns(cmax);
pointsZ.SetNumberRows(rmax);
pointsZ.SetNumberColumns(cmax);
}
// Specification of the x-coordinates
else if(countData>=2 && countData<(2+rmax))
{
int row = (countData-1);
// Set first u-element in current v
ptrLine = strtok(line, tkn);
pointsX.SetElement(row, 1, str2double(ptrLine));
// Set following u-elements in current v
for(int c=2; c<=cmax; c++)
{
ptrLine = strtok(0, tkn);
pointsX.SetElement(row, c, str2double(ptrLine));
}
}
// Specification of the y-coordinates
else if(countData>=(2+rmax) && countData<(2+rmax+rmax))
{
int row = (countData-1-rmax);
// Set first u-element in current v
ptrLine = strtok(line, tkn);
pointsY.SetElement(row, 1, str2double(ptrLine));
// Set following u-elements in current v
for(int c=2; c<=cmax; c++)
{
ptrLine = strtok(0, tkn);
pointsY.SetElement(row, c, str2double(ptrLine));
}
}
// Specification of the z-coordinates
else if(countData>=(2+rmax+rmax) && countData<(2+rmax+rmax+rmax))
{
int row = (countData-1-rmax-rmax);
// Set first u-element in current v
ptrLine = strtok(line, tkn);
pointsZ.SetElement(row, 1, str2double(ptrLine));
// Set following u-elements in current v
for(int c=2; c<=cmax; c++)
{
ptrLine = strtok(0, tkn);
pointsZ.SetElement(row, c, str2double(ptrLine));
}
}
// Too much data
else
{
throw clExceptionTree("clGeometryReader", "ReadPoints", "Too much data.");
}
if(countData==(1+rmax+rmax+rmax))
{
AllRead = 1;
}
}
file.getline(line, LINE_SIZE);
break;
}
}
if(!EndOfBlock || !AllRead)
{
throw clExceptionTree("clGeometryReader", "ReadPoints", "Unexpected end while reading block POINT.");
}
}
void clGeometryReader::ReadPatch(fstream &file, clPatch &patch) const
{
int EndOfBlock;
int AllRead;
char line[LINE_SIZE];
char *ptrLine = line;
const char *tkn = " ;:";
int countData;
int ID = 0;
char type = 'B';
dMatrix GX(4, 4);
dMatrix GY(4, 4);
dMatrix GZ(4, 4);
// Read line
file.getline(line, LINE_SIZE);
EndOfBlock = 0;
AllRead = 0;
countData = 0;
while(!file.eof() && file.good() && !EndOfBlock)
{
// Check first character in trimmed line
switch(*strtrim(line))
{
case '#':
case '*':
// Comment line
file.getline(line, LINE_SIZE);
break;
case '&':
case '$':
{
// Block specifier
int blockCommand = GetBlockSpec(line);
switch(blockCommand)
{
case UNKNOWN_SPEC:
throw clExceptionTree("clGeometryReader", "ReadPatch", "Unknown block specifier.");
break;
case PATCH_SPEC:
throw clExceptionTree("clGeometryReader", "ReadPatch", "Unexpected start of block PATCH.");
break;
case SURFACE_SPEC:
throw clExceptionTree("clGeometryReader", "ReadPatch", "Unexpected start of block SURFACE.");
break;
case GEOMETRY_SPEC:
throw clExceptionTree("clGeometryReader", "ReadPatch", "Unexpected start of block GEOMETRY.");
break;
case END_SPEC:
EndOfBlock = 1;
break;
default:
throw clExceptionTree("clGeometryReader", "ReadPatch", "Function GetBlockSpec returned unknown value.");
break;
}
break;
}
case '/':
// End of block specifier
EndOfBlock = 1;
break;
default:
if(strlen(strtrim(line)) > 0)
{
// Data line
countData++;
switch(countData)
{
// ID Number
case 1:
ID = str2int(line);
AllRead = 0;
break;
// blendType
case 2:
if(chrloc('H', line) != -1)
{
type = 'H';
}
else if(chrloc('B', line) != -1)
{
type = 'B';
}
else
{
throw clExceptionTree("clGeometryReader", "ReadPatch", "Unknown blending type.");
}
break;
// Matrix GX
case 3:
case 4:
case 5:
case 6:
ptrLine = strtok(line, tkn);
GX.SetElement(countData-2, 1, str2double(ptrLine));
ptrLine = strtok(0, tkn);
GX.SetElement(countData-2, 2, str2double(ptrLine));
ptrLine = strtok(0, tkn);
GX.SetElement(countData-2, 3, str2double(ptrLine));
ptrLine = strtok(0, tkn);
GX.SetElement(countData-2, 4, str2double(ptrLine));
break;
// Matrix GY
case 7:
case 8:
case 9:
case 10:
ptrLine = strtok(line, tkn);
GY.SetElement(countData-6, 1, str2double(ptrLine));
ptrLine = strtok(0, tkn);
GY.SetElement(countData-6, 2, str2double(ptrLine));
ptrLine = strtok(0, tkn);
GY.SetElement(countData-6, 3, str2double(ptrLine));
ptrLine = strtok(0, tkn);
GY.SetElement(countData-6, 4, str2double(ptrLine));
break;
// Matrix GZ
case 11:
case 12:
case 13:
case 14:
ptrLine = strtok(line, tkn);
GZ.SetElement(countData-10, 1, str2double(ptrLine));
ptrLine = strtok(0, tkn);
GZ.SetElement(countData-10, 2, str2double(ptrLine));
ptrLine = strtok(0, tkn);
GZ.SetElement(countData-10, 3, str2double(ptrLine));
ptrLine = strtok(0, tkn);
GZ.SetElement(countData-10, 4, str2double(ptrLine));
if(countData == 14)
{
AllRead = 1;
// Correct for right hand axis system when type is Bezier
if(type=='B')
{
GX.Transpose(); GX.MirrorColumns();
GY.Transpose(); GY.MirrorColumns();
GZ.Transpose(); GZ.MirrorColumns();
}
// Now create the patch
patch.SetNumberID(ID);
patch.SetGX(GX);
patch.SetGY(GY);
patch.SetGZ(GZ);
patch.SetBlendType(type);
}
break;
// Error
default:
throw clExceptionTree("clGeometryReader", "ReadPatch", "Wrong number of data lines.");
break;
}
}
file.getline(line, LINE_SIZE);
break;
}
}
if(!EndOfBlock || !AllRead)
{
throw clExceptionTree("clGeometryReader", "ReadPatch", "Unexpected end while reading block PATCH.");
}
}
//*********************************************************************
// FUNCTION: OpenInputFile
// DESCRIPTION: Open the input text file.
// INPUT:
// Parameters:
// std::string filename - Path to the input file.
// std::fstream file - The file object to use when opening the
// input file.
// OUTPUT:
// Return Val: Boolean indicating success of the file open
// operation.
// Parameters:
// std::fstream file - Initialized with the input file open on
// success.
// PERFORMANCE: f(n) = k
//**********************************************************************
bool OpenInputFile(string filename, fstream& file) {
file.open(filename.c_str(), fstream::in);
return(file.good());
} // OpenInputFile
bool Broken() override { return !iofile.good(); }
bool operator()() {
return file.good();
}
