contrib/llvm/tools/lldb/source/API/SBTypeEnumMember.cpp

   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/SBTypeEnumMember.h"
  11 #include "lldb/API/SBDefines.h"
  12 #include "lldb/API/SBStream.h"
  13 #include "lldb/API/SBType.h"
  14 #include "lldb/Symbol/CompilerType.h"
  15 #include "lldb/Symbol/Type.h"
  16 #include "lldb/Utility/Stream.h"
  17
  18 using namespace lldb;
  19 using namespace lldb_private;
  20
  21 SBTypeEnumMember::SBTypeEnumMember() : m_opaque_sp() {}
  22
  23 SBTypeEnumMember::~SBTypeEnumMember() {}
  24 SBTypeEnumMember::SBTypeEnumMember(
  25     const lldb::TypeEnumMemberImplSP &enum_member_sp)
  26     : m_opaque_sp(enum_member_sp) {}
  27
  28 SBTypeEnumMember::SBTypeEnumMember(const SBTypeEnumMember &rhs)
  29     : m_opaque_sp() {
  30   if (this != &rhs) {
  31     if (rhs.IsValid())
  32       m_opaque_sp.reset(new TypeEnumMemberImpl(rhs.ref()));
  33   }
  34 }
  35
  36 SBTypeEnumMember &SBTypeEnumMember::operator=(const SBTypeEnumMember &rhs) {
  37   if (this != &rhs) {
  38     if (rhs.IsValid())
  39       m_opaque_sp.reset(new TypeEnumMemberImpl(rhs.ref()));
  40   }
  41   return *this;
  42 }
  43
  44 bool SBTypeEnumMember::IsValid() const { return m_opaque_sp.get(); }
  45
  46 const char *SBTypeEnumMember::GetName() {
  47   if (m_opaque_sp.get())
  48     return m_opaque_sp->GetName().GetCString();
  49   return NULL;
  50 }
  51
  52 int64_t SBTypeEnumMember::GetValueAsSigned() {
  53   if (m_opaque_sp.get())
  54     return m_opaque_sp->GetValueAsSigned();
  55   return 0;
  56 }
  57
  58 uint64_t SBTypeEnumMember::GetValueAsUnsigned() {
  59   if (m_opaque_sp.get())
  60     return m_opaque_sp->GetValueAsUnsigned();
  61   return 0;
  62 }
  63
  64 SBType SBTypeEnumMember::GetType() {
  65   SBType sb_type;
  66   if (m_opaque_sp.get()) {
  67     sb_type.SetSP(m_opaque_sp->GetIntegerType());
  68   }
  69   return sb_type;
  70 }
  71
  72 void SBTypeEnumMember::reset(TypeEnumMemberImpl *type_member_impl) {
  73   m_opaque_sp.reset(type_member_impl);
  74 }
  75
  76 TypeEnumMemberImpl &SBTypeEnumMember::ref() {
  77   if (m_opaque_sp.get() == NULL)
  78     m_opaque_sp.reset(new TypeEnumMemberImpl());
  79   return *m_opaque_sp.get();
  80 }
  81
  82 const TypeEnumMemberImpl &SBTypeEnumMember::ref() const {
  83   return *m_opaque_sp.get();
  84 }
  85
  86 SBTypeEnumMemberList::SBTypeEnumMemberList()
  87     : m_opaque_ap(new TypeEnumMemberListImpl()) {}
  88
  89 SBTypeEnumMemberList::SBTypeEnumMemberList(const SBTypeEnumMemberList &rhs)
  90     : m_opaque_ap(new TypeEnumMemberListImpl()) {
  91   for (uint32_t i = 0,
  92                 rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize();
  93        i < rhs_size; i++)
  94     Append(const_cast<SBTypeEnumMemberList &>(rhs).GetTypeEnumMemberAtIndex(i));
  95 }
  96
  97 bool SBTypeEnumMemberList::IsValid() { return (m_opaque_ap != NULL); }
  98
  99 SBTypeEnumMemberList &SBTypeEnumMemberList::
 100 operator=(const SBTypeEnumMemberList &rhs) {
 101   if (this != &rhs) {
 102     m_opaque_ap.reset(new TypeEnumMemberListImpl());
 103     for (uint32_t i = 0,
 104                   rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize();
 105          i < rhs_size; i++)
 106       Append(
 107           const_cast<SBTypeEnumMemberList &>(rhs).GetTypeEnumMemberAtIndex(i));
 108   }
 109   return *this;
 110 }
 111
 112 void SBTypeEnumMemberList::Append(SBTypeEnumMember enum_member) {
 113   if (enum_member.IsValid())
 114     m_opaque_ap->Append(enum_member.m_opaque_sp);
 115 }
 116
 117 SBTypeEnumMember
 118 SBTypeEnumMemberList::GetTypeEnumMemberAtIndex(uint32_t index) {
 119   if (m_opaque_ap)
 120     return SBTypeEnumMember(m_opaque_ap->GetTypeEnumMemberAtIndex(index));
 121   return SBTypeEnumMember();
 122 }
 123
 124 uint32_t SBTypeEnumMemberList::GetSize() { return m_opaque_ap->GetSize(); }
 125
 126 SBTypeEnumMemberList::~SBTypeEnumMemberList() {}
 127
 128 bool SBTypeEnumMember::GetDescription(
 129     lldb::SBStream &description, lldb::DescriptionLevel description_level) {
 130   Stream &strm = description.ref();
 131
 132   if (m_opaque_sp.get()) {
 133     if (m_opaque_sp->GetIntegerType()->GetDescription(strm,
 134                                                       description_level)) {
 135       strm.Printf(" %s", m_opaque_sp->GetName().GetCString());
 136     }
 137   } else {
 138     strm.PutCString("No value");
 139   }
 140   return true;
 141 }