getpot.h

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

}



inline const char*   
GetPot::get(unsigned Idx, const char* Default) const
{ 
  if( Idx >= argv.size() ) return Default;
  else                     return argv[Idx].c_str();
}



inline unsigned 
GetPot::size() const
{ return argv.size(); }
//     -- next() function group
  inline int  
GetPot::next(int Default)    
{ 
  if( search_failed_f ) return Default;
  cursor++; 
  if( cursor >= argv.size() ) 
  { cursor = argv.size(); return Default; }

  const std::string Remain = __get_remaining_string(argv[cursor], prefix);

  return Remain != "" ? __convert_to_type(Remain, Default) : Default;
}



inline double 
GetPot::next(double Default) 
{ 
  if( search_failed_f ) return Default;
  cursor++;

  if( cursor >= argv.size() ) 
  { cursor = argv.size(); return Default; }

  std::string Remain = __get_remaining_string(argv[cursor], prefix);

  return Remain != "" ? __convert_to_type(Remain, Default) : Default;
}



inline const char*   
GetPot::next(const char* Default) 
{ 
  if( search_failed_f ) return Default;
  cursor++; 

  if( cursor >= argv.size() )
  { cursor = argv.size(); return Default; }

  const std::string Remain = __get_remaining_string(argv[cursor], prefix);

  return Remain != "" ? Remain.c_str() : Default;
}



inline std::string
GetPot::next(const std::string &Default) 
{ 
  if( search_failed_f ) return Default;
  cursor++; 

  if( cursor >= argv.size() )
  { cursor = argv.size(); return Default; }

  const std::string Remain = __get_remaining_string(argv[cursor], prefix);

  return Remain != "" ? Remain : Default;
}



//     -- follow() function group 
//        distinct option to be searched for
inline int 
GetPot::follow(int Default, const char* Option) 
{ 
  if( search(Option) == false ) return Default;
  return next(Default);
}



inline double  
GetPot::follow(double Default, const char* Option)
{ 
  if( search(Option) == false ) return Default;
  return next(Default);
}



inline const char* 
GetPot::follow(const char* Default, const char* Option)
{ 
  if( search(Option) == false ) return Default;
  return next(Default);
}



#ifdef GETPOT_ALLOW_VARGS
  //     -- second follow() function group 
  //        multiple option to be searched for
  inline int 
  GetPot::follow(int Default, unsigned No, const char* P, ...) 
  { 
    if( No == 0 ) return Default;
    if( search(P) == true ) return next(Default);
  
    std::va_list ap;
    va_start(ap, P);
    for(unsigned i=1; i<No; i++) {
      char* Opt = va_arg(ap, char *);
      if( search(Opt) == true ) { 
        va_end(ap); 
        return next(Default); 
      }
    }
    va_end(ap); 
    return Default;
  }



  inline double  
  GetPot::follow(double Default, unsigned No, const char* P, ...)
  {
    if( No == 0 ) return Default;
    if( search(P) == true ) return next(Default);
  
    std::va_list ap;
    va_start(ap, P);
    for(unsigned i=1; i<No; i++) {
      char* Opt = va_arg(ap, char *);
      if( search(Opt) == true ) { 
        va_end(ap); 
        return next(Default); 
      }
    }
    va_end(ap); 
    return Default;
  }



  inline const char* 
  GetPot::follow(const char* Default, unsigned No, const char* P, ...)
  {
    if( No == 0 ) return Default;
    if( search(P) == true ) return next(Default);
  
    std::va_list ap;
    va_start(ap, P);
    for(unsigned i=1; i<No; i++) {
      char* Opt = va_arg(ap, char *);
      if( search(Opt) == true ) { 
        va_end(ap); 
        return next(Default); 
      }
    }
    va_end(ap); 
    return Default;
  }

#endif // GETPOT_ALLOW_VARGS



///////////////////////////////////////////////////////////////////////////////
// (*) directly connected options
//.............................................................................
//
inline int
GetPot::direct_follow(int Default, const char* Option) 
{
  const char* FollowStr = __match_starting_string(Option);
  if( FollowStr == 0 )                    return Default;
  if( ++cursor >= argv.size() ) cursor = argv.size();
  return __convert_to_type(FollowStr, Default);
}



inline double 
GetPot::direct_follow(double Default, const char* Option) 
{
  const char* FollowStr = __match_starting_string(Option);
  if( FollowStr == 0 )                   return Default;
  if( ++cursor >= argv.size() ) cursor = argv.size();
  return __convert_to_type(FollowStr, Default);
}



inline const char* 
GetPot::direct_follow(const char* Default, const char* Option)
{
  if( search_failed_f ) return Default;
  const char* FollowStr = __match_starting_string(Option);
  if( FollowStr == 0 )          return Default;
  if( ++cursor >= argv.size() ) cursor = argv.size();
  return FollowStr;
}



inline const char*
GetPot::__match_starting_string(const char* StartString) 
  // pointer  to the place where the string after 
  //          the match inside the found argument starts.
  // 0        no argument matches the starting string.
{
  const unsigned N = std::strlen(StartString);
  unsigned OldCursor = cursor;
  if( OldCursor >= argv.size() ) OldCursor = argv.size() - 1;
  search_failed_f = true;

  // (*) first loop from cursor position until end
  unsigned c = cursor;
  for(; c < argv.size(); c++) {
    if( std::strncmp(StartString, argv[c].c_str(), N) == 0)
    { cursor = c; search_failed_f = false; return &(argv[c].c_str()[N]); }
  }

  if( ! search_loop_f ) return false;

  // (*) second loop from 0 to old cursor position
  for(c = 1; c < OldCursor; c++) {
    if( std::strncmp(StartString, argv[c].c_str(), N) == 0)
    { cursor = c; search_failed_f = false; return &(argv[c].c_str()[N]); }
  }
  return 0;
}



///////////////////////////////////////////////////////////////////////////////
// (*) search for flags
//.............................................................................
//
inline bool
GetPot::options_contain(const char* FlagList) const
{
  // go through all arguments that start with a '-' (but not '--')
  std::string str;
  for(std::vector<std::string>::const_iterator it = argv.begin();
      it != argv.end();
      it++) {
    str = __get_remaining_string(*it, prefix);

    if( str.length() >= 2 && str[0] == '-' && str[1] != '-' )
      if( __check_flags(str, FlagList) ) return true;
  }
  return false;
}



inline bool
GetPot::argument_contains(unsigned Idx, const char* FlagList) const
{
  if( Idx >= argv.size() ) return false;

  if( prefix == "" )
    // search argument for any flag in flag list
    return __check_flags(argv[Idx], FlagList);

  // if a prefix is set, then the argument index is the index
  //   inside the 'namespace'
  // => only check list of arguments that start with prefix
  unsigned no_matches = 0;
  for(unsigned i=0; i<argv.size(); i++) {
    const std::string Remain = __get_remaining_string(argv[i], prefix);
    if( Remain != "") {
      no_matches += 1;
      if( no_matches == Idx)
	return __check_flags(Remain, FlagList);
    }
  }
  // no argument in this namespace
  return false;
}



inline bool
GetPot::__check_flags(const std::string& Str, const char* FlagList) const
{
  for(const char* p=FlagList; *p != '\0' ; p++)
    if( Str.find(*p) != std::string::npos ) return true; // found something
  return false;
}



///////////////////////////////////////////////////////////////////////////////
// (*) nominus arguments
inline std::vector<std::string>  
GetPot::nominus_vector() const
// return vector of nominus arguments
{
  std::vector<std::string> nv;
  for(std::vector<unsigned>::const_iterator it = idx_nominus.begin();
      it != idx_nominus.end();
      it++) {
    nv.push_back(argv[*it]);
  }
  return nv;
}



inline const char* 
GetPot::next_nominus()
{
  if( nominus_cursor < int(idx_nominus.size()) - 1 )
    return argv[idx_nominus[++nominus_cursor]].c_str();
  return 0;
}



inline void 
GetPot::reset_nominus_cursor()
{ nominus_cursor = -1; }



///////////////////////////////////////////////////////////////////////////////
// (*) variables
//.............................................................................
//
inline bool
GetPot::have_variable(const char* VarName) const
{
  const variable* sv = __find_variable(VarName);
  if (sv == 0) return false;
  return true;
}

inline bool
GetPot::operator()(const char* VarName, bool Default) const
{
  const variable* sv = __find_variable(VarName);
  if ( sv == 0 ) return Default;
  return __convert_to_type(sv->original, Default);
}



inline int 
GetPot::operator()(const char* VarName, int Default) const
{
  const variable*  sv = __find_variable(VarName);
  if( sv == 0 ) return Default;
  return __convert_to_type(sv->original, Default);
}



inline double
GetPot::operator()(const char* VarName, double Default) const
{
  const variable*  sv = __find_variable(VarName);
  if( sv == 0 ) return Default;
  return __convert_to_type(sv->original, Default);
}



inline long double
GetPot::operator()(const char* VarName, long double Default) const
{
  const variable*  sv = __find_variable(VarName);
  if( sv == 0 ) return Default;
  return __convert_to_type(sv->original, Default);
}



inline const char*
GetPot::operator()(const char* VarName, const char* Default) const
{
  const variable*  sv = __find_variable(VarName);
  if( sv == 0 ) return Default;
  return sv->original.c_str();
}



inline std::string
GetPot::operator()(const char* VarName, const std::string& Default) const
{
  const variable*  sv = __find_variable(VarName);
  if( sv == 0 ) return Default;
  return sv->original;
}



inline int 
GetPot::operator()(const char* VarName, int Default, unsigned Idx) const
{
  const variable* sv = __find_variable(VarName);
  if( sv == 0 ) return Default;
  const std::string*  element = sv->get_element(Idx);
  if( element == 0 ) return Default;
  return __convert_to_type(*element, Default);
}



inline double
GetPot::operator()(const char* VarName, double Default, unsigned Idx) const
{
  const variable* sv = __find_variable(VarName);
  if( sv == 0 ) return Default;
  const std::string*  element = sv->get_element(Idx);
  if( element == 0 ) return Default;
  return __convert_to_type(*element, Default);
}