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
18using namespace lldb;
19using namespace lldb_private;
20
21SBTypeFilter::SBTypeFilter() :
22m_opaque_sp()
23{
24}
25
26SBTypeFilter::SBTypeFilter (uint32_t options)
27: m_opaque_sp(TypeFilterImplSP(new TypeFilterImpl(options)))
28{
29}
30
31SBTypeFilter::SBTypeFilter (const lldb::SBTypeFilter &rhs) :
32m_opaque_sp(rhs.m_opaque_sp)
33{
34}
35
36SBTypeFilter::~SBTypeFilter ()
37{
38}
39
40bool
41SBTypeFilter::IsValid() const
42{
43    return m_opaque_sp.get() != NULL;
44}
45
46uint32_t
47SBTypeFilter::GetOptions()
48{
49    if (IsValid())
50        return m_opaque_sp->GetOptions();
51    return 0;
52}
53
54void
55SBTypeFilter::SetOptions (uint32_t value)
56{
57    if (CopyOnWrite_Impl())
58        m_opaque_sp->SetOptions(value);
59}
60
61bool
62SBTypeFilter::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
74void
75SBTypeFilter::Clear()
76{
77    if (CopyOnWrite_Impl())
78        m_opaque_sp->Clear();
79}
80
81uint32_t
82SBTypeFilter::GetNumberOfExpressionPaths()
83{
84    if (IsValid())
85        return m_opaque_sp->GetCount();
86    return 0;
87}
88
89const char*
90SBTypeFilter::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
102bool
103SBTypeFilter::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
111void
112SBTypeFilter::AppendExpressionPath (const char* item)
113{
114    if (CopyOnWrite_Impl())
115        m_opaque_sp->AddExpressionPath(item);
116}
117
118lldb::SBTypeFilter &
119SBTypeFilter::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
128bool
129SBTypeFilter::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
137bool
138SBTypeFilter::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
155bool
156SBTypeFilter::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
164lldb::TypeFilterImplSP
165SBTypeFilter::GetSP ()
166{
167    return m_opaque_sp;
168}
169
170void
171SBTypeFilter::SetSP (const lldb::TypeFilterImplSP &typefilter_impl_sp)
172{
173    m_opaque_sp = typefilter_impl_sp;
174}
175
176SBTypeFilter::SBTypeFilter (const lldb::TypeFilterImplSP &typefilter_impl_sp) :
177m_opaque_sp(typefilter_impl_sp)
178{
179}
180
181bool
182SBTypeFilter::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}
200