readsamples()

template<typename T >

std::string datrw::ascii::anonymous_namespace{iasciistream.cc}::readsamples	(	std::istream &	is,
		const unsigned int &	n,
		const std::string &	firstline,
		typename aff::Series< T > &	series,
		const bool &	nonfatal
	)

read a sequence of samples

Read a sequence of samples being regarded as a contiguous trace.

Parameters

T	type of sample value (double, float, int)
is	input stream to read from
n	expected number of samples
firstline	first line from input, which is already read
series	container to write samples to
nonfatal	errors are made nonfatal if true

Returns

next input line

Definition at line 318 of file iasciistream.cc.

References DATRW_nonfatal_assert, datrw::mseed::key::nonfatal, and datrw::hpmo::nsamples.

Referenced by readany().

        {
          typedef typename aff::Series<T> Tmyseries;
          std::string line=firstline;
          if (n==0)
          {
            // we do not expect a specific number of samples
            // read as many samples as can be found
            typedef typename std::vector<Tmyseries> Tvecofrecorddata;
            Tvecofrecorddata vecofrecorddata;
            unsigned int nsamples=0;
            unsigned int i=0;
            const unsigned int bufsize=5000;
            Tmyseries buffer(0,bufsize-1);
            buffer=0;
            // read data
            while ((!(line.substr(0,1)=="#")) && is.good())
            {
              if (i==bufsize)
              {
                vecofrecorddata.push_back(buffer.copyout());
                buffer=0;
                i=0;
              }
              std::istringstream iss(line);
              iss >> buffer(i);
              std::getline(is, line);
              ++i;
              ++nsamples;
            }
            if (i>0)
            {
              vecofrecorddata.push_back(aff::subarray(buffer)(0,i-1));
            }
            // data read: now copy fragments to series container
            typename Tvecofrecorddata::const_iterator I(vecofrecorddata.begin());
            series=Tmyseries(0,nsamples-1);
            nsamples=0;
            while (I != vecofrecorddata.end())
            {
              Tmyseries dest
                =aff::subarray(series)(nsamples,nsamples+I->size()-1);
              dest.copyin(*I);
              nsamples += I->size();
              ++I;
            }
          }
          else
          {
            // we expect a specfied number of samples
            series=Tmyseries(n);
            series=0; 
            unsigned int i=0;
            while ((!(line.substr(0,1)=="#")) && is.good() && (i<n))
            {
              std::istringstream iss(line);
              iss >> series(series.f()+i);
              std::getline(is, line);
              ++i;
            }
            DATRW_nonfatal_assert(nonfatal,
                                  (i==n),
                                  "readsamples (ASCII): "
                                  "found less samples than expected\n"
                                  "expected: " << n << " " <<
                                  "found: " << i);
          }
          return(line);
        } // readsamples

Here is the caller graph for this function: