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