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

bool Cube::parseCoordinates(TextStream& textStream, unsigned nAtoms) 
{
   Data::Geometry* geometry(new Data::Geometry);
   bool ok;
   unsigned atomicNumber;
   qglviewer::Vec position;

   for (unsigned i = 0; i < nAtoms; ++i) {
       QStringList tokens(textStream.nextLineAsTokens());
       if (tokens.size() != 5) return false; 
       atomicNumber = tokens[0].toUInt(&ok);  if (!ok) goto error;
       position.x = tokens[2].toDouble(&ok);  if (!ok) goto error;
       position.y = tokens[3].toDouble(&ok);  if (!ok) goto error;
       position.z = tokens[4].toDouble(&ok);  if (!ok) goto error;
       geometry->append(atomicNumber, position);
   } 

   geometry->scaleCoordinates(m_scale);
   geometry->computeGasteigerCharges();
   m_dataBank.append(geometry);
   return true;

   error:
      QString msg("Incorrect format on line ");
      msg += QString::number(textStream.lineNumber());
      delete geometry;
      return false;
}

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 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()) {
//.........这里部分代码省略.........

int Cube::parseGridAxes(TextStream& textStream) 
{
   int nAtoms(0);
   bool ok, xOk, yOk, zOk;
   double x, y, z, dx, dy, dz;
   double thresh(1e-6);

   // origin line
   QStringList tokens(textStream.nextLineAsTokens());
   if (tokens.size() != 4) return 0;
   nAtoms = tokens[0].toInt(&ok);
   x = tokens[1].toDouble(&xOk);
   y = tokens[2].toDouble(&yOk);
   z = tokens[3].toDouble(&zOk);
   if (!(ok && xOk && yOk && zOk)) return 0;
   m_origin.setValue(x, y, z);

   // x line
   tokens = textStream.nextLineAsTokens();
   if (tokens.size() != 4) return 0;
   m_nx = tokens[0].toInt(&ok);
   dx   = tokens[1].toDouble(&xOk);
   y    = tokens[2].toDouble(&yOk);
   z    = tokens[3].toDouble(&zOk);
   if (!(ok && xOk && yOk && zOk)) return 0;
   if (std::abs(y) > thresh || std::abs(z) > thresh) goto axial_error;

   // y line
   tokens = textStream.nextLineAsTokens();
   if (tokens.size() != 4) return 0;
   m_ny = tokens[0].toInt(&ok); 
   x    = tokens[1].toDouble(&xOk);
   dy   = tokens[2].toDouble(&yOk);
   z    = tokens[3].toDouble(&zOk);
   if (!(ok && xOk && yOk && zOk)) return 0;
   if (std::abs(x) > thresh || std::abs(z) > thresh) goto axial_error;

   // z line
   tokens = textStream.nextLineAsTokens();
   if (tokens.size() != 4) return 0;
   m_nz = tokens[0].toInt(&ok); 
   x    = tokens[1].toDouble(&xOk);
   y    = tokens[2].toDouble(&yOk);
   dz   = tokens[3].toDouble(&zOk);
   if (!(ok && xOk && yOk && zOk)) return 0;
   if (std::abs(x) > thresh || std::abs(y) > thresh) goto axial_error;

   m_delta.setValue(dx, dy, dz); 

   // Check what units we are using.
   if (m_nx < 0) {
      m_scale = 1.0;
      QLOG_TRACE() << "Leaving grid data units unscaled";
   }else {
      m_scale = Constants::BohrToAngstrom;
      QLOG_TRACE() << "Scaling grid data units: Bohr -> Angstrom";
   }

   m_nx = std::abs(m_nx);
   m_ny = std::abs(m_ny);
   m_nz = std::abs(m_nz);
   m_origin *= m_scale;
   m_delta  *= m_scale;

   return nAtoms;

   axial_error:
      m_errors.append("Non-axial grid data not supported");
      return 0;
}