C++ fstream::bad方法代码示例

long long TCPTransport::recvfile(std::fstream& ofs, long long offset, long long size)
{
    if (!m_bConnected)
        return -1;

    if (ofs.bad() || ofs.fail())
        return -1;

    ofs.seekp(offset);

    int block = 1000000;
    char* buf = new char[block];
    long long recd = 0;
    while (recd < size)
    {
        int unit = int((size - recd) > block ? block : size - recd);
        recv(buf, unit);
        ofs.write(buf, unit);
        recd += unit;
    }

    delete [] buf;

    return recd;
}

long long TCPTransport::sendfile(std::fstream& ifs, long long offset, long long size)
{
    if (!m_bConnected)
        return -1;

    if (ifs.bad() || ifs.fail())
        return -1;

    ifs.seekg(offset);

    int block = 1000000;
    char* buf = new char[block];
    long long sent = 0;
    while (sent < size)
    {
        int unit = int((size - sent) > block ? block : size - sent);
        ifs.read(buf, unit);
        send(buf, unit);
        sent += unit;
    }

    delete [] buf;

    return sent;
}

    static int getImageCount(std::fstream& file_list)
    {
        int sample = 0;
        std::string line;
        while (std::getline(file_list, line))
            ++sample;
        if (file_list.eof())
            file_list.clear();  //otherwise we can't do any further I/O
        else if (file_list.bad()) {
            throw  std::runtime_error("Error occured while reading files_list.txt");
        }

        return sample;
    }

	/**
	 * Sets the stream position indicator for the stream. The new position,
	 * measured in bytes, is obtained by adding offset bytes to the position
	 * specified by whence. If whence is set to SEEK_SET, SEEK_CUR, or
	 * SEEK_END, the offset is relative to the start of the file, the current
	 * position indicator, or end-of-file, respectively. A successful call
	 * to the seek() method clears the end-of-file indicator for the stream.
	 *
	 * @note The semantics of any implementation of this method are
	 * supposed to match those of ISO C fseek().
	 *
	 * @param offset	the relative offset in bytes
	 * @param whence	the seek reference: SEEK_SET, SEEK_CUR, or SEEK_END
	 * @return true on success, false in case of a failure
	 */
	virtual bool seek(int32 offset, int whence = SEEK_SET) {
		if (whence == SEEK_SET) {
			_stream->seekg(offset, std::ios::beg);
		} else if (whence == SEEK_CUR) {
			_stream->seekg(offset, std::ios::cur);
		} else {
			_stream->seekg(offset, std::ios::end);
		}
		
		if (_stream->fail())
			return false;
		if (_stream->bad())
			return false;
		return true;
	}

void Agente::leerLinea(std::fstream& archivo, std::string& linea) {
	linea.clear();

	char buffer[T_BUFFER];

	bool seguirLeyendo = true;
	do {
		archivo.getline(buffer, T_BUFFER, '\n');
		linea.append(buffer, archivo.gcount());

		seguirLeyendo = (archivo.gcount() == T_BUFFER);

		if (archivo.bad())
			archivo.clear();

	} while (seguirLeyendo);
}

//------------------------------------------------------------------------------
/// \brief Reads 3. Data: ITMP
/// \brief Reads 4. Data: WELLID Qdes {CapMult} {Cprime} {xyz}
//------------------------------------------------------------------------------
void ProcessorMNW2::impl::ReadStressPeriods (std::fstream& a_is,
                                             std::fstream& a_os)
{
  CStr str;
  std::string line;
  EReadAsciiFile e;
  e.UseExceptions();
  while (!a_is.bad())
  {
    std::getline(a_is, line);
    if (line.empty())
    {
      return;
    }

    int ITMP;
    a_os << line << "\n";
    e.SetLine(line.c_str());
    e.ReadData(ITMP);
    if (ITMP < 1)
      continue;

    std::getline(a_is, line);
    e.SetLine(line.c_str());
    e.ReadData(str);
    if ("GMS_HDF5_01" == str)
    {
      CStr fname, path;
      int sp;
      e.ReadData(fname);
      e.ReadData(path);
      path += "/07. Property";
      e.ReadData(sp);
      std::pair<int, int> myPair(0,1);
      VEC_INT_PAIR indices(3, myPair);
      indices[0].second = numMnw2Prop();
      indices[1].second = m_MNWMAX;
      indices[2].first = sp - 1;
      H5DataSetReader r(fname, path, indices);
      CAR_DBL2D vals;
      vals.SetSize(MNW2::NPROP, m_MNWMAX, 0);
      if (!r.GetData(&vals[0][0], MNW2::NPROP*m_MNWMAX))
      {
        ErrorStack::Get().PutError("Unable to read MNW2 hdf5 data.");
        throw ioError("");
      }

      for (int i = 0; i<m_MNWMAX; i++)
      {
        if (vals.at(MNW2::ACTIVE, i) != 0)
        { // this well is active
          // 4a. Data: WELLID Qdes {CapMult} {Cprime} {xyz}
          CStr ln;
          ln.Format("'%s' %s", m_wells.at(i).m_WELLID,
                               STR(vals.at(MNW2::QDES, i)));
          if (m_wells.at(i).m_PUMPCAP > 0)
          {
            ln += " ";
            ln += STR(vals.at(MNW2::CAPMULT, i));
          }
          // don't write Cprime

          // get AUX
          for (int j = 0; j<m_nAUX; j++)
          {
            ln += " ";
            ln += STR(vals.at(MNW2::AUX_0+j, i));
          }
          a_os << ln << "\n";

          if (m_wells.at(i).m_Qlimit < 0)
          {
            double QCUT = vals.at(MNW2::QCUT, i);
            ln.Format("%s %s", STR(vals.at(MNW2::HLIM, i)), STR(QCUT));
            if (QCUT != 0)
            {
              CStr ln2;
              ln2.Format(" %s %s", STR(vals.at(MNW2::QFRCMN, i)),
                                   STR(vals.at(MNW2::QFRCMX, i)));
              ln += ln2;
            }
            a_os << ln << "\n";
          }
        }
      }
    }
  }
} // ProcessorMNW2::impl::ReadStressPeriods