readfileheader()

FileHeader datrw::tfascii::readfileheader	(	std::istream &	is,
		const bool &	verbose = false
	)

read the complete fileheader

Parameters

is	the input stream
verbose	for verbose output or not

Returns

the FileHeader of the data

Definition at line 78 of file readtfascii.cc.

References DATRW_assert, datrw::tfascii::helper::extract(), datrw::tfascii::helper::extractvalue(), datrw::tfascii::FileHeader::filefree, datrw::tfascii::FileHeader::hasfilefree, datrw::tfascii::FileHeader::hassrce, and datrw::tfascii::FileHeader::srce.

Referenced by datrw::itfasciistream::set_fileheader().

    {
      std::string line;
      bool hot = true;
      FileHeader fileheader;
      fileheader.hasfilefree = false;
      fileheader.hassrce = false;

      while (hot && is.good())
      {
        getline(is, line);
        // get SRCE line if available
        if (line == "contents of SFF SRCE line:")
        {
          fileheader.hassrce = true;
          if (verbose)
          {
            std::cout << "SFF SRCE line detected." << std::endl;
          }
          DATRW_assert(getline(is, line), "ERROR: reading file");
          helper::extract(line);
          fileheader.srce.type = line;    
          DATRW_assert(getline(is, line), "ERROR: reading file");
          helper::extractvalue(line);
          if (line == "cartesian")
          {
            fileheader.srce.cs = sff::CS_cartesian;
          } 
          else
          {
            fileheader.srce.cs = sff::CS_spherical; 
          }
          DATRW_assert(getline(is, line), "ERROR: reading file");
          helper::extractvalue(line, true);
          fileheader.srce.cx = std::atof(line.c_str());
          DATRW_assert(getline(is, line), "ERROR: reading file");
          helper::extractvalue(line, true);
          fileheader.srce.cy = std::atof(line.c_str());
          DATRW_assert(getline(is, line), "ERROR: reading file");
          helper::extractvalue(line, true);
          fileheader.srce.cz = std::atof(line.c_str());
          DATRW_assert(getline(is, line), "ERROR: reading file");
          helper::extract(line);
          std::istringstream iss(line);
          char c;
          int doy, day, month, year, hour, minute, secs, micsecs;
          iss >> doy;
          iss >> day >> c >> month >> c >> year;
          iss >> hour >> c >> minute >> c >> secs >> c >> micsecs;
          fileheader.srce.date = libtime::TAbsoluteTime(year, 
                                                        month,
                                                        day,
                                                        hour,
                                                        minute,
                                                        secs,
                                                        0,
                                                        micsecs);
          DATRW_assert(doy == fileheader.srce.date.doy(),
            "ERROR: inconsistent date values");
        }
        // get fileFREE if available
        if (line == "contents of SFF FREE block:")
        {
          fileheader.hasfilefree = true;
          if (verbose) 
          {
            std::cout << "file FREE block detected." << std::endl;
          }
          while (getline(is, line))
          {
            // break if stream reaches a empty line
            if (line.empty()) 
            { 
              hot = false;
              break; 
            }
            fileheader.filefree.append(line); 
          }
        } else 
        if (line == "file header contains no FREE block") 
        { hot = false; }
      }

      return fileheader;
    } // function readfileheader

Here is the call graph for this function:

Here is the caller graph for this function: