Home | History | Annotate | Download | only in Interpreter 
      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_
    228