Changeset 1246 in SHVCSoftware for branches/SHM-dev/source/Lib/TAppCommon


Ignore:
Timestamp:
14 Jul 2015, 00:26:07 (10 years ago)
Author:
seregin
Message:

port rev 4240

Location:
branches/SHM-dev/source/Lib/TAppCommon
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • branches/SHM-dev/source/Lib/TAppCommon/program_options_lite.cpp

    r1029 r1246  
    22 * License, included below. This software may be subject to other third party
    33 * and contributor rights, including patent rights, and no such rights are
    4  * granted under this license. 
     4 * granted under this license.
    55 *
    66 * Copyright (c) 2010-2014, ITU/ISO/IEC
    … …  
    5050  namespace program_options_lite
    5151  {
    52    
     52
    5353    Options::~Options()
    5454    {
    … …  
    5858      }
    5959    }
    60    
     60
    6161    void Options::addOption(OptionBase *opt)
    6262    {
    … …  
    6464      names->opt = opt;
    6565      string& opt_string = opt->opt_string;
    66      
     66
    6767      size_t opt_start = 0;
    6868      for (size_t opt_end = 0; opt_end != string::npos;)
    … …  
    9696      return OptionSpecific(*this);
    9797    }
    98    
     98
    9999    static void setOptions(Options::NamesPtrList& opt_list, const string& value)
    100100    {
    … …  
    108108
    109109    static const char spaces[41] = "                                        ";
    110    
     110
    111111    /* format help text for a single option:
    112112     * using the formatting: "-x, --long",
    … …  
    138138      }
    139139    }
    140    
     140
    141141    /* format the help text */
    142142    void doHelp(ostream& out, Options& opts, unsigned columns)
    … …  
    154154      unsigned opt_width = min(max_width+2, 28u + pad_short) + 2;
    155155      unsigned desc_width = columns - opt_width;
    156      
     156
    157157      /* second pass: write out formatted option and help text.
    158158       *  - align start of help text to start at opt_width
    … …  
    209209            split_pos = opt_desc.find_last_not_of(' ', split_pos) + 1;
    210210          }
    211          
     211
    212212          /* bad split if no suitable space to split at.  fall back to width */
    213213          bool bad_split = split_pos == string::npos || split_pos <= cur_pos;
    … …  
    217217          }
    218218          line << opt_desc.substr(cur_pos, split_pos - cur_pos);
    219          
     219
    220220          /* eat up any space for the start of the next line */
    221221          if (!bad_split)
    … …  
    224224          }
    225225          cur_pos = newline_pos = split_pos;
    226          
     226
    227227          if (cur_pos >= opt_desc.size())
    228228          {
    … …  
    235235      }
    236236    }
    237    
     237
    238238    bool storePair(Options& opts, bool allow_long, bool allow_short, const string& name, const string& value)
    239239    {
    … …  
    248248        }
    249249      }
    250      
     250
    251251      /* check for the short list */
    252252      if (allow_short && !(found && allow_long))
    … …  
    269269      return true;
    270270    }
    271    
     271
    272272    bool storePair(Options& opts, const string& name, const string& value)
    273273    {
    274274      return storePair(opts, true, true, name, value);
    275275    }
    276    
     276
    277277    /**
    278278     * returns number of extra arguments consumed
    … …  
    288288      size_t arg_opt_sep = arg.find_first_of('=');
    289289      string option = arg.substr(arg_opt_start, arg_opt_sep - arg_opt_start);
    290      
     290
    291291      unsigned extra_argc_consumed = 0;
    292292      if (arg_opt_sep == string::npos)
    … …  
    299299        * booleans */
    300300        if (argc == 1)
     301        {
    301302          return 0; /* run out of argv for argument */
     303        }
    302304        extra_argc_consumed = 1;
    303305#endif
    … …  
    339341      return 1;
    340342    }
    341    
     343
    342344    list<const char*>
    343345    scanArgv(Options& opts, unsigned argc, const char* argv[])
    … …  
    376378          /* a lone double dash ends option processing */
    377379          while (++i < argc)
     380          {
    378381            non_option_arguments.push_back(argv[i]);
     382          }
    379383          break;
    380384        }
    … …  
    386390      return non_option_arguments;
    387391    }
    388    
     392
    389393    void scanLine(Options& opts, string& line)
    390394    {
    … …  
    441445         * any trailing whitespace will be removed shortly */
    442446        value_end = line.find_first_not_of(" \t\n\r", value_end);
    443       }
    444       while (value_end != string::npos);
     447      } while (value_end != string::npos);
    445448      /* strip any trailing space from value*/
    446449      value_end = line.find_last_not_of(" \t\n\r", value_end);
    … …  
    468471        getline(in, line);
    469472        scanLine(opts, line);
    470       }
    471       while(!!in);
     473      } while(!!in);
    472474    }
    473475

  • branches/SHM-dev/source/Lib/TAppCommon/program_options_lite.h

    r1029 r1246  
    22 * License, included below. This software may be subject to other third party
    33 * and contributor rights, including patent rights, and no such rights are
    4  * granted under this license. 
     4 * granted under this license.
    55 *
    66 * Copyright (c) 2010-2014, ITU/ISO/IEC
    … …  
    4949  {
    5050    struct Options;
    51    
     51
    5252    struct ParseFailure : public std::exception
    5353    {
    … …  
    7373    void parseConfigFile(Options& opts, const std::string& filename);
    7474    bool storePair(Options& opts, const std::string& name, const std::string& value);
    75    
     75
    7676    /** OptionBase: Virtual base class for storing information relating to a
    7777     * specific option This base class describes common elements.  Type specific
    … …  
    8282      : opt_string(name), opt_desc(desc)
    8383      {};
    84      
     84
    8585      virtual ~OptionBase() {}
    86      
     86
    8787      /* parse argument arg, to obtain a value for the option */
    8888      virtual void parse(const std::string& arg) = 0;
    8989      /* set the argument to the default value */
    9090      virtual void setDefault() = 0;
    91      
     91
    9292      std::string opt_string;
    9393      std::string opt_desc;
    9494    };
    95    
     95
    9696    /** Type specific option storage */
    9797    template<typename T>
    … …  
    101101      : OptionBase(name, desc), opt_storage(storage), opt_default_val(default_val)
    102102      {}
    103      
     103
    104104      void parse(const std::string& arg);
    105      
     105
    106106      void setDefault()
    107107      {
    108108        opt_storage = opt_default_val;
    109109      }
    110      
     110
    111111      T& opt_storage;
    112112      T opt_default_val;
    113113    };
    114    
     114
    115115    /* Generic parsing */
    116116    template<typename T>
    … …  
    129129      }
    130130    }
    131    
     131
    132132    /* string parsing is specialized -- copy the whole string, not just the
    133133     * first word */
    … …  
    138138      opt_storage = arg;
    139139    }
    140    
     140
    141141    /** Option class for argument handling using a user provided function */
    142142    struct OptionFunc : public OptionBase
    143143    {
    144144      typedef void (Func)(Options&, const std::string&);
    145      
     145
    146146      OptionFunc(const std::string& name, Options& parent_, Func *func_, const std::string& desc)
    147147      : OptionBase(name, desc), parent(parent_), func(func_)
    148148      {}
    149      
     149
    150150      void parse(const std::string& arg)
    151151      {
    152152        func(parent, arg);
    153153      }
    154      
     154
    155155      void setDefault()
    156156      {
    157157        return;
    158158      }
    159      
     159
    160160    private:
    161161      Options& parent;
    162162      void (*func)(Options&, const std::string&);
    163163    };
    164    
     164
    165165    class OptionSpecific;
    166166    struct Options
    167167    {
    168168      ~Options();
    169      
     169
    170170      OptionSpecific addOptions();
    171      
     171
    172172      struct Names
    173173      {
    … …  
    176176        {
    177177          if (opt)
     178          {
    178179            delete opt;
     180          }
    179181        }
    180182        std::list<std::string> opt_long;
    … …  
    184186
    185187      void addOption(OptionBase *opt);
    186      
     188
    187189      typedef std::list<Names*> NamesPtrList;
    188190      NamesPtrList opt_list;
    189      
     191
    190192      typedef std::map<std::string, NamesPtrList> NamesMap;
    191193      NamesMap opt_long_map;
    192194      NamesMap opt_short_map;
    193195    };
    194    
     196
    195197    /* Class with templated overloaded operator(), for use by Options::addOptions() */
    196198    class OptionSpecific
    … …  
    198200    public:
    199201      OptionSpecific(Options& parent_) : parent(parent_) {}
    200      
     202
    201203      /**
    202204       * Add option described by name to the parent Options list,
    … …  
    281283      Options& parent;
    282284    };
    283    
     285
    284286  } /* namespace: program_options_lite */
    285287} /* namespace: df */
Note: See TracChangeset for help on using the changeset viewer.