framework/delibs/decpp/deCommandLine.hpp

   1 #ifndef _DECOMMANDLINE_HPP
   2 #define _DECOMMANDLINE_HPP
   3 /*-------------------------------------------------------------------------
   4  * drawElements C++ Base Library
   5  * -----------------------------
   6  *
   7  * Copyright 2014 The Android Open Source Project
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  *//*!
  22  * \file
  23  * \brief Command line parser.
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "deDefs.hpp"
  27
  28 #include <map>
  29 #include <string>
  30 #include <vector>
  31 #include <ostream>
  32 #include <typeinfo>
  33 #include <stdexcept>
  34
  35 namespace de
  36 {
  37 namespace cmdline
  38 {
  39
  40 //! Default parsing function
  41 template<typename ValueType>
  42 void parseType (const char* src, ValueType* dst);
  43
  44 template<typename T>
  45 struct NamedValue
  46 {
  47         const char*     name;
  48         T                       value;
  49 };
  50
  51 template<typename OptName>
  52 struct Option
  53 {
  54         typedef typename OptName::ValueType ValueType;
  55         typedef void (*ParseFunc) (const char* src, ValueType* dst);
  56
  57         // \note All assumed to point to static memory.
  58         const char*                                             shortName;
  59         const char*                                             longName;
  60         const char*                                             description;
  61         const char*                                             defaultValue;           //!< Default value (parsed from string), or null if should not be set
  62
  63         // \note Either parse or namedValues must be null.
  64         ParseFunc                                               parse;                          //!< Custom parsing function or null.
  65         const NamedValue<ValueType>*    namedValues;            //!< Named values or null.
  66         const NamedValue<ValueType>*    namedValuesEnd;         //!< Named value list end.
  67
  68         //! Construct generic option (string, int, boolean).
  69         Option (const char* shortName_, const char* longName_, const char* description_, const char* defaultValue_ = DE_NULL)
  70                 : shortName             (shortName_)
  71                 , longName              (longName_)
  72                 , description   (description_)
  73                 , defaultValue  (defaultValue_)
  74                 , parse                 (parseType<ValueType>)
  75                 , namedValues   (DE_NULL)
  76                 , namedValuesEnd(0)
  77         {
  78         }
  79
  80         //! Option with custom parsing function.
  81         Option (const char* shortName_, const char* longName_, const char* description_, ParseFunc parse_, const char* defaultValue_ = DE_NULL)
  82                 : shortName             (shortName_)
  83                 , longName              (longName_)
  84                 , description   (description_)
  85                 , defaultValue  (defaultValue_)
  86                 , parse                 (parse_)
  87                 , namedValues   (DE_NULL)
  88                 , namedValuesEnd(DE_NULL)
  89         {
  90         }
  91
  92         //! Option that uses named values.
  93         Option (const char* shortName_, const char* longName_, const char* description_, const NamedValue<ValueType>* namedValues_, const NamedValue<ValueType>* namedValuesEnd_, const char* defaultValue_ = DE_NULL)
  94                 : shortName             (shortName_)
  95                 , longName              (longName_)
  96                 , description   (description_)
  97                 , defaultValue  (defaultValue_)
  98                 , parse                 ((ParseFunc)DE_NULL)
  99                 , namedValues   (namedValues_)
 100                 , namedValuesEnd(namedValuesEnd_)
 101         {
 102         }
 103
 104         //! Option that uses named values.
 105         template<size_t NumNamedValues>
 106         Option (const char* shortName_, const char* longName_, const char* description_, const NamedValue<ValueType> (&namedValues_)[NumNamedValues], const char* defaultValue_ = DE_NULL)
 107                 : shortName             (shortName_)
 108                 , longName              (longName_)
 109                 , description   (description_)
 110                 , defaultValue  (defaultValue_)
 111                 , parse                 ((ParseFunc)DE_NULL)
 112                 , namedValues   (DE_ARRAY_BEGIN(namedValues_))
 113                 , namedValuesEnd(DE_ARRAY_END(namedValues_))
 114         {
 115         }
 116 };
 117
 118 template<class Option>
 119 struct OptTraits
 120 {
 121         typedef typename Option::ValueType ValueType;
 122 };
 123
 124 //! Default value lookup
 125 template<typename ValueType>
 126 inline void getTypeDefault (ValueType* dst)
 127 {
 128         *dst = ValueType();
 129 }
 130
 131 template<> void getTypeDefault<bool> (bool* dst);
 132
 133 template<typename T>    inline bool isBoolean           (void) { return false;  }
 134 template<>                              inline bool isBoolean<bool>     (void) { return true;   }
 135
 136 //! Is argument boolean-only value?
 137 template<class Option>  inline bool isBooleanOpt        (void) { return isBoolean<typename OptTraits<Option>::ValueType>(); }
 138
 139 namespace detail
 140 {
 141
 142 using std::string;
 143 using std::vector;
 144 using std::map;
 145
 146 // TypedFieldMap implementation
 147
 148 template<class Name>
 149 struct TypedFieldTraits
 150 {
 151         // Generic implementation for cmdline.
 152         typedef typename OptTraits<Name>::ValueType     ValueType;
 153 };
 154
 155 template<class Value>
 156 struct TypedFieldValueTraits
 157 {
 158         static void destroy (void* value) { delete (Value*)value; }
 159 };
 160
 161 class TypedFieldMap
 162 {
 163 public:
 164                                                 TypedFieldMap                   (void);
 165                                                 ~TypedFieldMap                  (void);
 166
 167         bool                            empty                                   (void) const    { return m_fields.empty();      }
 168         void                            clear                                   (void);
 169
 170         template<typename Name>
 171         void                            set                                             (typename TypedFieldTraits<Name>::ValueType* value);
 172
 173         template<typename Name>
 174         void                            set                                             (const typename TypedFieldTraits<Name>::ValueType& value);
 175
 176         template<typename Name>
 177         bool                            contains                                (void) const;
 178
 179         template<typename Name>
 180         const typename TypedFieldTraits<Name>::ValueType&
 181                                                 get                                             (void) const;
 182
 183 private:
 184                                                 TypedFieldMap                   (const TypedFieldMap&);
 185         TypedFieldMap&          operator=                               (const TypedFieldMap&);
 186
 187         typedef void (*DestroyFunc) (void*);
 188
 189         struct Entry
 190         {
 191                 void*                   value;
 192                 DestroyFunc             destructor;
 193
 194                 Entry (void) : value(DE_NULL), destructor(0) {}
 195                 Entry (void* value_, DestroyFunc destructor_) : value(value_), destructor(destructor_) {}
 196         };
 197
 198         typedef std::map<const std::type_info*, Entry> Map;
 199
 200         bool                            contains                                (const std::type_info* key) const;
 201         const Entry&            get                                             (const std::type_info* key) const;
 202         void                            set                                             (const std::type_info* key, const Entry& value);
 203
 204         Map                                     m_fields;
 205 };
 206
 207 template<typename Name>
 208 inline void TypedFieldMap::set (typename TypedFieldTraits<Name>::ValueType* value)
 209 {
 210         set(&typeid(Name), Entry(value, &TypedFieldValueTraits<typename TypedFieldTraits<Name>::ValueType>::destroy));
 211 }
 212
 213 template<typename Name>
 214 void TypedFieldMap::set (const typename TypedFieldTraits<Name>::ValueType& value)
 215 {
 216         typename TypedFieldTraits<Name>::ValueType* copy = new typename TypedFieldTraits<Name>::ValueType(value);
 217
 218         try
 219         {
 220                 set<Name>(copy);
 221         }
 222         catch (...)
 223         {
 224                 delete copy;
 225                 throw;
 226         }
 227 }
 228
 229 template<typename Name>
 230 inline bool TypedFieldMap::contains (void) const
 231 {
 232         return contains(&typeid(Name));
 233 }
 234
 235 template<typename Name>
 236 inline const typename TypedFieldTraits<Name>::ValueType& TypedFieldMap::get (void) const
 237 {
 238         return *static_cast<typename TypedFieldTraits<Name>::ValueType*>(get(&typeid(Name)).value);
 239 }
 240
 241 class CommandLine;
 242
 243 typedef void (*GenericParseFunc) (const char* src, void* dst);
 244
 245 class Parser
 246 {
 247 public:
 248                                         Parser                          (void);
 249                                         ~Parser                         (void);
 250
 251         template<class OptType>
 252         void                    addOption                       (const Option<OptType>& option);
 253
 254         bool                    parse                           (int numArgs, const char* const* args, CommandLine* dst, std::ostream& err) const;
 255
 256         void                    help                            (std::ostream& dst) const;
 257
 258 private:
 259                                         Parser                          (const Parser&);
 260         Parser&                 operator=                       (const Parser&);
 261
 262         struct OptInfo;
 263
 264         typedef void            (*DispatchParseFunc)            (const OptInfo* info, const char* src, TypedFieldMap* dst);
 265         typedef void            (*SetDefaultFunc)                       (TypedFieldMap* dst);
 266
 267         struct OptInfo
 268         {
 269                 const char*                             shortName;
 270                 const char*                             longName;
 271                 const char*                             description;
 272                 const char*                             defaultValue;
 273                 bool                                    isFlag;                 //!< Set true for bool typed arguments that do not used named values.
 274
 275                 GenericParseFunc                parse;
 276
 277                 const void*                             namedValues;
 278                 const void*                             namedValuesEnd;
 279                 size_t                                  namedValueStride;
 280
 281                 DispatchParseFunc               dispatchParse;
 282                 SetDefaultFunc                  setDefault;
 283
 284                 OptInfo (void)
 285                         : shortName                     (DE_NULL)
 286                         , longName                      (DE_NULL)
 287                         , description           (DE_NULL)
 288                         , defaultValue          (DE_NULL)
 289                         , isFlag                        (false)
 290                         , parse                         (DE_NULL)
 291                         , namedValues           (DE_NULL)
 292                         , namedValuesEnd        (DE_NULL)
 293                         , namedValueStride      (0)
 294                         , dispatchParse         (DE_NULL)
 295                         , setDefault            (DE_NULL)
 296                 {}
 297         };
 298
 299         void                    addOption                       (const OptInfo& option);
 300
 301         template<typename OptName>
 302         static void             dispatchParse           (const OptInfo* info, const char* src, TypedFieldMap* dst);
 303
 304         vector<OptInfo> m_options;
 305 };
 306
 307 template<class OptType>
 308 inline Parser& operator<< (Parser& parser, const Option<OptType>& option)
 309 {
 310         parser.addOption(option);
 311         return parser;
 312 }
 313
 314 //! Find match by name. Throws exception if no match is found.
 315 const void* findNamedValueMatch (const char* src, const void* namedValues, const void* namedValuesEnd, size_t stride);
 316
 317 template<typename OptType>
 318 void Parser::dispatchParse (const OptInfo* info, const char* src, TypedFieldMap* dst)
 319 {
 320         typename OptTraits<OptType>::ValueType* value = new typename OptTraits<OptType>::ValueType();
 321         try
 322         {
 323                 DE_ASSERT((!!info->parse) != (!!info->namedValues));
 324                 if (info->parse)
 325                 {
 326                         ((typename Option<OptType>::ParseFunc)(info->parse))(src, value);
 327                 }
 328                 else
 329                 {
 330                         const void* match = findNamedValueMatch(src, info->namedValues, info->namedValuesEnd, info->namedValueStride);
 331                         *value = static_cast<const NamedValue<typename OptTraits<OptType>::ValueType>*>(match)->value;
 332                 }
 333                 dst->set<OptType>(value);
 334         }
 335         catch (...)
 336         {
 337                 delete value;
 338                 throw;
 339         }
 340 }
 341
 342 template<typename OptType>
 343 void dispatchSetDefault (TypedFieldMap* dst)
 344 {
 345         typename OptTraits<OptType>::ValueType* value = new typename OptTraits<OptType>::ValueType();
 346         try
 347         {
 348                 getTypeDefault<typename OptTraits<OptType>::ValueType>(value);
 349                 dst->set<OptType>(value);
 350         }
 351         catch (...)
 352         {
 353                 delete value;
 354                 throw;
 355         }
 356 }
 357
 358 template<typename OptType>
 359 const char* getNamedValueName (const void* value)
 360 {
 361         const NamedValue<typename OptTraits<OptType>::ValueType>* typedVal = static_cast<const NamedValue<typename OptTraits<OptType>::ValueType> >(value);
 362         return typedVal->name;
 363 }
 364
 365 template<typename OptType>
 366 void setFromNamedValue (const void* value, TypedFieldMap* dst)
 367 {
 368         const NamedValue<typename OptTraits<OptType>::ValueType>* typedVal = static_cast<const NamedValue<typename OptTraits<OptType>::ValueType> >(value);
 369         dst->set<OptType>(typedVal->value);
 370 }
 371
 372 template<class OptType>
 373 void Parser::addOption (const Option<OptType>& option)
 374 {
 375         OptInfo opt;
 376
 377         opt.shortName                   = option.shortName;
 378         opt.longName                    = option.longName;
 379         opt.description                 = option.description;
 380         opt.defaultValue                = option.defaultValue;
 381         opt.isFlag                              = isBooleanOpt<OptType>() && !option.namedValues;
 382         opt.parse                               = (GenericParseFunc)option.parse;
 383         opt.namedValues                 = (const void*)option.namedValues;
 384         opt.namedValuesEnd              = (const void*)option.namedValuesEnd;
 385         opt.namedValueStride    = sizeof(*option.namedValues);
 386         opt.dispatchParse               = dispatchParse<OptType>;
 387
 388         if (opt.isFlag)
 389                 opt.setDefault          = dispatchSetDefault<OptType>;
 390
 391         addOption(opt);
 392 }
 393
 394 class CommandLine
 395 {
 396 public:
 397                                                                 CommandLine             (void) {}
 398                                                                 ~CommandLine    (void) {}
 399
 400         void                                            clear                   (void);
 401
 402         const TypedFieldMap&            getOptions              (void) const    { return m_options;     }
 403         const vector<string>&           getArgs                 (void) const    { return m_args;        }
 404
 405         template<typename Option>
 406         bool                                            hasOption               (void) const    { return m_options.contains<Option>();  }
 407
 408         template<typename Option>
 409         const typename TypedFieldTraits<Option>::ValueType&
 410                                                                 getOption               (void) const    { return m_options.get<Option>();               }
 411
 412 private:
 413         TypedFieldMap                           m_options;
 414         vector<string>                          m_args;
 415
 416         friend class Parser;
 417 };
 418
 419 } // detail
 420
 421 using detail::Parser;
 422 using detail::CommandLine;
 423
 424 void selfTest (void);
 425
 426 } // cmdline
 427 } // de
 428
 429 #define DE_DECLARE_COMMAND_LINE_OPT(NAME, TYPE) struct NAME { typedef TYPE ValueType; }
 430
 431 #endif // _DECOMMANDLINE_HPP