Exemplo n.º 1
0
RecordList
PhoneBook::searchByName(const string & name)
{
    Iter i = _records.begin(), j;
    RecordList ret;
    while ((j=searchName(name, i++)) != _records.end())
        ret.push_back(*j);
    return ret;
}
void pa5functions::ReadInputFile( const char* inputFile,
                                  RecordList& recordList ){
    // File validation
    std::fstream fin( inputFile );
    if( !fin ){
        throw pa5_exception( "Invalid input file." );
    }

    // Parse the file line by line and tokenize
    std::string currentLine;
    std::list<std::string> currentTokens;
    std::list<std::string>::iterator tokenIter;
    while( !fin.eof() ){
        currentLine.clear();
        currentTokens.clear();

        getline( fin, currentLine );
        // Handle poorly formed, but not invalid input input
        if( currentLine.size() == 0 ){
            continue;
        }
        TokenizeString( currentLine, currentTokens, ',' );
        if( currentTokens.size() != 3 ){
            throw pa5_exception( "Invalid input file - format or data error." );
        }

        tokenIter = currentTokens.begin();
        StudentRecord record;
        record.name      = *(tokenIter);
        record.ssn       = *(++tokenIter);
        record.testScore = atoi((*(++tokenIter)).c_str());

        // Normalize string length.
        record.name = record.name.substr(0,12);
        record.ssn = record.ssn.substr(0,9);

        recordList.push_back( record );
    }
    fin.close();
}
Exemplo n.º 3
0
//---------------------------------------------------------------------------
void BinexReadWriteTest::process()
   throw()
{
   if (verboseLevel > 0)
   {
      cout << "Creating BINEX records . . ." << endl;
   }
   
   for (short recNum = 0; recNum < 10; recNum++)
   {
      BinexData record(recNum);
      TestDataList      recordData;
      size_t            offset = 0;
      
      for (short dataNum = 0; dataNum < 80; dataNum++)
      {
         TestDataType whichType = (TestDataType)(rand() % (eMGFZI + 1) );
         void         *value = NULL;
         
         switch (whichType)
         {
            case eChar:
            {
               char c = (char)(rand() % 0x100);
               record.updateMessageData(offset, c, sizeof(c) );
               value  = new char(c);
               break;
            }   
            case eShort:
            {
               short s = (short)(rand() % 10000);
               record.updateMessageData(offset, s, sizeof(s) );
               value  = new short(s);
               break;
            }  
            case eLong:
            {
               long l = (long)(lrand48() );
               record.updateMessageData(offset, l, sizeof(l) );
               value  = new long(l);
               break;
            }   
            case eUBNXI:
            {
               BinexData::UBNXI u( (unsigned long)(abs(lrand48() ) ) % BinexData::UBNXI::MAX_VALUE);
               record.updateMessageData(offset, u);
               value = new BinexData::UBNXI(u);
               break;
            }   
            case eMGFZI:
            {
               BinexData::MGFZI m( (long long)(lrand48() ) );
               record.updateMessageData(offset, m);
               value = new BinexData::MGFZI(m);
               break;
            }   
            default:
                  // Internal error
               exit(1);
         }
         if (value != NULL)
         {
            recordData.push_back(TestData(whichType, value) );
         }
      }
      testData.push_back(recordData);      
      testRecords.push_back(record);
   }

   if (verboseLevel > 0)
   {
      cout << "Verifying BINEX records . . ." << endl;
   }
   TestDataListList::iterator dataListIter = testData.begin();
   RecordList::iterator       recordIter   = testRecords.begin();
   bool more = true;
   while (  (dataListIter != testData.end() )
         && (recordIter   != testRecords.end() ) )
   {
      TestDataList      dataList = *dataListIter;
      BinexData record   = *recordIter;
      try
      {
         size_t offset = 0;
         TestDataList::iterator dataIter = (*dataListIter).begin();
         while (dataIter != (*dataListIter).end() )
         {
            switch ( (*dataIter).first)
            {
               case eChar:
               {
                  string desc = "Comparing character record message data";
                  char   c;
                  record.extractMessageData(offset, c, sizeof(c) );
                  if (memcmp( (void*)&c, (*dataIter).second, sizeof(c) ) )
                  {
                     report(desc, false);
                     cout << "  Actual:   " << c << endl;
                     cout << "  Expected: " << *( (char*)(*dataIter).second) << endl;
                  }
                  else
                  {
                     report(desc, true);
                  }
                  break;
               }   
               case eShort:
               {
                  string desc = "Comparing short record message data";
                  short  s;
                  record.extractMessageData(offset, s, sizeof(s) );
                  if (memcmp( (void*)&s, (*dataIter).second, sizeof(s) ) )
                  {
                     report(desc, false);
                     cout << "  Actual:   " << s << endl;
                     cout << "  Expected: " << *( (char*)(*dataIter).second) << endl;
                  }
                  else
                  {
                     report(desc, true);
                  }
                  break;
               }  
               case eLong:
               {
                  string desc = "Comparing long record message data";
                  long   l;
                  record.extractMessageData(offset, l, sizeof(l) );
                  if (memcmp( (void*)&l, (*dataIter).second, sizeof(l) ) )
                  {
                     report(desc, false);
                     cout << "  Actual:   " << l << endl;
                     cout << "  Expected: " << *( (char*)(*dataIter).second) << endl;
                  }
                  else
                  {
                     report(desc, true);
                  }
                  break;
               }   
               case eUBNXI:
               {
                  string           desc = "Comparing UBNXI record message data";
                  BinexData::UBNXI u;
                  record.extractMessageData(offset, u);
                  if (u == *( (BinexData::UBNXI*)(*dataIter).second) )
                  {
                     report(desc, true);
                  }
                  else
                  {
                     report(desc, false);
                     cout << "  Actual:   " << (unsigned long)u << endl;
                     cout << "  Expected: " << (unsigned long)*( (BinexData::UBNXI*)(*dataIter).second) << endl;
                  }
                  break;
               }   
               case eMGFZI:
               {
                  string           desc = "Comparing MGFZI record message data";
                  BinexData::MGFZI m;
                  record.extractMessageData(offset, m);
                  if (m == *( (BinexData::MGFZI*)(*dataIter).second) )
                  {
                     report(desc, true);
                  }
                  else
                  {
                     report(desc, false);
                     cout << "  Actual:   " << (long long)m << endl;
                     cout << "  Expected: " << (long long)*( (BinexData::MGFZI*)(*dataIter).second) << endl;
                  }
                  break;
               }   
               default:
                     // Internal error
                  exit(1);
            }
            dataIter++;
         }
      }
      catch (FFStreamError e)
      {
         cout << "  FFStreamError reading record." << endl;
      }
      catch (...)
      {
         cout << "  Unknown error reading record." << endl;
      }
      dataListIter++;
      recordIter++;
      
   }

   if (verboseLevel > 0)
   {
      cout << "Writing BINEX file . . ." << endl;
   }
   BinexStream outStream("test.out", std::ios::out | std::ios::binary);
   outStream.exceptions(ios_base::failbit | ios_base::badbit);
   recordIter = testRecords.begin();
   while (recordIter != testRecords.end() )
   {
      try
      {
         (*recordIter).putRecord(outStream);
      }
      catch(...)
      {
         cout << "  Error writing record." << endl;
      }
      recordIter++;
   }
   outStream.close();
   
   if (verboseLevel > 0)
   {
      cout << "Reading BINEX file . . ." << endl;
   }
   BinexStream inStream("test.out", std::ios::in | std::ios::binary);   
   inStream.exceptions(ios_base::failbit);
   recordIter = testRecords.begin();
   while (inStream.good() && (EOF != inStream.peek() ) )
   {
      if (recordIter == testRecords.end() )
      {
         cout << "Stored records exhausted before file records - exiting." << endl;
         break;
      }
      BinexData record;
      try
      {
         record.getRecord(inStream);
         if (record == *recordIter)
         {
            report("Reading and comparing BINEX record", true);
         }
         else
         {
            report("Reading and comparing BINEX record", false);
            cout << "Actual record:" << endl;
            (*recordIter).dump(cout);
            cout << "Expected record:" << endl;
            record.dump(cout);
         }
      }
      catch (FFStreamError e)
      {
         cout << e << endl;
      }
      catch (...)
      {
         cout << "  Unknown error reading record." << endl;
      }
      recordIter++;      
   }
   inStream.close();

}