C++ TextStream::atEnd方法代码示例

void Cube::parseGridData(TextStream& textStream) 
{
   QList<double> data;
   while (!textStream.atEnd()) {
      data += textStream.nextLineAsDoubles();
   }   

   QList<Data::Geometry*> geometryList(m_dataBank.findData<Data::Geometry>());
   if (geometryList.isEmpty()) {
      m_errors.append("Geometry data not found in cube file");
      return;
   }

   try {
      Data::SurfaceType type(Data::SurfaceType::CubeData);
      Data::GridSize    size(m_origin, m_delta, m_nx, m_ny, m_nz);

      Data::CubeData* cube(new Data::CubeData(*(geometryList.last()),size, type, data));
      m_dataBank.append(cube);

      QFileInfo info(m_filePath);
      cube->setLabel(info.completeBaseName());
   } catch (std::out_of_range const& err) {
      m_errors.append("Invalid grid data in cube file");
   }
}

void QChemInput::readEfpParamsSection(TextStream& textStream)
{
   EfpFragment parser;
   while (!textStream.atEnd()) {
      parser.loadNextFragment(textStream);
      if (textStream.previousLine().contains("$end", Qt::CaseInsensitive)) break;
   }
}

bool PovRay::parse(TextStream& textStream)
{
   Data::PovRay* povray(new Data::PovRay);

   while (!textStream.atEnd()) {
      readNextDeclaration(textStream, povray);
   }

   m_dataBank.append(povray);
   return m_errors.isEmpty();
}

void QChemInput::readEfpFragmentSection(TextStream& textStream)
{
   // Check for an existing list from the $molecule section
   Data::EfpFragmentList* efps(0);
   QList<Data::EfpFragmentList*> lists = m_dataBank.findData<Data::EfpFragmentList>();
   if (lists.isEmpty()) {
      efps = new Data::EfpFragmentList;
      m_dataBank.append(efps);
   }else {
      efps = lists.last();
   }

   QString msg("Invalid $efp_fragments format on line ");
   QStringList tokens;
   bool ok, allOk;
   int count(1);

   while (!textStream.atEnd()) {
      tokens = textStream.nextLineAsTokens();

      if (tokens.size() == 1 && tokens[0].contains("$end", Qt::CaseInsensitive)) {
         break;

      }else if (tokens.size() < 7) {
         Data::EfpFragment* efp(0);
         if (count <= efps->size()) {
            efp = efps->at(count-1);
         }else {
            efp = new Data::EfpFragment;
            efps->append(efp);
         }
         efp->setName(tokens[0]);
 
      }else {
         allOk = true;
         QString name(tokens[0]);
         double x, y, z, a, b, c;
         if (allOk) x = tokens[1].toDouble(&ok);  allOk = allOk && ok;
         if (allOk) y = tokens[2].toDouble(&ok);  allOk = allOk && ok;
         if (allOk) z = tokens[3].toDouble(&ok);  allOk = allOk && ok;
         if (allOk) a = tokens[4].toDouble(&ok);  allOk = allOk && ok;
         if (allOk) b = tokens[5].toDouble(&ok);  allOk = allOk && ok;
         if (allOk) c = tokens[6].toDouble(&ok);  allOk = allOk && ok;

         if (allOk) {
            efps->append(new Data::EfpFragment(name, qglviewer::Vec(x,y,z), a, b, c));
         }else {
            m_errors.append(msg += QString::number(textStream.lineNumber()));
         }
      }
      ++count;
   }
}

bool ExternalCharges::parse(TextStream& textStream) 
{
   int max(INT_MAX);
   bool allOk(true), isDouble;
   bool maxSet(false), invalidFormat(false);
   double x, y, z, q;
   QStringList tokens;
   Data::PointChargeList* charges(new Data::PointChargeList);

   while (!textStream.atEnd() && charges->size() < max) {
      tokens = textStream.nextLineAsTokens();
      if (tokens.size() >= 4) {
         x = tokens[0].toDouble(&isDouble);  allOk = allOk && isDouble;
         y = tokens[1].toDouble(&isDouble);  allOk = allOk && isDouble;
         z = tokens[2].toDouble(&isDouble);  allOk = allOk && isDouble;
         q = tokens[3].toDouble(&isDouble);  allOk = allOk && isDouble;

         if (allOk) {
            charges->append(new Data::PointCharge(q, qglviewer::Vec(x,y,z)));
         }else {
            invalidFormat = true;
            break;
         }
      }else if (tokens.size() >= 1) {
         if (tokens.first().contains("$end", Qt::CaseInsensitive) || maxSet) {
            break;
         }else {
            max = tokens[0].toInt(&maxSet);
         }
      }
   } 

   if (maxSet && charges->size() != max) {
      if (invalidFormat) {
         QString msg("Invalid format on line ");
         m_errors.append(msg += QString::number(textStream.lineNumber()));
      }else {
         m_errors.append("End of stream encountered");
      }
      delete charges;
   }else if (charges->isEmpty()) {
      m_errors.append("No charges found");
      delete charges;
   }else {
      m_dataBank.append(charges);
   }

   return m_errors.isEmpty();
}

void PovRay::readNextDeclaration(TextStream& textStream, Data::PovRay* povray)
{
   // looks for '#declare TextureName = '
   const QRegExp declare("^#declare\\s+(\\S+)\\s?="); 

   QString line(textStream.nextLine());
   if (!line.contains(declare)) line = textStream.seek(declare);

   if (!textStream.atEnd() && declare.indexIn(line) > -1) {
      QString name(declare.cap(1));
      // remove the initial IQmol_Texture_
      name.remove(0,14);
      name.replace("_", " ");
      line = textStream.nextBlock();
      povray->addTexture(name,line);
   }
}

QString EfpFragment::loadNextFragment(TextStream& textStream)
{
   QString line(textStream.previousLine()); 
   if (!line.contains("fragment", Qt::CaseInsensitive)) {
      line = textStream.seek("fragment", Qt::CaseInsensitive);
   }

   QStringList tokens(TextStream::tokenize(line));
   QString name;

   if (tokens.size() >= 2 && tokens[0].toLower() == "fragment") {
      name = tokens[1];
   }else {
      return QString();
   }

   CartesianCoordinates parser;
   Data::Geometry* geom(parser.parse(textStream)); 
   if ( !geom || !parser.error().isEmpty()) {
      m_errors.append("Invalid EFP file, no coordinates found");
      delete geom;
      return QString();
   }

   if (name.endsWith("_L", Qt::CaseInsensitive)) {
      Data::EfpFragmentLibrary::instance().add(name, geom);
   }else {
	  // We assume the fragment is not in the library and so we need to collect
	  // the additional guff so we can add it to the input file if required.
      QString line;
      QStringList guff;
      while ( !textStream.atEnd() && 
         !line.contains("fragment", Qt::CaseInsensitive) &&
         !line.contains("$end", Qt::CaseInsensitive) ) {
         guff << line;
      }
      Data::EfpFragmentLibrary::instance().add(name, geom, guff.join("\n"));
   }

   return name;
}

bool QChemInput::parse(TextStream& textStream)
{
   QString line;
   m_geometryList = new Data::GeometryList;

   while (!textStream.atEnd()) {
      line = textStream.nextLine();

      if (line.contains("@@@", Qt::CaseInsensitive)) {
         // Any need to demarkate jobs?

      }else if (line.contains("$rem", Qt::CaseInsensitive)) {
         readRemSection(textStream);

      }else if (line.contains("$molecule", Qt::CaseInsensitive)) {
         readMoleculeSection(textStream);

      }else if (line.contains("$efp_params", Qt::CaseInsensitive)) {
         //readEfpParamsSection(textStream);

      }else if (line.contains("$efp_fragments", Qt::CaseInsensitive)) {
         readEfpFragmentSection(textStream);

      }else if (line.contains("$external_charges", Qt::CaseInsensitive)) {
         readExternalChargesSection(textStream);

      }else if (line.contains("------------------------")) {
          // Assume this is the end of the input echoed in an output file.
          break;
      }
   }

   if (m_geometryList->isEmpty()) {
      delete m_geometryList;
   }else {
      m_dataBank.append(m_geometryList);
   }

   return m_errors.isEmpty();
}

QList<Data::SurfaceType> QChemPlot::parseForProperties(TextStream& textStream)
{
   QString firstLine;
   while (!textStream.atEnd() && !firstLine.contains("Grid point positions")) {
      firstLine = textStream.nextLine();
   }

   bool esp(firstLine.contains("esp values"));
   bool rho(firstLine.contains("electronic density values"));

   textStream.skipLine();
   QString secondLine(textStream.nextLine());

   QList<Data::SurfaceType> surfaceTypes;

   unsigned count(1);
   while (!secondLine.isEmpty()) {
      QString field(secondLine.left(13));
      secondLine.remove(0, 13);
      field = field.trimmed();

      if (field == "X" || field == "Y" || field == "Z") {
         // ignore
      }else if(field.contains("ALPHA")) {
         surfaceTypes.append(
           Data::SurfaceType(Data::SurfaceType::AlphaOrbital, count++));
      }else if(field.contains("BETA")) {
         surfaceTypes.append(
           Data::SurfaceType(Data::SurfaceType::BetaOrbital, count++));
      }else if (esp) {
         surfaceTypes.append(
           Data::SurfaceType(Data::SurfaceType::ElectrostaticPotential, count++));
      }else if (rho) {
         surfaceTypes.append(
           Data::SurfaceType(Data::SurfaceType::TotalDensity, count++));
      }
   }
   
   return surfaceTypes;
}

void QChemInput::readRemSection(TextStream& textStream)
{  
   QString line;
   QStringList tokens;
   bool finished(false);
   Data::RemSection* rem = new Data::RemSection;

   while (!textStream.atEnd() && !finished) {
      line = textStream.nextLine();
      line = line.replace('=', ' ');
      tokens = TextStream::tokenize(line);
      
      switch (tokens.size()) {
         case 0:
            // Ignore empty lines
            break;
         case 1:
            if (tokens[0].contains("$end", Qt::CaseInsensitive)) {
               finished = true;
            }else if (tokens[0].contains("$rem", Qt::CaseInsensitive)) {
               // carry on
            }else {
               m_errors.append("Invalid $rem format, line " + 
                 QString::number(textStream.lineNumber()));
               delete rem;
               rem = 0;
               finished = true;
            }  
            break;
         default:
            rem->insert(tokens[0].toLower(), tokens[1].toLower());
            break;
      }     
   }  
   
   if (rem) m_dataBank.append(rem);
} 

void QChemInput::readMoleculeSection(TextStream& textStream)
{
   QString msg("Invalid $molecule format on line ");
   int charge(0);
   unsigned multiplicity(1);
   bool ok;

   // First line can only contain the charge and multiplicity or 'read'
   QString line(textStream.nextLine());
   line = line.replace(',', ' ');
   QStringList tokens(TextStream::tokenize(line));

   switch (tokens.size()) {
      case 0:  // Error
         m_errors.append(msg + QString::number(textStream.lineNumber()));
         return;
      break;

      case 1:  // Could be reading in previous geometry
         if (tokens[0].contains("read", Qt::CaseInsensitive)) {
            if (m_geometryList->size() > 0) {
                // copy previous geometry
                Data::Geometry* geometry(new Data::Geometry(*(m_geometryList->last()))); 
                m_geometryList->append(geometry);
             }else {
				// We assume we are reading an input section from
				// an output file, so there is no new geometry.
             }
          }else {
             m_errors.append(msg + QString::number(textStream.lineNumber()));
          }
          return;
      break;

      default:
         charge = tokens[0].toInt(&ok);
         if (ok) multiplicity = tokens[1].toUInt(&ok);
         if (!ok) {
            m_errors.append(msg + QString::number(textStream.lineNumber()));
            return;
         }
      break;
   }

   // Second line could be a 'read' token or the first atom
   line = textStream.nextLine();
   // offset is passed to the CartesianCoordinates parser to give
   // an accurate line number if an error occurs.
   int offset(textStream.lineNumber()-1);

   if (line.isEmpty()) {
      m_errors.append(msg + QString::number(textStream.lineNumber()));
      return;
   }

   // Special case: read previous geometry
   if (line.contains("read", Qt::CaseInsensitive)) {
      if (m_geometryList->size() > 0) {
         // copy last geometry
         Data::Geometry* geometry(new Data::Geometry(*(m_geometryList->last()))); 
         geometry->setChargeAndMultiplicity(charge, multiplicity);
         m_geometryList->append(geometry);
      }else {
         m_errors.append(msg + QString::number(textStream.lineNumber()));
      }
      return;
   }

   // Special case: EFP only fragments
   if (line.contains("--")) {
	  // Check for an existing list which may have been created if the
	  // $efp_fragments section was parsed before $molecule.
      Data::EfpFragmentList* efps(0);
      QList<Data::EfpFragmentList*> lists = m_dataBank.findData<Data::EfpFragmentList>();
      if (lists.isEmpty()) {
         efps = new Data::EfpFragmentList;
         m_dataBank.append(efps);
      }else {
         efps = lists.last();
      }

      int count(1);
      while (!textStream.atEnd()) {
         tokens = textStream.nextLineAsTokens();

         if (tokens.size() == 1 && tokens[0].contains("$end", Qt::CaseInsensitive)) {
            break;
         }else if (tokens.size() == 6) {
            bool allOk(true);
            double x, y, z, a, b, c;
            if (allOk) x = tokens[0].toDouble(&ok);  allOk = allOk && ok;
            if (allOk) y = tokens[1].toDouble(&ok);  allOk = allOk && ok;
            if (allOk) z = tokens[2].toDouble(&ok);  allOk = allOk && ok;
            if (allOk) a = tokens[3].toDouble(&ok);  allOk = allOk && ok;
            if (allOk) b = tokens[4].toDouble(&ok);  allOk = allOk && ok;
            if (allOk) c = tokens[5].toDouble(&ok);  allOk = allOk && ok;

            if (allOk) {
               Data::EfpFragment* efp(0);
               if (count <= efps->size()) {
//.........这里部分代码省略.........

// Note the grid data is read in as bohr, but converted to angstroms in the
// Grid constructor
bool QChemPlot::parse(TextStream& textStream)
{
   QList<double> values;

   QList<Data::SurfaceType> surfaceTypes(parseForProperties(textStream));
   unsigned nProperties(surfaceTypes.size());
   if (nProperties < 1) goto error;
   
   values = textStream.nextLineAsDoubles();
   if ((unsigned)values.size() != 3 + nProperties) goto error;

   {/**/
      double xMin(values[0]);
      double yMin(values[1]);
      double zMin(values[2]);
      double xMax(xMin);
      double yMax(yMin);
      double zMax(zMin);

      typedef QList<double> List;
      List* data = new List[nProperties];

      for (unsigned i = 0; i < nProperties; ++i) {
          data[i].append(values[i+3]);
      }

      unsigned nx(1), ny(1), nz(1);

      while (!textStream.atEnd()) {
         if ((unsigned)values.size() == 3 + nProperties) {
            if (values[0] > xMax) { xMax = values[0]; ++nx; }
            if (values[1] > yMax) { yMax = values[1]; ++ny; }
            if (values[2] > zMax) { zMax = values[2]; ++nz; }
            for (unsigned i = 0; i < nProperties; ++i) {
                data[i].append(values[i+3]);
            }
         }
         values = textStream.nextLineAsDoubles();
      }

      qglviewer::Vec delta((xMax-xMin)/nx, (yMax-yMin)/ny, (zMax-zMin)/nz);
      qglviewer::Vec origin(xMin, yMin, zMin);
      Data::GridDataList* gridList(new Data::GridDataList);

      try {

         for (unsigned i = 0; i < nProperties; ++i) {
             Data::GridSize size(origin, delta, nx, ny, nz);
             gridList->append(new Data::GridData(size, surfaceTypes[i]));
         }

         m_dataBank.append(gridList);

      } catch (...) {
         m_errors.append("Problem creating QChem plot data");
         delete gridList; 
      }

      delete[] data;
   }/**/

   return m_errors.isEmpty();

   error:
      QString msg("Problem parsing QChem plot data, line ");
      m_errors.append(msg += QString::number(textStream.lineNumber()));
      return false;
}