getpot.h

一个用来实现偏微分方程中网格的计算库

// $Id: getpot.h 2946 2008-07-30 22:09:25Z jwpeterson $
//
// (with patches from Michael Anderson for more general variable types)

//  -*- c++ -*- 
//  GetPot Version 1.0                                        Sept/13/2002
//  
//  WEBSITE: http://getpot.sourceforge.net
//  
//  This library is  free software; you can redistribute  it and/or modify
//  it  under  the terms  of  the GNU  Lesser  General  Public License  as
//  published by the  Free Software Foundation; either version  2.1 of the
//  License, or (at your option) any later version.
//  
//  This library  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
//  Lesser General Public License for more details.
//  
//  You  should have  received a  copy of  the GNU  Lesser  General Public
//  License along  with this library; if  not, write to  the Free Software
//  Foundation, Inc.,  59 Temple Place,  Suite 330, Boston,  MA 02111-1307
//  USA
//  
//  (C) 2001-2002 Frank R. Schaefer  
//==========================================================================
#ifndef __GETPOT_H__
#define __GETPOT_H__

#if defined(WIN32) || defined(SOLARIS_RAW) || defined(__SUNPRO_CC) || (__GNUC__ == 2) || defined(__HP_aCC) || defined (__CYGWIN__)
#  define strtok_r(a, b, c) std::strtok(a, b)
#endif // WINDOWS or SOLARIS or gcc 2.* or HP aCC or CYGWIN


#define GETPOT_ALLOW_VARGS

#include <cctype> 
#include <cstdio>
#include <cstring>

#ifdef GETPOT_ALLOW_VARGS
#  include <cstdarg>
#endif


#include <math.h>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <fstream>


#define victorate(TYPE, VARIABLE, ITERATOR) \
for(std::vector<TYPE>::const_iterator (ITERATOR) = (VARIABLE).begin(); \
    (ITERATOR) != (VARIABLE).end(); ++(ITERATOR))


class GetPot {
  //--------
  inline void __basic_initialization();
  public:
  // (*) constructors, destructor, assignment operator -----------------------
  inline GetPot();
  inline GetPot(const GetPot&);
  inline GetPot(int argc_, char ** argv_);
  inline GetPot(const char* FileName);
  inline GetPot(const std::string &FileName);
  inline ~GetPot();
  inline GetPot& operator=(const GetPot&);

  // (*) parse methods for command line & input files ------------------------
  inline void         parse_command_line (int argc_, char ** argv_);
  inline void         parse_input_file   (const std::string& FileName);
  inline void         parse_input_file   (const char* FileName);
  
  // (*) direct access to command line arguments -----------------------------
  inline const char*  operator[](unsigned Idx) const;
  inline int          get(unsigned Idx, int         Default) const;
  inline double       get(unsigned Idx, double      Default) const;
  inline const char*  get(unsigned Idx, const char* Default) const;
  inline unsigned     size() const; 

  // (*) flags ---------------------------------------------------------------
  inline bool         options_contain(const char* FlagList) const;
  inline bool         argument_contains(unsigned Idx, const char* FlagList) const;

  // (*) variables -----------------------------------------------------------
  //     -- check for a variable
  inline bool         have_variable (const char* VarName) const;
  //     -- scalar values
  inline bool         operator()(const char* VarName, bool        Default) const;
  inline int          operator()(const char* VarName, int         Default) const;
  inline double       operator()(const char* VarName, double      Default) const;
  inline long double  operator()(const char* VarName, long double Default) const;
  inline const char*  operator()(const char* VarName, const char* Default) const;
  inline std::string  operator()(const char* VarName, const std::string& Default) const;
  //     -- vectors
  inline int          operator()(const char* VarName, int         Default, unsigned Idx) const;
  inline double       operator()(const char* VarName, double      Default, unsigned Idx) const;
  inline const char*  operator()(const char* VarName, const char* Default, unsigned Idx) const;
  inline unsigned     vector_variable_size(const char* VarName) const;
  inline std::vector<std::string> get_variable_names() const;
  inline std::vector<std::string> get_section_names() const;


  // (*) cursor oriented functions -------------------------------------------
  inline void         set_prefix(const char* Prefix) { prefix = std::string(Prefix); }
  inline void         set_prefix(const std::string & Prefix) { prefix = Prefix; }
  inline bool         search_failed() const { return search_failed_f; }

  //     -- enable/disable search for an option in loop
  inline void         disable_loop() { search_loop_f = false; }
  inline void         enable_loop()  { search_loop_f = true; }

  //     -- reset cursor to position '1'
  inline void         reset_cursor();
  inline void         init_multiple_occurrence();

  //     -- search for a certain option and set cursor to position
  inline bool         search(const char* option);
  inline bool         search(const std::string &option);


#ifdef GETPOT_ALLOW_VARGS
  // TODO:    BAD USING VARGS
    inline bool         search(unsigned No, const char* P, ...);
#endif

  //     -- get argument at cursor++
  inline int          next(int           Default);
  inline double       next(double Default);
  inline const char*  next(const char*   Default);
  inline std::string  next(const std::string   &Default);
  
  //     -- search for option and get argument at cursor++
  inline int          follow(int           Default, const char* Option);
  inline double       follow(double Default, const char* Option);
  inline const char*  follow(const char*   Default, const char* Option);

  //     -- search for one of the given options and get argument that follows it
#ifdef GETPOT_ALLOW_VARGS
  // TODO:    BAD USING VARGS
  inline int          follow(int           Default, unsigned No, const char* Option, ...);
  inline double       follow(double Default, unsigned No, const char* Option, ...);
  inline const char*  follow(const char*   Default, unsigned No, const char* Option, ...);
#endif

  //     -- directly followed arguments 
  inline int          direct_follow(int           Default, const char* Option);
  inline double       direct_follow(double Default, const char* Option);
  inline const char*  direct_follow(const char*   Default, const char* Option);

  // (*) nominus arguments ---------------------------------------------------
  inline void                      reset_nominus_cursor();
  inline std::vector<std::string>  nominus_vector() const;
  inline unsigned                  nominus_size() const  { return idx_nominus.size(); }
  inline const char*               next_nominus();

  // (*) unidentified flying objects -----------------------------------------
  inline std::vector<std::string>  unidentified_arguments(const std::vector<std::string>& Knowns) const;
  inline std::vector<std::string>  unidentified_options(const std::vector<std::string>& Knowns) const;
  inline std::vector<std::string>  unidentified_variables(const std::vector<std::string>& Knowns) const;
  inline std::vector<std::string>  unidentified_sections(const std::vector<std::string>& Knowns) const;
  inline std::vector<std::string>  unidentified_nominuses(const std::vector<std::string>& Knowns) const;
  
  inline std::string  unidentified_flags(const char* Known, 
                                         int ArgumentNumber /* =-1 */) const;
#ifdef GETPOT_ALLOW_VARGS
  // TODO:    BAD USING VARGS
  inline std::vector<std::string>  unidentified_arguments(unsigned Number, const char* Known, ...) const;
  inline std::vector<std::string>  unidentified_options(unsigned Number, const char* Known, ...) const;
  inline std::vector<std::string>  unidentified_variables(unsigned Number, const char* Known, ...) const;
  inline std::vector<std::string>  unidentified_sections(unsigned Number, const char* Known, ...) const;
  inline std::vector<std::string>  unidentified_nominuses(unsigned Number, const char* Known, ...) const;
#endif

  // (*) output --------------------------------------------------------------
  inline int print() const;

  private:
  // (*) Type Declaration ----------------------------------------------------
  struct variable {
    //-----------
    // Variable to be specified on the command line or in input files.
    // (i.e. of the form var='12 312 341')

    // -- constructors, destructors, assignment operator
    variable();
    variable(const variable&);
    variable(const char* Name, const char* Value);
    ~variable();
    variable& operator=(const variable& Other);

    void      take(const char* Value);

    // -- get a specific element in the string vector
    //    (return 0 if not present)
    const std::string*  get_element(unsigned Idx) const;

    // -- data memebers
    std::string         name;      // identifier of variable
    std::vector<std::string> value;     // value of variable stored in vector
    std::string         original;  // value of variable as given on command line
  };

  // (*) member variables --------------------------------------------------------------
  std::string          prefix;          // prefix automatically added in queries
  std::string          section;         // (for dollar bracket parsing)
  std::vector<std::string>  section_list;    // list of all parsed sections
  //     -- argurment vector 
  std::vector<std::string>  argv;            // vector of command line arguments stored as strings
  unsigned        cursor;          // cursor for argv
  bool            search_loop_f;   // shall search start at beginning after
  //                               // reaching end of arg array ?
  bool            search_failed_f; // flag indicating a failed search() operation
  //                               // (e.g. next() functions react with 'missed')

  //     --  nominus vector 
  int              nominus_cursor; // cursor for nominus_pointers
  std::vector<unsigned> idx_nominus;     // indecies of 'no minus' arguments

  //    -- intern variables 
  //       (arguments of the form "variable=value")
  std::vector<variable> variables; 

  // (*) helper functions ----------------------------------------------------
  //     -- produce three basic data vectors:
  //          - argument vector
  //          - nominus vector
  //          - variable dictionary
  inline void          __parse_argument_vector(const std::vector<std::string>& ARGV);

  //     -- helpers for argument list processing
  //        * search for a variable in 'variables' array
  inline const variable*  __find_variable(const char*) const;
  //        * support finding directly followed arguments
  inline const char*   __match_starting_string(const char* StartString);
  //        * support search for flags in a specific argument
  inline bool          __check_flags(const std::string& Str, const char* FlagList) const;
  //        * type conversion if possible     
  inline int      __convert_to_type(const std::string& String, int Default) const;
  inline double   __convert_to_type(const std::string& String, double Default) const;
  inline long double   __convert_to_type(const std::string& String, long double Default) const;
  inline bool     __convert_to_type(const std::string& String, bool Default) const;

  //        * prefix extraction
  const std::string    __get_remaining_string(const std::string& String, const std::string& Start) const;
  //        * search for a specific string
  inline bool          __search_string_vector(const std::vector<std::string>& Vec, 
      const std::string& Str) const;    

  //     -- helpers to parse input files
  //        create an argument vector based on data found in an input file, i.e.:
  //           1) delete '#'-comments 
  //           2) contract assignment expressions, such as
  //                   my-variable   =    '007 J. B.'
  //             into 
  //                   my-variable='007 J. B.'
  //           3) interprete sections like '[../my-section]' etc.
  inline void               __skip_whitespace(std::istream& istr);
  inline const std::string  __get_next_token(std::istream& istr);
  inline const std::string  __get_string(std::istream& istr);
  inline const std::string  __get_until_closing_bracket(std::istream& istr);

  inline std::vector<std::string> __read_in_stream(std::istream& istr);
  inline std::vector<std::string> __read_in_file(const char* FileName);
  inline std::string              __process_section_label(const std::string& Section, 
      std::vector<std::string>& section_stack);

  //      -- dollar bracket expressions
  std::string                   __DBE_expand_string(const std::string& str);
  std::string                   __DBE_expand(const std::string& str);
  const GetPot::variable*  __DBE_get_variable(const std::string& str);
  std::vector<std::string>           __DBE_get_expr_list(const std::string& str, const unsigned ExpectedNumber);

  std::string  __double2string(double Value) const { 
    char* tmp = new char[128];
    std::sprintf(tmp, "%e", Value);
    std::string result(tmp);
    delete [] tmp;
    return result;
  }
  std::string  __int2string(const int& Value) const { 
    char* tmp = new char[128];
    std::sprintf(tmp, "%i", Value);
    std::string result(tmp);
    delete [] tmp;
    return result;
  }
};


///////////////////////////////////////////////////////////////////////////////
// (*) constructors, destructor, assignment operator
//.............................................................................
//
inline void
GetPot::__basic_initialization()
{
  cursor = 0;              nominus_cursor = -1;
  search_failed_f = true;  search_loop_f = true;
  prefix = "";             section = "";      
}



inline 
GetPot::GetPot()
{
  __basic_initialization();
}



inline 
GetPot::GetPot(int argc_, char ** argv_)
{
  parse_command_line (argc_, argv_);
}



inline 
GetPot::GetPot(const char* FileName)
{
  parse_input_file (FileName);
}



inline 
GetPot::GetPot(const std::string &FileName)
{
  parse_input_file (FileName);
}



inline 
GetPot::GetPot(const GetPot& Other)
{
  GetPot::operator=(Other);
}



inline 
GetPot::~GetPot()
{
}



inline
void GetPot::parse_command_line (int argc_, char ** argv_)
{
  __basic_initialization();

  // -- make an internal copy of the argument list:
  std::vector<std::string> __argv;
  __argv.reserve (argc_);
  
  for(int i=0; i<argc_; i++) {
    std::string tmp(argv_[i]);
    __argv.push_back(tmp);
  }
  __parse_argument_vector(__argv); 
}



inline
void GetPot::parse_input_file (const std::string& FileName)
{
  __basic_initialization();

  std::vector<std::string> __argv;
  __argv.push_back(FileName); 
  std::vector<std::string> args = __read_in_file(FileName.c_str());
  __argv.insert(__argv.begin()+1, args.begin(), args.end());
  __parse_argument_vector(__argv); 
}



inline
void GetPot::parse_input_file (const char* FileName)
{
  __basic_initialization();

  std::vector<std::string> __argv;
  __argv.push_back(FileName); 
  std::vector<std::string> args = __read_in_file(FileName);
  __argv.insert(__argv.begin()+1, args.begin(), args.end());
  __parse_argument_vector(__argv); 
}



inline GetPot&
GetPot::operator=(const GetPot& Other)
{
  if (&Other != this) {
    argv            = Other.argv;
    variables       = Other.variables;
    cursor          = Other.cursor;
    nominus_cursor  = Other.nominus_cursor;
    search_failed_f = Other.search_failed_f;
    idx_nominus     = Other.idx_nominus;
    search_loop_f   = Other.search_loop_f;
  }
  return *this;
}



inline void
GetPot::__parse_argument_vector(const std::vector<std::string>& ARGV)
{
  // build internal databases:
  //   1) array with no-minus arguments (usually used as filenames)
  //   2) variable assignments:
  //             'variable name' '=' number | string
  section = "";
  std::vector<std::string>  section_stack;
  unsigned i=0;
  std::vector<std::string>::const_iterator it     = ARGV.begin();
  std::vector<std::string>::const_iterator it_end = ARGV.end();
  argv.push_back(*it);