contrib/llvm/tools/lldb/include/lldb/Interpreter/OptionValueString.h

   1 //===-- OptionValueString.h -------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef liblldb_OptionValueString_h_
  11 #define liblldb_OptionValueString_h_
  12
  13 #include <string>
  14
  15 #include "lldb/Utility/Flags.h"
  16
  17 #include "lldb/Interpreter/OptionValue.h"
  18
  19 namespace lldb_private {
  20
  21 class OptionValueString : public OptionValue {
  22 public:
  23   typedef Status (*ValidatorCallback)(const char *string, void *baton);
  24
  25   enum Options { eOptionEncodeCharacterEscapeSequences = (1u << 0) };
  26
  27   OptionValueString()
  28       : OptionValue(), m_current_value(), m_default_value(), m_options(),
  29         m_validator(), m_validator_baton() {}
  30
  31   OptionValueString(ValidatorCallback validator, void *baton = nullptr)
  32       : OptionValue(), m_current_value(), m_default_value(), m_options(),
  33         m_validator(validator), m_validator_baton(baton) {}
  34
  35   OptionValueString(const char *value)
  36       : OptionValue(), m_current_value(), m_default_value(), m_options(),
  37         m_validator(), m_validator_baton() {
  38     if (value && value[0]) {
  39       m_current_value.assign(value);
  40       m_default_value.assign(value);
  41     }
  42   }
  43
  44   OptionValueString(const char *current_value, const char *default_value)
  45       : OptionValue(), m_current_value(), m_default_value(), m_options(),
  46         m_validator(), m_validator_baton() {
  47     if (current_value && current_value[0])
  48       m_current_value.assign(current_value);
  49     if (default_value && default_value[0])
  50       m_default_value.assign(default_value);
  51   }
  52
  53   OptionValueString(const char *value, ValidatorCallback validator,
  54                     void *baton = nullptr)
  55       : OptionValue(), m_current_value(), m_default_value(), m_options(),
  56         m_validator(validator), m_validator_baton(baton) {
  57     if (value && value[0]) {
  58       m_current_value.assign(value);
  59       m_default_value.assign(value);
  60     }
  61   }
  62
  63   OptionValueString(const char *current_value, const char *default_value,
  64                     ValidatorCallback validator, void *baton = nullptr)
  65       : OptionValue(), m_current_value(), m_default_value(), m_options(),
  66         m_validator(validator), m_validator_baton(baton) {
  67     if (current_value && current_value[0])
  68       m_current_value.assign(current_value);
  69     if (default_value && default_value[0])
  70       m_default_value.assign(default_value);
  71   }
  72
  73   ~OptionValueString() override = default;
  74
  75   //---------------------------------------------------------------------
  76   // Virtual subclass pure virtual overrides
  77   //---------------------------------------------------------------------
  78
  79   OptionValue::Type GetType() const override { return eTypeString; }
  80
  81   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
  82                  uint32_t dump_mask) override;
  83
  84   Status
  85   SetValueFromString(llvm::StringRef value,
  86                      VarSetOperationType op = eVarSetOperationAssign) override;
  87   Status
  88   SetValueFromString(const char *,
  89                      VarSetOperationType = eVarSetOperationAssign) = delete;
  90
  91   bool Clear() override {
  92     m_current_value = m_default_value;
  93     m_value_was_set = false;
  94     return true;
  95   }
  96
  97   lldb::OptionValueSP DeepCopy() const override;
  98
  99   //---------------------------------------------------------------------
 100   // Subclass specific functions
 101   //---------------------------------------------------------------------
 102
 103   Flags &GetOptions() { return m_options; }
 104
 105   const Flags &GetOptions() const { return m_options; }
 106
 107   const char *operator=(const char *value) {
 108     SetCurrentValue(llvm::StringRef::withNullAsEmpty(value));
 109     return m_current_value.c_str();
 110   }
 111
 112   const char *GetCurrentValue() const { return m_current_value.c_str(); }
 113   llvm::StringRef GetCurrentValueAsRef() const { return m_current_value; }
 114
 115   const char *GetDefaultValue() const { return m_default_value.c_str(); }
 116   llvm::StringRef GetDefaultValueAsRef() const { return m_default_value; }
 117
 118   Status SetCurrentValue(const char *) = delete;
 119   Status SetCurrentValue(llvm::StringRef value);
 120
 121   Status AppendToCurrentValue(const char *value);
 122
 123   void SetDefaultValue(const char *value) {
 124     if (value && value[0])
 125       m_default_value.assign(value);
 126     else
 127       m_default_value.clear();
 128   }
 129
 130   bool IsCurrentValueEmpty() const { return m_current_value.empty(); }
 131
 132   bool IsDefaultValueEmpty() const { return m_default_value.empty(); }
 133
 134 protected:
 135   std::string m_current_value;
 136   std::string m_default_value;
 137   Flags m_options;
 138   ValidatorCallback m_validator;
 139   void *m_validator_baton;
 140 };
 141
 142 } // namespace lldb_private
 143
 144 #endif // liblldb_OptionValueString_h_