src/OpenFOAM/global/argList/argList.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software; you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM; if not, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 Class
  26     Foam::argList
  27
  28 Description
  29     Extract command arguments and options from the supplied
  30     @a argc and @a argv parameters.
  31
  32     Sequences with "(" ... ")" are transformed into a stringList.
  33     For example,
  34     @verbatim
  35         program -listFiles \( *.txt \)
  36     @endverbatim
  37     would create a stringList:
  38     @verbatim
  39         ( "file1.txt" "file2.txt" ... "fileN.txt" )
  40     @endverbatim
  41     The backslash-escaping has been used to avoid shell expansions.
  42
  43     @par Default command-line options
  44     @param -case \<dir\> \n
  45         select an case directory instead of the current working directory
  46     @param -parallel \n
  47         specify case as a parallel job
  48     @param -doc \n
  49         display the documentation in browser
  50     @param -srcDoc \n
  51         display the source documentation in browser
  52     @param -help \n
  53        print the usage
  54
  55     The environment variable @b FOAM_CASE is set to the path of the
  56     global case (same for serial and parallel jobs).
  57     The environment variable @b FOAM_CASENAME is set to the name of the
  58     global case.
  59
  60 Note
  61     - Adjustment of the valid (mandatory) arguments
  62       by directly manipulating the static member argList::validArgs.
  63     - Adjustment of the valid options
  64       by directly manipulating the static member argList::validOptions.
  65
  66 SourceFiles
  67     argList.C
  68
  69 \*---------------------------------------------------------------------------*/
  70
  71 #ifndef argList_H
  72 #define argList_H
  73
  74 #include "stringList.H"
  75 #include "SubList.H"
  76 #include "SLList.H"
  77 #include "HashTable.H"
  78 #include "word.H"
  79 #include "fileName.H"
  80 #include "parRun.H"
  81 #include "IStringStream.H"
  82
  83 #include "sigFpe.H"
  84 #include "sigInt.H"
  85 #include "sigQuit.H"
  86 #include "sigSegv.H"
  87
  88 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  89
  90 namespace Foam
  91 {
  92
  93 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  94
  95 class argList
  96 {
  97     // Private data
  98         static bool bannerEnabled;
  99
 100         stringList args_;
 101         HashTable<string> options_;
 102
 103         word executable_;
 104         fileName rootPath_;
 105         fileName globalCase_;
 106         fileName case_;
 107
 108         ParRunControl parRunControl_;
 109
 110         // Signal handlers
 111         sigFpe sigFpe_;
 112         sigInt sigInt_;
 113         sigQuit sigQuit_;
 114         sigSegv sigSegv_;
 115
 116
 117     // Private member functions
 118
 119         void getRootCase();
 120
 121         //- Transcribe argv into internal args_
 122         //  return true if any "(" ... ")" sequences were captured
 123         bool regroupArgv(int& argc, char**& argv);
 124
 125
 126 public:
 127
 128     // Static data members
 129
 130         //- A list of valid (mandatory) arguments
 131         static SLList<string> validArgs;
 132
 133         //- A list of valid options
 134         static HashTable<string> validOptions;
 135
 136         //- A list of valid parallel options
 137         static HashTable<string> validParOptions;
 138
 139         //! @cond ignoreDocumentation
 140         class initValidTables
 141         {
 142         public:
 143
 144             initValidTables();
 145         };
 146         //! @endcond ignoreDocumentation
 147
 148
 149     // Constructors
 150
 151         //- Construct from argc and argv
 152         //  checking the arguments and options as requested
 153         argList
 154         (
 155             int& argc,
 156             char**& argv,
 157             bool checkArgs=true,
 158             bool checkOpts=true
 159         );
 160
 161
 162     // Destructor
 163
 164         virtual ~argList();
 165
 166
 167     // Member functions
 168
 169         // Access
 170
 171             //- Name of executable
 172             const word& executable() const
 173             {
 174                 return executable_;
 175             }
 176
 177             //- Return root path
 178             const fileName& rootPath() const
 179             {
 180                 return rootPath_;
 181             }
 182
 183             //- Return case name
 184             const fileName& globalCaseName() const
 185             {
 186                 return globalCase_;
 187             }
 188
 189             //- Return case name (parallel run) or global case (serial run)
 190             const fileName& caseName() const
 191             {
 192                 return case_;
 193             }
 194
 195             //- Return the path
 196             fileName path() const
 197             {
 198                 return rootPath()/caseName();
 199             }
 200
 201             //- Return arguments
 202             const stringList& args() const
 203             {
 204                 return args_;
 205             }
 206
 207             //- Return additionl arguments,
 208             //  i.e. those additional to the executable itself
 209             stringList::subList additionalArgs() const;
 210
 211             //- Return options
 212             const Foam::HashTable<string>& options() const
 213             {
 214                 return options_;
 215             }
 216
 217             //- Return the argument string associated with the named option
 218             const string& option(const word& opt) const
 219             {
 220                 return options_.operator[](opt);
 221             }
 222
 223             //- Return true if the named option is found
 224             bool optionFound(const word& opt) const
 225             {
 226                 return options_.found(opt);
 227             }
 228
 229             //- Return an IStringStream to the named option
 230             IStringStream optionLookup(const word& opt) const
 231             {
 232                 return IStringStream(option(opt));
 233             }
 234
 235             //- Read a value from the named option
 236             template<class T>
 237             T optionRead(const word& opt) const
 238             {
 239                 T val;
 240                 optionLookup(opt)() >> val;
 241                 return val;
 242             }
 243
 244             //- Read a value from the named option if present.
 245             //  Return true if the named option was found.
 246             template<class T>
 247             bool optionReadIfPresent(const word& opt, T& val) const
 248             {
 249                 if (optionFound(opt))
 250                 {
 251                     optionLookup(opt)() >> val;
 252                     return true;
 253                 }
 254                 else
 255                 {
 256                     return false;
 257                 }
 258             }
 259
 260             //- Read a List of values from the named option
 261             template<class T>
 262             List<T> optionReadList(const word& opt) const
 263             {
 264                 return readList<T>(optionLookup(opt)());
 265             }
 266
 267
 268         // Edit
 269
 270             //- Disable emitting the banner information
 271             static void noBanner();
 272
 273             //- Remove the parallel options
 274             static void noParallel();
 275
 276
 277         // Print
 278
 279             //- Print usage
 280             void printUsage() const;
 281
 282             //- Display documentation in browser
 283             //  Optionally display the application source code
 284             void displayDoc(bool source=false) const;
 285
 286
 287         // Check
 288
 289             //- Check argument list
 290             bool check(bool checkArgs=true, bool checkOpts=true) const;
 291
 292             //- Check root path and case path
 293             bool checkRootCase() const;
 294 };
 295
 296
 297 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 298
 299 } // End namespace Foam
 300
 301 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 302
 303 #endif
 304
 305 // ************************************************************************* //