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 // C Includes
  14 // C++ Includes
  15 #include <string>
  16
  17 // Other libraries and framework includes
  18 // Project includes
  19 #include "lldb/Core/Flags.h"
  20 #include "lldb/Interpreter/OptionValue.h"
  21
  22 namespace lldb_private {
  23
  24 class OptionValueString : public OptionValue
  25 {
  26 public:
  27
  28     typedef Error (*ValidatorCallback) (const char* string,
  29                                         void* baton);
  30
  31     enum Options
  32     {
  33         eOptionEncodeCharacterEscapeSequences = (1u << 0)
  34     };
  35
  36     OptionValueString () :
  37         OptionValue(),
  38         m_current_value (),
  39         m_default_value (),
  40         m_options(),
  41         m_validator(),
  42         m_validator_baton()
  43     {
  44     }
  45
  46     OptionValueString (ValidatorCallback validator,
  47                        void* baton = NULL) :
  48         OptionValue(),
  49         m_current_value (),
  50         m_default_value (),
  51         m_options(),
  52         m_validator(validator),
  53         m_validator_baton(baton)
  54     {
  55     }
  56
  57     OptionValueString (const char *value) :
  58         OptionValue(),
  59         m_current_value (),
  60         m_default_value (),
  61         m_options(),
  62         m_validator(),
  63         m_validator_baton()
  64     {
  65         if  (value && value[0])
  66         {
  67             m_current_value.assign (value);
  68             m_default_value.assign (value);
  69         }
  70     }
  71
  72     OptionValueString (const char *current_value,
  73                        const char *default_value) :
  74         OptionValue(),
  75         m_current_value (),
  76         m_default_value (),
  77         m_options(),
  78         m_validator(),
  79         m_validator_baton()
  80     {
  81         if  (current_value && current_value[0])
  82             m_current_value.assign (current_value);
  83         if  (default_value && default_value[0])
  84             m_default_value.assign (default_value);
  85     }
  86
  87     OptionValueString (const char *value,
  88                        ValidatorCallback validator,
  89                        void* baton = NULL) :
  90     OptionValue(),
  91     m_current_value (),
  92     m_default_value (),
  93     m_options(),
  94     m_validator(validator),
  95     m_validator_baton(baton)
  96     {
  97         if  (value && value[0])
  98         {
  99             m_current_value.assign (value);
 100             m_default_value.assign (value);
 101         }
 102     }
 103
 104     OptionValueString (const char *current_value,
 105                        const char *default_value,
 106                        ValidatorCallback validator,
 107                        void* baton = NULL) :
 108     OptionValue(),
 109     m_current_value (),
 110     m_default_value (),
 111     m_options(),
 112     m_validator(validator),
 113     m_validator_baton(baton)
 114     {
 115         if  (current_value && current_value[0])
 116             m_current_value.assign (current_value);
 117         if  (default_value && default_value[0])
 118             m_default_value.assign (default_value);
 119     }
 120
 121     virtual
 122     ~OptionValueString()
 123     {
 124     }
 125
 126     //---------------------------------------------------------------------
 127     // Virtual subclass pure virtual overrides
 128     //---------------------------------------------------------------------
 129
 130     virtual OptionValue::Type
 131     GetType () const
 132     {
 133         return eTypeString;
 134     }
 135
 136     virtual void
 137     DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
 138
 139     virtual Error
 140     SetValueFromCString (const char *value,
 141                          VarSetOperationType op = eVarSetOperationAssign);
 142
 143     virtual bool
 144     Clear ()
 145     {
 146         m_current_value = m_default_value;
 147         m_value_was_set = false;
 148         return true;
 149     }
 150
 151     virtual lldb::OptionValueSP
 152     DeepCopy () const;
 153
 154     //---------------------------------------------------------------------
 155     // Subclass specific functions
 156     //---------------------------------------------------------------------
 157
 158     Flags &
 159     GetOptions ()
 160     {
 161         return m_options;
 162     }
 163
 164     const Flags &
 165     GetOptions () const
 166     {
 167         return m_options;
 168     }
 169
 170     const char *
 171     operator = (const char *value)
 172     {
 173         SetCurrentValue(value);
 174         return m_current_value.c_str();
 175     }
 176
 177     const char *
 178     GetCurrentValue() const
 179     {
 180         return m_current_value.c_str();
 181     }
 182
 183     const char *
 184     GetDefaultValue() const
 185     {
 186         return m_default_value.c_str();
 187     }
 188
 189     Error
 190     SetCurrentValue (const char *value);
 191
 192     Error
 193     AppendToCurrentValue (const char *value);
 194
 195     void
 196     SetDefaultValue (const char *value)
 197     {
 198         if (value && value[0])
 199             m_default_value.assign (value);
 200         else
 201             m_default_value.clear();
 202     }
 203
 204     bool
 205     IsCurrentValueEmpty () const
 206     {
 207         return m_current_value.empty();
 208     }
 209
 210     bool
 211     IsDefaultValueEmpty () const
 212     {
 213         return m_default_value.empty();
 214     }
 215
 216
 217 protected:
 218     std::string m_current_value;
 219     std::string m_default_value;
 220     Flags m_options;
 221     ValidatorCallback m_validator;
 222     void* m_validator_baton;
 223 };
 224
 225 } // namespace lldb_private
 226
 227 #endif  // liblldb_OptionValueString_h_