commandlinereader.hh

Go to the documentation of this file.

/*****************************************************************************
*   This program is part of the msbGrid software                            *
*                                                                           *
*   msbGrid stands for multi-structured block Grid generator                *
*                                                                           *
*   msbGrid is a free software: you can redistribute it and/or modify       *
*   it under the terms of the GNU General Public License as published by    *
*   the Free Software Foundation, either version 2 of the License, or       *
*   (at your option) any later version.                                     *
*                                                                           *
*   msbGrid is distributed in the hope that it will be useful,              *
*   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           *
*   GNU General Public License for more details.                            *
*                                                                           *
*   See the file COPYING for full copying permissions.                      *
*****************************************************************************/
#include <parametertree.hh>
#include <parametertreeparser.hh>

#ifndef _COMMAND_LINE_READER_HH_
#define _COMMAND_LINE_READER_HH_

namespace msbGrid
{
std :: string readCommandLineOptions(int argc, char **argv, msbGrid :: ParameterTree &paramTree)
{
  // All command line options need to start with '-'
  for ( int i = 1; i < argc; ++i ) {
    if ( argv [ i ] [ 0 ] != '-' ) {
      std :: ostringstream oss;
      oss << "Command line argument " << i << " (='" << argv [ i ] << "') is invalid.";
      return oss.str();
    }

    std :: string paramName, paramValue;

    // read a --my-opt=abc option. This gets transformed
    // into the parameter "MyOpt" with the value being "abc"
    if ( argv [ i ] [ 1 ] == '-' ) {
      // There is nothing after the '-'
      if ( argv [ i ] [ 2 ] == 0 || !std :: isalpha(argv [ i ] [ 2 ]) ) {
        std :: ostringstream oss;
        oss << "Parameter name of argument " << i << " ('" << argv [ i ] << "')"
            << " is invalid because it does not start with a letter.";
        return oss.str();
      }

      // copy everything after the "--" into a separate string
      std :: string s(argv [ i ] + 2);

      // parse argument
      unsigned j = 0;
      while ( true ) {
        if ( j >= s.size() ) {
          // encountered the end of the string, i.e. we
          // have a parameter where the argument is empty
          paramName = s;
          paramValue = "";
          break;
        } else if ( s [ j ] == '=' ) {
          // we encountered a '=' character. everything
          // before is the name of the parameter,
          // everything after is the value.
          paramName = s.substr(0, j);
          paramValue = s.substr(j + 1);
          break;
        } else if ( s [ j ] == '-' ) {
          // remove all "-" characters and capitalize the character after them
          s.erase(j, 1);
          if ( s.size() == j ) {
            std :: ostringstream oss;
            oss << "Parameter name of argument " << i << " ('" << argv [ i ] << "')"
                << " is invalid (ends with a '-' character).";
            return oss.str();
          } else if ( s [ j ] == '-' ) {
            std :: ostringstream oss;
            oss << "Malformed parameter name in argument " << i << " ('" << argv [ i ] << "'): "
                << "'--' in parameter name.";
            return oss.str();
          }

          s [ j ] = std :: toupper(s [ j ]);
        } else if ( !std :: isalnum(s [ j ]) ) {
          std :: ostringstream oss;
          oss << "Parameter name of argument " << i << " ('" << argv [ i ] << "')"
              << " is invalid (character '" << s [ j ] << "' is not a letter or digit).";
          return oss.str();
        }

        ++j;
      }
    } else {
      // read a -myOpt abc option for the parameter "MyOpt" with a value of "abc"
      paramName = argv [ i ] + 1;

      if ( argc == i + 1 || argv [ i + 1 ] [ 0 ] == '-' ) {
        std :: ostringstream oss;
        oss << "No argument given for parameter '" << argv [ i ] << "'!";
        return oss.str();
      }

      paramValue = argv [ i + 1 ];
      ++i;       // In the case of '-myOpt abc' each pair counts as two arguments
    }

    // capitalize first letter of parameter name
    paramName [ 0 ] = std :: toupper(paramName [ 0 ]);

    // Put the key=value pair into the parameter tree
    paramTree [ paramName ] = paramValue;
  }

  return "";
}
}  /* namespace msbGrid*/

#endif  /* #ifndef _COMMAND_LINE_READER_HH_ */