tclap: UnlabeledMultiArg.h Source File

00001
00002 /****************************************************************************** 
00003  * 
00004  *  file:  UnlabeledMultiArg.h
00005  * 
00006  *  Copyright (c) 2003, Michael E. Smoot.
00007  *  All rights reverved.
00008  * 
00009  *  See the file COPYING in the top directory of this distribution for
00010  *  more information.
00011  *  
00012  *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS 
00013  *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
00014  *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
00015  *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
00016  *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
00017  *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
00018  *  DEALINGS IN THE SOFTWARE.  
00019  *  
00020  *****************************************************************************/ 
00021 
00022 
00023 #ifndef TCLAP_MULTIPLE_UNLABELED_ARGUMENT_H
00024 #define TCLAP_MULTIPLE_UNLABELED_ARGUMENT_H
00025 
00026 #include <string>
00027 #include <vector>
00028 
00029 #include <tclap/MultiArg.h>
00030 #include <tclap/OptionalUnlabeledTracker.h>
00031 
00032 namespace TCLAP {
00033 
00039 template<class T>
00040 class UnlabeledMultiArg : public MultiArg<T>
00041 {
00042 
00043     // If compiler has two stage name lookup (as gcc >= 3.4 does)
00044     // this is requried to prevent undef. symbols
00045     using MultiArg<T>::_ignoreable;
00046     using MultiArg<T>::_hasBlanks;
00047     using MultiArg<T>::_extractValue;
00048     using MultiArg<T>::_typeDesc;
00049     using MultiArg<T>::_name;
00050     using MultiArg<T>::_description;
00051     using MultiArg<T>::_alreadySet;
00052     using MultiArg<T>::toString;
00053 
00054     public:
00055         
00073         UnlabeledMultiArg( const std::string& name,
00074                            const std::string& desc,
00075                            bool req,
00076                            const std::string& typeDesc,
00077                            bool ignoreable = false,
00078                            Visitor* v = NULL );
00097         UnlabeledMultiArg( const std::string& name,
00098                            const std::string& desc,
00099                            bool req,
00100                            const std::string& typeDesc,
00101                            CmdLineInterface& parser,
00102                            bool ignoreable = false,
00103                            Visitor* v = NULL );
00104                          
00120         UnlabeledMultiArg( const std::string& name,
00121                            const std::string& desc,
00122                            bool req,
00123                            Constraint<T>* constraint,
00124                            bool ignoreable = false,
00125                            Visitor* v = NULL );
00126 
00143         UnlabeledMultiArg( const std::string& name,
00144                            const std::string& desc, 
00145                            bool req,
00146                            Constraint<T>* constraint,
00147                            CmdLineInterface& parser,
00148                            bool ignoreable = false,
00149                            Visitor* v = NULL );
00150                          
00159         virtual bool processArg(int* i, std::vector<std::string>& args);
00160 
00165         virtual std::string shortID(const std::string& val="val") const;
00166 
00171         virtual std::string longID(const std::string& val="val") const;
00172 
00177         virtual bool operator==(const Arg& a) const;
00178 
00183         virtual void addToList( std::list<Arg*>& argList ) const;
00184 };
00185 
00186 template<class T>
00187 UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string& name,
00188                                         const std::string& desc, 
00189                                         bool req,
00190                                         const std::string& typeDesc,
00191                                         bool ignoreable,
00192                                         Visitor* v)
00193 : MultiArg<T>("", name, desc,  req, typeDesc, v)
00194 { 
00195     _ignoreable = ignoreable;
00196     OptionalUnlabeledTracker::check(true, toString());
00197 }
00198 
00199 template<class T>
00200 UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string& name,
00201                                         const std::string& desc, 
00202                                         bool req,
00203                                         const std::string& typeDesc,
00204                                         CmdLineInterface& parser,
00205                                         bool ignoreable,
00206                                         Visitor* v)
00207 : MultiArg<T>("", name, desc,  req, typeDesc, v)
00208 { 
00209     _ignoreable = ignoreable;
00210     OptionalUnlabeledTracker::check(true, toString());
00211     parser.add( this );
00212 }
00213 
00214 
00215 template<class T>
00216 UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string& name,
00217                                         const std::string& desc, 
00218                                         bool req,
00219                                         Constraint<T>* constraint,
00220                                         bool ignoreable,
00221                                         Visitor* v)
00222 : MultiArg<T>("", name, desc,  req, constraint, v)
00223 { 
00224     _ignoreable = ignoreable;
00225     OptionalUnlabeledTracker::check(true, toString());
00226 }
00227 
00228 template<class T>
00229 UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string& name,
00230                                         const std::string& desc, 
00231                                         bool req,
00232                                         Constraint<T>* constraint,
00233                                         CmdLineInterface& parser,
00234                                         bool ignoreable,
00235                                         Visitor* v)
00236 : MultiArg<T>("", name, desc,  req, constraint, v)
00237 { 
00238     _ignoreable = ignoreable;
00239     OptionalUnlabeledTracker::check(true, toString());
00240     parser.add( this );
00241 }
00242 
00243 
00244 template<class T>
00245 bool UnlabeledMultiArg<T>::processArg(int *i, std::vector<std::string>& args)
00246 {
00247 
00248     if ( _hasBlanks( args[*i] ) )
00249         return false;
00250 
00251     // never ignore an unlabeled multi arg
00252 
00253 
00254     // always take the first value, regardless of the start string 
00255     _extractValue( args[(*i)] );
00256 
00257     /*
00258     // continue taking args until we hit the end or a start string 
00259     while ( (unsigned int)(*i)+1 < args.size() &&
00260             args[(*i)+1].find_first_of( Arg::flagStartString() ) != 0 &&
00261             args[(*i)+1].find_first_of( Arg::nameStartString() ) != 0 ) 
00262         _extractValue( args[++(*i)] );
00263     */
00264 
00265     _alreadySet = true;
00266 
00267     return true;
00268 }
00269 
00270 template<class T>
00271 std::string UnlabeledMultiArg<T>::shortID(const std::string& val) const
00272 {
00273     static_cast<void>(val); // Ignore input, don't warn
00274     return std::string("<") + _typeDesc + "> ...";
00275 }
00276 
00277 template<class T>
00278 std::string UnlabeledMultiArg<T>::longID(const std::string& val) const
00279 {
00280     static_cast<void>(val); // Ignore input, don't warn
00281     return std::string("<") + _typeDesc + ">  (accepted multiple times)";
00282 }
00283 
00284 template<class T>
00285 bool UnlabeledMultiArg<T>::operator==(const Arg& a) const
00286 {
00287     if ( _name == a.getName() || _description == a.getDescription() )
00288         return true;
00289     else
00290         return false;
00291 }
00292 
00293 template<class T>
00294 void UnlabeledMultiArg<T>::addToList( std::list<Arg*>& argList ) const
00295 {
00296     argList.push_back( const_cast<Arg*>(static_cast<const Arg* const>(this)) );
00297 }
00298 
00299 }
00300 
00301 #endif