LLDB mainline
TypeFormat.h
Go to the documentation of this file.
1//===-- TypeFormat.h ----------------------------------------------*- C++
2//-*-===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef LLDB_DATAFORMATTERS_TYPEFORMAT_H
11#define LLDB_DATAFORMATTERS_TYPEFORMAT_H
12
13#include <functional>
14#include <string>
15#include <unordered_map>
16
17
19#include "lldb/lldb-public.h"
20
22
23namespace lldb_private {
25public:
26 class Flags {
27 public:
28 Flags() {}
29
30 Flags(const Flags &other) : m_flags(other.m_flags) {}
31
32 Flags(uint32_t value) : m_flags(value) {}
33
34 Flags &operator=(const Flags &rhs) {
35 if (&rhs != this)
36 m_flags = rhs.m_flags;
37
38 return *this;
39 }
40
41 Flags &operator=(const uint32_t &rhs) {
42 m_flags = rhs;
43 return *this;
44 }
45
47 m_flags = 0;
48 return *this;
49 }
50
51 bool GetCascades() const {
52 return (m_flags & lldb::eTypeOptionCascade) == lldb::eTypeOptionCascade;
53 }
54
55 Flags &SetCascades(bool value = true) {
56 if (value)
57 m_flags |= lldb::eTypeOptionCascade;
58 else
59 m_flags &= ~lldb::eTypeOptionCascade;
60 return *this;
61 }
62
63 bool GetSkipPointers() const {
64 return (m_flags & lldb::eTypeOptionSkipPointers) ==
65 lldb::eTypeOptionSkipPointers;
66 }
67
68 Flags &SetSkipPointers(bool value = true) {
69 if (value)
70 m_flags |= lldb::eTypeOptionSkipPointers;
71 else
72 m_flags &= ~lldb::eTypeOptionSkipPointers;
73 return *this;
74 }
75
76 bool GetSkipReferences() const {
77 return (m_flags & lldb::eTypeOptionSkipReferences) ==
78 lldb::eTypeOptionSkipReferences;
79 }
80
81 Flags &SetSkipReferences(bool value = true) {
82 if (value)
83 m_flags |= lldb::eTypeOptionSkipReferences;
84 else
85 m_flags &= ~lldb::eTypeOptionSkipReferences;
86 return *this;
87 }
88
89 bool GetNonCacheable() const {
90 return (m_flags & lldb::eTypeOptionNonCacheable) ==
91 lldb::eTypeOptionNonCacheable;
92 }
93
94 Flags &SetNonCacheable(bool value = true) {
95 if (value)
96 m_flags |= lldb::eTypeOptionNonCacheable;
97 else
98 m_flags &= ~lldb::eTypeOptionNonCacheable;
99 return *this;
100 }
101
102 uint32_t GetValue() { return m_flags; }
103
104 void SetValue(uint32_t value) { m_flags = value; }
105
106 private:
107 uint32_t m_flags = lldb::eTypeOptionCascade;
108 };
109
110 TypeFormatImpl(const Flags &flags = Flags());
111
112 typedef std::shared_ptr<TypeFormatImpl> SharedPointer;
113
115
116 bool Cascades() const { return m_flags.GetCascades(); }
117
118 bool SkipsPointers() const { return m_flags.GetSkipPointers(); }
119
120 bool SkipsReferences() const { return m_flags.GetSkipReferences(); }
121
122 bool NonCacheable() const { return m_flags.GetNonCacheable(); }
123
124 void SetCascades(bool value) { m_flags.SetCascades(value); }
125
126 void SetSkipsPointers(bool value) { m_flags.SetSkipPointers(value); }
127
128 void SetSkipsReferences(bool value) { m_flags.SetSkipReferences(value); }
129
130 void SetNonCacheable(bool value) { m_flags.SetNonCacheable(value); }
131
132 uint32_t GetOptions() { return m_flags.GetValue(); }
133
134 void SetOptions(uint32_t value) { m_flags.SetValue(value); }
135
136 uint32_t &GetRevision() { return m_my_revision; }
137
139
140 virtual Type GetType() { return Type::eTypeUnknown; }
141
142 // we are using a ValueObject* instead of a ValueObjectSP because we do not
143 // need to hold on to this for extended periods of time and we trust the
144 // ValueObject to stay around for as long as it is required for us to
145 // generate its value
146 virtual bool FormatObject(ValueObject *valobj, std::string &dest) const = 0;
147
148 virtual std::string GetDescription() = 0;
149
150protected:
152 uint32_t m_my_revision = 0;
153
154private:
156 const TypeFormatImpl &operator=(const TypeFormatImpl &) = delete;
157};
158
160public:
162 const TypeFormatImpl::Flags &flags = Flags());
163
164 typedef std::shared_ptr<TypeFormatImpl_Format> SharedPointer;
165
167
168 lldb::Format GetFormat() const { return m_format; }
169
170 void SetFormat(lldb::Format fmt) { m_format = fmt; }
171
174 }
175
176 bool FormatObject(ValueObject *valobj, std::string &dest) const override;
177
178 std::string GetDescription() override;
179
180protected:
182
183private:
187};
188
190public:
192 const TypeFormatImpl::Flags &flags = Flags());
193
194 typedef std::shared_ptr<TypeFormatImpl_EnumType> SharedPointer;
195
197
199
200 void SetTypeName(ConstString enum_type) { m_enum_type = enum_type; }
201
204 }
205
206 bool FormatObject(ValueObject *valobj, std::string &dest) const override;
207
208 std::string GetDescription() override;
209
210protected:
212 mutable std::unordered_map<void *, CompilerType> m_types;
213
214private:
218};
219} // namespace lldb_private
220
221#endif // LLDB_DATAFORMATTERS_TYPEFORMAT_H
A uniqued constant string class.
Definition: ConstString.h:40
Flags & SetCascades(bool value=true)
Definition: TypeFormat.h:55
Flags & SetSkipReferences(bool value=true)
Definition: TypeFormat.h:81
Flags & operator=(const Flags &rhs)
Definition: TypeFormat.h:34
Flags & SetSkipPointers(bool value=true)
Definition: TypeFormat.h:68
void SetValue(uint32_t value)
Definition: TypeFormat.h:104
Flags & operator=(const uint32_t &rhs)
Definition: TypeFormat.h:41
Flags & SetNonCacheable(bool value=true)
Definition: TypeFormat.h:94
void SetTypeName(ConstString enum_type)
Definition: TypeFormat.h:200
const TypeFormatImpl_EnumType & operator=(const TypeFormatImpl_EnumType &)=delete
bool FormatObject(ValueObject *valobj, std::string &dest) const override
Definition: TypeFormat.cpp:141
std::string GetDescription() override
Definition: TypeFormat.cpp:198
std::shared_ptr< TypeFormatImpl_EnumType > SharedPointer
Definition: TypeFormat.h:194
std::unordered_map< void *, CompilerType > m_types
Definition: TypeFormat.h:212
TypeFormatImpl::Type GetType() override
Definition: TypeFormat.h:202
TypeFormatImpl_EnumType(const TypeFormatImpl_EnumType &)=delete
bool FormatObject(ValueObject *valobj, std::string &dest) const override
Definition: TypeFormat.cpp:41
TypeFormatImpl::Type GetType() override
Definition: TypeFormat.h:172
const TypeFormatImpl_Format & operator=(const TypeFormatImpl_Format &)=delete
void SetFormat(lldb::Format fmt)
Definition: TypeFormat.h:170
std::shared_ptr< TypeFormatImpl_Format > SharedPointer
Definition: TypeFormat.h:164
lldb::Format GetFormat() const
Definition: TypeFormat.h:168
TypeFormatImpl_Format(const TypeFormatImpl_Format &)=delete
std::string GetDescription() override
Definition: TypeFormat.cpp:126
void SetCascades(bool value)
Definition: TypeFormat.h:124
void SetNonCacheable(bool value)
Definition: TypeFormat.h:130
const TypeFormatImpl & operator=(const TypeFormatImpl &)=delete
TypeFormatImpl(const TypeFormatImpl &)=delete
virtual std::string GetDescription()=0
virtual bool FormatObject(ValueObject *valobj, std::string &dest) const =0
void SetSkipsPointers(bool value)
Definition: TypeFormat.h:126
void SetOptions(uint32_t value)
Definition: TypeFormat.h:134
void SetSkipsReferences(bool value)
Definition: TypeFormat.h:128
std::shared_ptr< TypeFormatImpl > SharedPointer
Definition: TypeFormat.h:112
A class that represents a running process on the host machine.
Definition: SBAddress.h:15
Format
Display format definitions.