contrib/llvm/tools/lldb/include/lldb/DataFormatters/TypeValidator.h

   1 //===-- TypeValidator.h ------------------------------------------*- C++
   2 //-*-===//
   3 //
   4 //                     The LLVM Compiler Infrastructure
   5 //
   6 // This file is distributed under the University of Illinois Open Source
   7 // License. See LICENSE.TXT for details.
   8 //
   9 //===----------------------------------------------------------------------===//
  10
  11 #ifndef lldb_TypeValidator_h_
  12 #define lldb_TypeValidator_h_
  13
  14
  15 #include <functional>
  16 #include <string>
  17
  18
  19 #include "lldb/lldb-enumerations.h"
  20 #include "lldb/lldb-private-enumerations.h"
  21 #include "lldb/lldb-public.h"
  22
  23 namespace lldb_private {
  24
  25 class TypeValidatorImpl {
  26 public:
  27   class Flags {
  28   public:
  29     Flags() : m_flags(lldb::eTypeOptionCascade) {}
  30
  31     Flags(const Flags &other) : m_flags(other.m_flags) {}
  32
  33     Flags(uint32_t value) : m_flags(value) {}
  34
  35     Flags &operator=(const Flags &rhs) {
  36       if (&rhs != this)
  37         m_flags = rhs.m_flags;
  38
  39       return *this;
  40     }
  41
  42     Flags &operator=(const uint32_t &rhs) {
  43       m_flags = rhs;
  44       return *this;
  45     }
  46
  47     Flags &Clear() {
  48       m_flags = 0;
  49       return *this;
  50     }
  51
  52     bool GetCascades() const {
  53       return (m_flags & lldb::eTypeOptionCascade) == lldb::eTypeOptionCascade;
  54     }
  55
  56     Flags &SetCascades(bool value = true) {
  57       if (value)
  58         m_flags |= lldb::eTypeOptionCascade;
  59       else
  60         m_flags &= ~lldb::eTypeOptionCascade;
  61       return *this;
  62     }
  63
  64     bool GetSkipPointers() const {
  65       return (m_flags & lldb::eTypeOptionSkipPointers) ==
  66              lldb::eTypeOptionSkipPointers;
  67     }
  68
  69     Flags &SetSkipPointers(bool value = true) {
  70       if (value)
  71         m_flags |= lldb::eTypeOptionSkipPointers;
  72       else
  73         m_flags &= ~lldb::eTypeOptionSkipPointers;
  74       return *this;
  75     }
  76
  77     bool GetSkipReferences() const {
  78       return (m_flags & lldb::eTypeOptionSkipReferences) ==
  79              lldb::eTypeOptionSkipReferences;
  80     }
  81
  82     Flags &SetSkipReferences(bool value = true) {
  83       if (value)
  84         m_flags |= lldb::eTypeOptionSkipReferences;
  85       else
  86         m_flags &= ~lldb::eTypeOptionSkipReferences;
  87       return *this;
  88     }
  89
  90     bool GetNonCacheable() const {
  91       return (m_flags & lldb::eTypeOptionNonCacheable) ==
  92              lldb::eTypeOptionNonCacheable;
  93     }
  94
  95     Flags &SetNonCacheable(bool value = true) {
  96       if (value)
  97         m_flags |= lldb::eTypeOptionNonCacheable;
  98       else
  99         m_flags &= ~lldb::eTypeOptionNonCacheable;
 100       return *this;
 101     }
 102
 103     uint32_t GetValue() { return m_flags; }
 104
 105     void SetValue(uint32_t value) { m_flags = value; }
 106
 107   private:
 108     uint32_t m_flags;
 109   };
 110
 111   TypeValidatorImpl(const Flags &flags = Flags());
 112
 113   typedef std::shared_ptr<TypeValidatorImpl> SharedPointer;
 114
 115   virtual ~TypeValidatorImpl();
 116
 117   bool Cascades() const { return m_flags.GetCascades(); }
 118   bool SkipsPointers() const { return m_flags.GetSkipPointers(); }
 119   bool SkipsReferences() const { return m_flags.GetSkipReferences(); }
 120   bool NonCacheable() const { return m_flags.GetNonCacheable(); }
 121
 122   void SetCascades(bool value) { m_flags.SetCascades(value); }
 123
 124   void SetSkipsPointers(bool value) { m_flags.SetSkipPointers(value); }
 125
 126   void SetSkipsReferences(bool value) { m_flags.SetSkipReferences(value); }
 127
 128   void SetNonCacheable(bool value) { m_flags.SetNonCacheable(value); }
 129
 130   uint32_t GetOptions() { return m_flags.GetValue(); }
 131
 132   void SetOptions(uint32_t value) { m_flags.SetValue(value); }
 133
 134   uint32_t &GetRevision() { return m_my_revision; }
 135
 136   enum class Type { eTypeUnknown, eTypeCXX };
 137
 138   struct ValidationResult {
 139     TypeValidatorResult m_result;
 140     std::string m_message;
 141   };
 142
 143   virtual Type GetType() { return Type::eTypeUnknown; }
 144
 145   // we are using a ValueObject* instead of a ValueObjectSP because we do not
 146   // need to hold on to this for extended periods of time and we trust the
 147   // ValueObject to stay around for as long as it is required for us to
 148   // generate its value
 149   virtual ValidationResult FormatObject(ValueObject *valobj) const = 0;
 150
 151   virtual std::string GetDescription() = 0;
 152
 153   static ValidationResult Success();
 154
 155   static ValidationResult Failure(std::string message);
 156
 157 protected:
 158   Flags m_flags;
 159   uint32_t m_my_revision;
 160
 161 private:
 162   DISALLOW_COPY_AND_ASSIGN(TypeValidatorImpl);
 163 };
 164
 165 class TypeValidatorImpl_CXX : public TypeValidatorImpl {
 166 public:
 167   typedef std::function<TypeValidatorImpl::ValidationResult(
 168       ValueObject *valobj)>
 169       ValidatorFunction;
 170
 171   TypeValidatorImpl_CXX(ValidatorFunction f, std::string d,
 172                         const TypeValidatorImpl::Flags &flags = Flags());
 173
 174   typedef std::shared_ptr<TypeValidatorImpl_CXX> SharedPointer;
 175
 176   ~TypeValidatorImpl_CXX() override;
 177
 178   ValidatorFunction GetValidatorFunction() const {
 179     return m_validator_function;
 180   }
 181
 182   void SetValidatorFunction(ValidatorFunction f) { m_validator_function = f; }
 183
 184   TypeValidatorImpl::Type GetType() override {
 185     return TypeValidatorImpl::Type::eTypeCXX;
 186   }
 187
 188   ValidationResult FormatObject(ValueObject *valobj) const override;
 189
 190   std::string GetDescription() override;
 191
 192 protected:
 193   std::string m_description;
 194   ValidatorFunction m_validator_function;
 195
 196 private:
 197   DISALLOW_COPY_AND_ASSIGN(TypeValidatorImpl_CXX);
 198 };
 199
 200 } // namespace lldb_private
 201
 202 #endif // lldb_TypeValidator_h_