arguments.cpp

Go to the documentation of this file.
00001 /*
00002   CLAW - a C++ Library Absolutely Wonderful
00003 
00004   CLAW is a free library without any particular aim but being useful to 
00005   anyone.
00006 
00007   Copyright (C) 2005-2008 Julien Jorge
00008 
00009   This library is free software; you can redistribute it and/or
00010   modify it under the terms of the GNU Lesser General Public
00011   License as published by the Free Software Foundation; either
00012   version 2.1 of the License, or (at your option) any later version.
00013 
00014   This library is distributed in the hope that it will be useful,
00015   but WITHOUT ANY WARRANTY; without even the implied warranty of
00016   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017   Lesser General Public License for more details.
00018 
00019   You should have received a copy of the GNU Lesser General Public
00020   License along with this library; if not, write to the Free Software
00021   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
00022 
00023   contact: julien_jorge@yahoo.fr
00024 */
00030 #include <sstream>
00031 #include <claw/arguments.hpp>
00032 #include <claw/assert.hpp>
00033 
00034 /*----------------------------------------------------------------------------*/
00038 claw::arguments::arguments()
00039   : m_program_name("<unknow>")
00040 {
00041 
00042 } // arguments::arguments()
00043 
00044 /*----------------------------------------------------------------------------*/
00053 claw::arguments::arguments( int& argc, char** &argv )
00054 {
00055   parse(argc, argv);
00056 } // arguments::arguments()
00057 
00058 /*----------------------------------------------------------------------------*/
00068 claw::arguments::arguments(int& argc, char** &argv,
00069                            const claw::math::ordered_set<std::string>& allowed )
00070 
00071 {
00072   parse(argc, argv, allowed);
00073 } // arguments::arguments()
00074 
00075 /*----------------------------------------------------------------------------*/
00083 void claw::arguments::parse( int& argc, char** &argv )
00084 {
00085   bool stop = false;
00086   int base = 0;
00087 
00088   if (m_program_name == "")
00089     {
00090       m_program_name = argv[0];
00091       argv[0] = NULL;
00092       base = 1;
00093     }
00094 
00095   for (int argi=base; (argi!=argc) && !stop; ++argi)
00096     {
00097       std::string arg(argv[argi]);
00098 
00099       if ( (arg[0] == '-') && (arg.length() > 1) )
00100         {
00101           if (arg == "--")
00102             stop = true;
00103           else
00104             {
00105               add_argument( arg );
00106               argv[argi] = NULL;
00107             }
00108         }
00109     }
00110 
00111   remove_null_arguments( argc, argv );
00112 } // arguments::parse()
00113 
00114 /*----------------------------------------------------------------------------*/
00123 void claw::arguments::parse
00124 ( int& argc, char** &argv,
00125   const claw::math::ordered_set<std::string>& allowed )
00126 {
00127   bool stop = false;
00128   int base = 0;
00129 
00130   if (m_program_name == "")
00131     {
00132       m_program_name = argv[0];
00133       argv[0] = NULL;
00134       base = 1;
00135     }
00136 
00137   for (int argi=base; (argi!=argc) && !stop; ++argi)
00138     {
00139       std::string arg(argv[argi]);
00140 
00141       if ( (arg[0] == '-') && (arg.length() > 1) )
00142         {
00143           if (arg == "--")
00144             stop = true;
00145           else
00146             {
00147               std::string name, value;
00148               split_argument( arg, name, value );
00149 
00150               if ( allowed.find( name ) != allowed.end() )
00151                 {
00152                   add_argument( arg );
00153                   argv[argi] = NULL;
00154                 }
00155             }
00156         }
00157     }
00158 
00159   remove_null_arguments( argc, argv );
00160 } // arguments::parse()
00161 
00162 /*----------------------------------------------------------------------------*/
00167 bool claw::arguments::has_value( const std::string& arg_name ) const
00168 {
00169   return m_pairs.find( arg_name ) != m_pairs.end();
00170 } // arguments::has_value()
00171 
00172 /*----------------------------------------------------------------------------*/
00176 const std::string& claw::arguments::get_program_name() const
00177 {
00178   return m_program_name;
00179 } // arguments::get_program_name()
00180 
00181 /*----------------------------------------------------------------------------*/
00186 bool claw::arguments::get_bool( const std::string& arg_name ) const
00187 {
00188   return m_flags.find( arg_name ) != m_flags.end();
00189 } // arguments::get_bool()
00190 
00191 /*----------------------------------------------------------------------------*/
00197 int claw::arguments::get_integer( const std::string& arg_name ) const
00198 {
00199   CLAW_ASSERT( has_value(arg_name),
00200                "arguments::get_integer(): argument is not set." );
00201 
00202   std::istringstream iss( m_pairs.find( arg_name )->second );
00203   int val;
00204   iss >> val;
00205 
00206   return val;
00207 } // arguments::get_integer()
00208 
00209 /*----------------------------------------------------------------------------*/
00215 double claw::arguments::get_real( const std::string& arg_name ) const
00216 {
00217   CLAW_ASSERT( has_value(arg_name),
00218                "arguments::get_real(): argument is not set." );
00219 
00220   std::istringstream iss( m_pairs.find( arg_name )->second );
00221   double val;
00222   iss >> val;
00223 
00224   return val;
00225 } // arguments::get_real()
00226 
00227 /*----------------------------------------------------------------------------*/
00233 const std::string&
00234 claw::arguments::get_string( const std::string& arg_name ) const
00235 {
00236   CLAW_ASSERT( has_value(arg_name),
00237                "arguments::get_string(): argument is not set." );
00238 
00239   return m_pairs.find( arg_name )->second;
00240 } // arguments::get_string()
00241 
00242 /*----------------------------------------------------------------------------*/
00252 void claw::arguments::add_argument( const std::string& arg )
00253 {
00254   CLAW_ASSERT( arg != "--", "arguments::add_argument(): arg can't be '--'" );
00255   CLAW_ASSERT( arg[0] == '-',
00256                "arguments::add_argument(): arg must begin by '-'" );
00257   
00258   std::string name, value;
00259   split_argument(arg, name, value);
00260 
00261   if ( value == "" )
00262     m_flags.insert( arg );
00263   else
00264     m_pairs[ name ] = value;
00265 } // arguments::add_argument()
00266 
00267 /*----------------------------------------------------------------------------*/
00275 void claw::arguments::split_argument( const std::string& arg, std::string& name,
00276                                       std::string& value ) const
00277 {
00278   CLAW_ASSERT( arg != "--", "arguments::split_argument(): arg can't be '--'" );
00279   CLAW_ASSERT( arg[0] == '-',
00280                "arguments::split_argument(): arg must begin by '-'" );
00281   
00282   std::string::size_type pos = arg.find("=");
00283 
00284   if ( pos == std::string::npos )
00285     {
00286       name = arg;
00287       value = "";
00288     }
00289   else
00290     {
00291       name = arg.substr(0, pos);
00292       value = arg.substr(pos+1, arg.length() - pos - 1);
00293     }
00294 } // arguments::split_argument()
00295 
00296 /*----------------------------------------------------------------------------*/
00302 void claw::arguments::remove_null_arguments( int& argc, char** &argv ) const
00303 {
00304   unsigned int c=0; // number of non-NULL arguments
00305   
00306   for (int i=0; i!=argc; ++i)
00307     if ( argv[i] != NULL )
00308       ++c;
00309     else
00310       {
00311         bool ok = false;
00312         int j=i;
00313         
00314         while ( (j!=argc) && !ok )
00315           if ( argv[j] == NULL )
00316             ++j;
00317           else
00318             ok = true;
00319 
00320         if (ok)
00321           {
00322             argv[i] = argv[j];
00323             argv[j] = NULL;
00324             ++c;
00325           }
00326       }
00327 
00328   if ( c > 0 )
00329     if ( (std::string(argv[c-1]) == "--") )
00330       --c;
00331     
00332   argc=c;
00333 } // arguments::remove_null_arguments()

Generated on Thu Jun 26 09:35:03 2008 for CLAW Library (a C++ Library Absolutely Wonderful) by  doxygen 1.5.6