llvm/Support/CommandLine.h

528 template <class DataType> struct OptionValue;
532 template <class DataType, bool isClass>
535   using WrapperType = OptionValue<DataType>;
539   const DataType &getValue() const { llvm_unreachable("no default value"); }
544   bool compare(const DataType & /*V*/) const { return false; }
555 template <class DataType> class OptionValueCopy : public GenericOptionValue {
556   DataType Value;
569   const DataType &getValue() const {
574   void setValue(const DataType &V) {
579   bool compare(const DataType &V) const { return Valid && (Value != V); }
582     const OptionValueCopy<DataType> &VC =
583         static_cast<const OptionValueCopy<DataType> &>(V);
591 template <class DataType>
592 struct OptionValueBase<DataType, false> : OptionValueCopy<DataType> {
593   using WrapperType = DataType;
603 template <class DataType>
605     : OptionValueBase<DataType, std::is_class<DataType>::value> {
608   OptionValue(const DataType &V) { this->setValue(V); }
611   template <class DT> OptionValue<DataType> &operator=(const DT &V) {
752   // DataType (via the same AnyOptionValue).
804 template <class DataType> class parser : public generic_parser_base {
808     OptionInfo(StringRef name, DataType v, StringRef helpStr)
811     OptionValue<DataType> V;
818   using parser_data_type = DataType;
833   bool parse(Option &O, StringRef ArgName, StringRef Arg, DataType &V) {
854     OptionInfo X(Name, static_cast<DataType>(V), HelpStr);
911 template <class DataType> class basic_parser : public basic_parser_impl {
913   using parser_data_type = DataType;
914   using OptVal = OptionValue<DataType>;
1317 template <class DataType, bool ExternalStorage, bool isClass>
1319   DataType *Location = nullptr; // Where to store the object...
1320   OptionValue<DataType> Default;
1331   bool setLocation(Option &O, DataType &L) {
1346   DataType &getValue() {
1350   const DataType &getValue() const {
1355   operator DataType() const { return this->getValue(); }
1357   const OptionValue<DataType> &getDefault() const { return Default; }
1364 template <class DataType>
1365 class opt_storage<DataType, false, true> : public DataType {
1367   OptionValue<DataType> Default;
1370     DataType::operator=(V);
1375   DataType &getValue() { return *this; }
1376   const DataType &getValue() const { return *this; }
1378   const OptionValue<DataType> &getDefault() const { return Default; }
1385 template <class DataType> class opt_storage<DataType, false, false> {
1387   DataType Value;
1388   OptionValue<DataType> Default;
1392   opt_storage() : Value(DataType()), Default(DataType()) {}
1399   DataType &getValue() { return Value; }
1400   DataType getValue() const { return Value; }
1402   const OptionValue<DataType> &getDefault() const { return Default; }
1404   operator DataType() const { return getValue(); }
1407   DataType operator->() const { return Value; }
1413 template <class DataType, bool ExternalStorage = false,
1414           class ParserClass = parser<DataType>>
1416             public opt_storage<DataType, ExternalStorage,
1417                                std::is_class<DataType>::value> {
1459     const OptionValue<DataType> &V = this->getDefault();
1468   void setDefault() override { setDefaultImpl<DataType>(); }
1481   void setInitialValue(const DataType &V) { this->setValue(V, true); }
1485   template <class T> DataType &operator=(const T &Val) {
1520 template <class DataType, class StorageClass> class list_storage {
1550 template <class DataType> class list_storage<DataType, bool> {
1551   std::vector<DataType> Storage;
1554   using iterator = typename std::vector<DataType>::iterator;
1559   using const_iterator = typename std::vector<DataType>::const_iterator;
1564   using size_type = typename std::vector<DataType>::size_type;
1570   void push_back(const DataType &value) { Storage.push_back(value); }
1571   void push_back(DataType &&value) { Storage.push_back(value); }
1573   using reference = typename std::vector<DataType>::reference;
1574   using const_reference = typename std::vector<DataType>::const_reference;
1593   iterator insert(const_iterator pos, const DataType &value) {
1596   iterator insert(const_iterator pos, DataType &&value) {
1600   iterator insert(iterator pos, const DataType &value) {
1603   iterator insert(iterator pos, DataType &&value) {
1610   operator std::vector<DataType>&() { return Storage; }
1611   operator ArrayRef<DataType>() { return Storage; }
1612   std::vector<DataType> *operator&() { return &Storage; }
1613   const std::vector<DataType> *operator&() const { return &Storage; }
1621 template <class DataType, class StorageClass = bool,
1622           class ParserClass = parser<DataType>>
1623 class list : public Option, public list_storage<DataType, StorageClass> {
1641     list_storage<DataType, StorageClass>::addValue(Val);
1663     list_storage<DataType, StorageClass>::clear();
1719 template <class DataType, class StorageClass> class bits_storage {
1755 template <class DataType> class bits_storage<DataType, bool> {
1776 template <class DataType, class Storage = bool,
1777           class ParserClass = parser<DataType>>
1778 class bits : public Option, public bits_storage<DataType, Storage> {