main()

int main	(	int	iargc,
		char *	argv[]
	)

Definition at line 92 of file thiesdl1test.cc.

References Options::countonly, DATRW_assert, datrw::hpmo::dump(), Options::integer, Options::modifiers, Options::nprint, datrw::ithiesdl1stream::openmode, Options::readfile, Options::readheader, datrw::thiesdl1::readheader(), reportfilled(), reportheader(), Options::streamread, THIESDL1TEST_VERSION, Options::tolerateredundant, datrw::thiesdl1::File::tolerateredundant(), Options::toleratewrongtime, and Options::verbose.

{

  // define usage information
  char usage_text[]=
  {
    THIESDL1TEST_VERSION "\n"
    "usage: thiesdl1test [-v] [-h] [-f] [-trs] [-twt] [-stream] [-count]\n"
    "                    [-int] [-np n] [-modifiers m]\n"
    "                    file [file ...]" "\n"
    "   or: thiesdl1test --help|-h" "\n"
  };

  // define full help text
  char help_text[]=
  {
    "\n"
    "-v           be verbose\n"
    "-h           read file header and report entries\n"
    "-f           read complete file and report entries\n"
    "-trs         tolerate redundant samples\n"
    "-twt         tolerate wrong time\n"
    "-stream      use stream interface\n"
    "-count       only count samples in stream mode\n"
    "-int         use integer reading in stream mode\n"
    "-np n        display n samples in stream mode\n"
    "-modifiers m use modifiers m in stream mode\n"
  };

  // define commandline options
  using namespace tfxx::cmdline;
  static Declare options[]= 
  {
    // 0: print help
    {"help",arg_no,"-"},
    // 1: verbose mode
    {"v",arg_no,"-"},
    // 2: read file header
    {"h",arg_no,"-"},
    // 3: read complete file
    {"f",arg_no,"-"},
    // 4: tolerate redundant samples
    {"trs",arg_no,"-"},
    // 5: tolerate wrong time
    {"twt",arg_no,"-"},
    // 6: use stream reading
    {"stream",arg_no,"-"},
    // 7: count samples
    {"count",arg_no,"-"},
    // 8: use integer input
    {"int",arg_no,"-"},
    // 9: use integer input
    {"np",arg_yes,"10"},
    // 10: use integer input
    {"modifiers",arg_yes,""},
    {NULL}
  };

  // no arguments? print usage...
  if (iargc<2) 
  {
    cerr << usage_text << endl;
    exit(0);
  }

  // collect options from commandline
  Commandline cmdline(iargc, argv, options);

  // help requested? print full help text...
  if (cmdline.optset(0))
  {
    cerr << usage_text << endl;
    cerr << help_text << endl;
    exit(0);
  }

  Options opt;
  opt.verbose=cmdline.optset(1);
  opt.readheader=cmdline.optset(2);
  opt.readfile=cmdline.optset(3);
  opt.tolerateredundant=cmdline.optset(4);
  opt.toleratewrongtime=cmdline.optset(5);
  opt.streamread=cmdline.optset(6);
  opt.countonly=cmdline.optset(7);
  opt.integer=cmdline.optset(8);
  opt.nprint=cmdline.int_arg(9);
  opt.modifiers=cmdline.string_arg(10);

  /*
  // dummy operation: print option settings
  for (int iopt=0; iopt<2; iopt++)
  {
    cout << "option: '" << options[iopt].opt_string << "'" << endl;
    if (cmdline.optset(iopt)) {  cout << "  option was set"; }
    else { cout << "option was not set"; }
    cout << endl;
    cout << "  argument (string): '" << cmdline.string_arg(iopt) << "'" << endl;
    cout << "     argument (int): '" << cmdline.int_arg(iopt) << "'" << endl;
    cout << "    argument (long): '" << cmdline.long_arg(iopt) << "'" << endl;
    cout << "   argument (float): '" << cmdline.float_arg(iopt) << "'" << endl;
    cout << "  argument (double): '" << cmdline.double_arg(iopt) << "'" << endl;
    cout << "    argument (bool): '";
    if (cmdline.bool_arg(iopt))
    { cout << "true"; } else { cout << "false"; }
    cout << "'" << endl;
  }
  while (cmdline.extra()) { cout << cmdline.next() << endl; }
  */

  // cycle through all file names
  while (cmdline.extra()) 
  { 
    std::string filename=cmdline.next();
    cout << "process file " << filename << endl; 

    /*----------------------------------------------------------------------*/

    if (opt.readheader)
    {
      cout << "  read header\n"
        <<    "  -----------" << endl;
      std::ifstream ifs(filename.c_str(), datrw::ithiesdl1stream::openmode); 
      datrw::thiesdl1::FileHeader header=
        datrw::thiesdl1::readheader(ifs);
      reportheader(header);
    } // if (opt.readheader)

    /*----------------------------------------------------------------------*/

    if (opt.readfile)
    {
      cout << "  read file\n"
        <<    "  ---------" << endl;
      std::ifstream ifs(filename.c_str(), datrw::ithiesdl1stream::openmode); 
      datrw::thiesdl1::File file;
      file.tolerateredundant(opt.tolerateredundant);
      file.toleratewrongtime(opt.toleratewrongtime);
      reportfilled(file);
      file.readwithheader(ifs);
      reportfilled(file);
      reportheader(file.header());
      datrw::Tdseries series=file.dseries();
      aff::dump(series);
    } // if (opt.readheader)

    /*----------------------------------------------------------------------*/

    if (opt.streamread)
    {

      std::ifstream ifs(filename.c_str());
      datrw::ithiesdl1stream is(ifs, opt.modifiers);
      if (is.hasfree())
      {
        if (opt.verbose)
        {
          cout << "file FREE block:" << endl;
          is.free().write(std::cout);
        }
        else
        {
          cout << "file has FREE block" << endl;
        }
      }
      else
      {
        cout << "file has no FREE block" << endl;
      }
      if (is.hassrce())
      {
        if (opt.verbose)
        {
          cout << "file SRCE line:" << endl;
          cout << is.srce().line() << endl;;
        }
        else
        {
          cout << "file has SRCE line" << endl;
        }
      }
      else
      {
        cout << "file has no SRCE line" << endl;
      }
      datrw::Tfseries fseries;
      datrw::Tiseries iseries;

      if (opt.countonly)
      {
        is.skipseries();
      }
      else
      {
        if (opt.integer)
        {
          is >> iseries;
        }
        else
        {
          is >> fseries;
        }
      }
      if (is.hasfree())
      {
        if (opt.verbose)
        {
          cout << "trace FREE block:" << endl;
          is.free().write(std::cout);
        }
        else
        {
          cout << "trace has FREE block" << endl;
        }
      }
      else
      {
        cout << "trace has no FREE block" << endl;
      }
      if (is.hasinfo())
      {
        if (opt.verbose)
        {
          cout << "trace INFO line:" << endl;
          cout << is.info().line() << endl;;
        }
        else
        {
          cout << "trace has INFO line" << endl;
        }
      }
      else
      {
        cout << "trace has no INFO line" << endl;
      }
      std::cout << is.wid2().line() << std::endl;
      if ((!opt.countonly) && (opt.verbose))
      {
        if (opt.integer)
        {
          int npr=
            opt.nprint < int(iseries.size()/2) ?
            opt.nprint : iseries.size()/2;
          for (int i=0; i<npr; ++i)
          { std::cout << i << " " << iseries(i) << std::endl; }
          std::cout << " ... " << std::endl;
          for (int i=iseries.size()-npr; i<int(iseries.size()); ++i)
          { std::cout << i << " " << iseries(i) << std::endl; }
        }
        else
        {
          int npr=
            opt.nprint < int(fseries.size()/2) ?
            opt.nprint : fseries.size()/2;
          for (int i=0; i<npr; ++i)
          { std::cout << i << " " << fseries(i) << std::endl; }
          std::cout << " ... " << std::endl;
          for (int i=fseries.size()-npr; i<int(fseries.size()); ++i)
          { std::cout << i << " " << fseries(i) << std::endl; }
        }
      }
      DATRW_assert(is.last(), "last flag was not set");
    } // if (opt.streamread)

  } // while (cmdline.extra())
}

Here is the call graph for this function: