1 //===-- SBTypeEnumMember.cpp ---------------------------------- -*- 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 #include "lldb/API/SBDefines.h"
11 #include "lldb/API/SBType.h"
12 #include "lldb/API/SBTypeEnumMember.h"
13 #include "lldb/API/SBStream.h"
14 #include "lldb/Core/Stream.h"
15 #include "lldb/Symbol/ClangASTType.h"
16 #include "lldb/Symbol/Type.h"
17 
18 using namespace lldb;
19 using namespace lldb_private;
20 using namespace clang;
21 
22 SBTypeEnumMember::SBTypeEnumMember() :
23     m_opaque_sp()
24 {
25 }
26 
27 SBTypeEnumMember::~SBTypeEnumMember()
28 {
29 }
30 SBTypeEnumMember::SBTypeEnumMember (const lldb::TypeEnumMemberImplSP &enum_member_sp) :
31     m_opaque_sp(enum_member_sp)
32 {
33 }
34 
35 SBTypeEnumMember::SBTypeEnumMember (const SBTypeEnumMember& rhs) :
36     m_opaque_sp()
37 {
38     if (this != &rhs)
39     {
40         if (rhs.IsValid())
41             m_opaque_sp.reset(new TypeEnumMemberImpl(rhs.ref()));
42     }
43 }
44 
45 SBTypeEnumMember&
46 SBTypeEnumMember::operator = (const SBTypeEnumMember& rhs)
47 {
48     if (this != &rhs)
49     {
50         if (rhs.IsValid())
51             m_opaque_sp.reset(new TypeEnumMemberImpl(rhs.ref()));
52     }
53     return *this;
54 }
55 
56 bool
57 SBTypeEnumMember::IsValid() const
58 {
59     return m_opaque_sp.get();
60 }
61 
62 const char *
63 SBTypeEnumMember::GetName ()
64 {
65     if (m_opaque_sp.get())
66         return m_opaque_sp->GetName().GetCString();
67     return NULL;
68 }
69 
70 int64_t
71 SBTypeEnumMember::GetValueAsSigned()
72 {
73     if (m_opaque_sp.get())
74         return m_opaque_sp->GetValueAsSigned();
75     return 0;
76 }
77 
78 uint64_t
79 SBTypeEnumMember::GetValueAsUnsigned()
80 {
81     if (m_opaque_sp.get())
82         return m_opaque_sp->GetValueAsUnsigned();
83     return 0;
84 }
85 
86 SBType
87 SBTypeEnumMember::GetType ()
88 {
89     SBType sb_type;
90     if (m_opaque_sp.get())
91     {
92         sb_type.SetSP(m_opaque_sp->GetIntegerType());
93     }
94     return sb_type;
95 
96 }
97 
98 void
99 SBTypeEnumMember::reset(TypeEnumMemberImpl *type_member_impl)
100 {
101     m_opaque_sp.reset(type_member_impl);
102 }
103 
104 TypeEnumMemberImpl &
105 SBTypeEnumMember::ref ()
106 {
107     if (m_opaque_sp.get() == NULL)
108         m_opaque_sp.reset (new TypeEnumMemberImpl());
109     return *m_opaque_sp.get();
110 }
111 
112 const TypeEnumMemberImpl &
113 SBTypeEnumMember::ref () const
114 {
115     return *m_opaque_sp.get();
116 }
117 
118 
119 SBTypeEnumMemberList::SBTypeEnumMemberList() :
120     m_opaque_ap(new TypeEnumMemberListImpl())
121 {
122 }
123 
124 SBTypeEnumMemberList::SBTypeEnumMemberList(const SBTypeEnumMemberList& rhs) :
125     m_opaque_ap(new TypeEnumMemberListImpl())
126 {
127     for (uint32_t i = 0, rhs_size = const_cast<SBTypeEnumMemberList&>(rhs).GetSize(); i < rhs_size; i++)
128         Append(const_cast<SBTypeEnumMemberList&>(rhs).GetTypeEnumMemberAtIndex(i));
129 }
130 
131 bool
132 SBTypeEnumMemberList::IsValid ()
133 {
134     return (m_opaque_ap.get() != NULL);
135 }
136 
137 SBTypeEnumMemberList&
138 SBTypeEnumMemberList::operator = (const SBTypeEnumMemberList& rhs)
139 {
140     if (this != &rhs)
141     {
142         m_opaque_ap.reset (new TypeEnumMemberListImpl());
143         for (uint32_t i = 0, rhs_size = const_cast<SBTypeEnumMemberList&>(rhs).GetSize(); i < rhs_size; i++)
144             Append(const_cast<SBTypeEnumMemberList&>(rhs).GetTypeEnumMemberAtIndex(i));
145     }
146     return *this;
147 }
148 
149 void
150 SBTypeEnumMemberList::Append (SBTypeEnumMember enum_member)
151 {
152     if (enum_member.IsValid())
153         m_opaque_ap->Append (enum_member.m_opaque_sp);
154 }
155 
156 SBTypeEnumMember
157 SBTypeEnumMemberList::GetTypeEnumMemberAtIndex(uint32_t index)
158 {
159     if (m_opaque_ap.get())
160         return SBTypeEnumMember(m_opaque_ap->GetTypeEnumMemberAtIndex(index));
161     return SBTypeEnumMember();
162 }
163 
164 uint32_t
165 SBTypeEnumMemberList::GetSize()
166 {
167     return m_opaque_ap->GetSize();
168 }
169 
170 SBTypeEnumMemberList::~SBTypeEnumMemberList()
171 {
172 }
173 
174 bool
175 SBTypeEnumMember::GetDescription (lldb::SBStream &description,
176                                   lldb::DescriptionLevel description_level)
177 {
178     Stream &strm = description.ref();
179 
180     if (m_opaque_sp.get())
181     {
182         if( m_opaque_sp->GetIntegerType()->GetDescription(strm, description_level) )
183         {
184             strm.Printf(" %s", m_opaque_sp->GetName().GetCString());
185         }
186     }
187     else
188     {
189         strm.PutCString ("No value");
190     }
191     return true;
192 }
193