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

   1 //===-- SBTypeFilter.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/lldb-python.h"
  11
  12 #include "lldb/API/SBTypeFilter.h"
  13
  14 #include "lldb/API/SBStream.h"
  15
  16 #include "lldb/DataFormatters/DataVisualization.h"
  17
  18 using namespace lldb;
  19 using namespace lldb_private;
  20
  21 SBTypeFilter::SBTypeFilter() :
  22 m_opaque_sp()
  23 {
  24 }
  25
  26 SBTypeFilter::SBTypeFilter (uint32_t options)
  27 : m_opaque_sp(TypeFilterImplSP(new TypeFilterImpl(options)))
  28 {
  29 }
  30
  31 SBTypeFilter::SBTypeFilter (const lldb::SBTypeFilter &rhs) :
  32 m_opaque_sp(rhs.m_opaque_sp)
  33 {
  34 }
  35
  36 SBTypeFilter::~SBTypeFilter ()
  37 {
  38 }
  39
  40 bool
  41 SBTypeFilter::IsValid() const
  42 {
  43     return m_opaque_sp.get() != NULL;
  44 }
  45
  46 uint32_t
  47 SBTypeFilter::GetOptions()
  48 {
  49     if (IsValid())
  50         return m_opaque_sp->GetOptions();
  51     return 0;
  52 }
  53
  54 void
  55 SBTypeFilter::SetOptions (uint32_t value)
  56 {
  57     if (CopyOnWrite_Impl())
  58         m_opaque_sp->SetOptions(value);
  59 }
  60
  61 bool
  62 SBTypeFilter::GetDescription (lldb::SBStream &description,
  63                               lldb::DescriptionLevel description_level)
  64 {
  65     if (!IsValid())
  66         return false;
  67     else {
  68         description.Printf("%s\n",
  69                            m_opaque_sp->GetDescription().c_str());
  70         return true;
  71     }
  72 }
  73
  74 void
  75 SBTypeFilter::Clear()
  76 {
  77     if (CopyOnWrite_Impl())
  78         m_opaque_sp->Clear();
  79 }
  80
  81 uint32_t
  82 SBTypeFilter::GetNumberOfExpressionPaths()
  83 {
  84     if (IsValid())
  85         return m_opaque_sp->GetCount();
  86     return 0;
  87 }
  88
  89 const char*
  90 SBTypeFilter::GetExpressionPathAtIndex (uint32_t i)
  91 {
  92     if (IsValid())
  93     {
  94         const char* item = m_opaque_sp->GetExpressionPathAtIndex(i);
  95         if (item && *item == '.')
  96             item++;
  97         return item;
  98     }
  99     return NULL;
 100 }
 101
 102 bool
 103 SBTypeFilter::ReplaceExpressionPathAtIndex (uint32_t i, const char* item)
 104 {
 105     if (CopyOnWrite_Impl())
 106         return m_opaque_sp->SetExpressionPathAtIndex(i, item);
 107     else
 108         return false;
 109 }
 110
 111 void
 112 SBTypeFilter::AppendExpressionPath (const char* item)
 113 {
 114     if (CopyOnWrite_Impl())
 115         m_opaque_sp->AddExpressionPath(item);
 116 }
 117
 118 lldb::SBTypeFilter &
 119 SBTypeFilter::operator = (const lldb::SBTypeFilter &rhs)
 120 {
 121     if (this != &rhs)
 122     {
 123         m_opaque_sp = rhs.m_opaque_sp;
 124     }
 125     return *this;
 126 }
 127
 128 bool
 129 SBTypeFilter::operator == (lldb::SBTypeFilter &rhs)
 130 {
 131     if (IsValid() == false)
 132         return !rhs.IsValid();
 133
 134     return m_opaque_sp == rhs.m_opaque_sp;
 135 }
 136
 137 bool
 138 SBTypeFilter::IsEqualTo (lldb::SBTypeFilter &rhs)
 139 {
 140     if (IsValid() == false)
 141         return !rhs.IsValid();
 142
 143     if (GetNumberOfExpressionPaths() != rhs.GetNumberOfExpressionPaths())
 144         return false;
 145
 146     for (uint32_t j = 0;
 147          j < GetNumberOfExpressionPaths();
 148          j++)
 149         if ( strcmp(GetExpressionPathAtIndex(j),rhs.GetExpressionPathAtIndex(j)) != 0)
 150             return false;
 151
 152     return GetOptions() == rhs.GetOptions();
 153 }
 154
 155 bool
 156 SBTypeFilter::operator != (lldb::SBTypeFilter &rhs)
 157 {
 158     if (IsValid() == false)
 159         return !rhs.IsValid();
 160
 161     return m_opaque_sp != rhs.m_opaque_sp;
 162 }
 163
 164 lldb::TypeFilterImplSP
 165 SBTypeFilter::GetSP ()
 166 {
 167     return m_opaque_sp;
 168 }
 169
 170 void
 171 SBTypeFilter::SetSP (const lldb::TypeFilterImplSP &typefilter_impl_sp)
 172 {
 173     m_opaque_sp = typefilter_impl_sp;
 174 }
 175
 176 SBTypeFilter::SBTypeFilter (const lldb::TypeFilterImplSP &typefilter_impl_sp) :
 177 m_opaque_sp(typefilter_impl_sp)
 178 {
 179 }
 180
 181 bool
 182 SBTypeFilter::CopyOnWrite_Impl()
 183 {
 184     if (!IsValid())
 185         return false;
 186     if (m_opaque_sp.unique())
 187         return true;
 188
 189     TypeFilterImplSP new_sp(new TypeFilterImpl(GetOptions()));
 190
 191     for (uint32_t j = 0;
 192          j < GetNumberOfExpressionPaths();
 193          j++)
 194         new_sp->AddExpressionPath(GetExpressionPathAtIndex(j));
 195
 196     SetSP(new_sp);
 197
 198     return true;
 199 }