llvm-project/lldb/include/lldb/API/SBWatchpoint.h
Pavel Labath 4bc0500635 Make operator==s consistent between c++ and python APIs
Summary:
modify-python-lldb.py had code to insert python equality operators to
some classes. Some of those classes already had c++ equality operators,
and some didn't.

This makes the situation more consistent, by removing all equality
handilng from modify-python-lldb. Instead, I add c++ operators to
classes where they were missing, and expose them in the swig interface
files so that they are available to python too.

The only tricky case was the SBAddress class, which had an operator==
defined as a free function, which is not handled by swig. This function
cannot be removed without breaking ABI, and we cannot add an extra
operator== member, as that would make equality comparisons ambiguous.
For this class, I define a python __eq__ function by hand and have it
delegate to the operator!=, which I have defined as a member function.

This isn't fully NFC, as the semantics of some equality functions in
python changes slightly, but I believe it changes for the better (e.g.,
previously SBBreakpoint.__eq__ would consider two breakpoints with the
same ID as equal, even if they belonged to different targets; now they
are only equal if they belong to the same target).

Reviewers: jingham, clayborg, zturner

Subscribers: jdoerfert, JDevlieghere, lldb-commits

Differential Revision: https://reviews.llvm.org/D59819

llvm-svn: 357463
2019-04-02 10:18:46 +00:00

86 lines
1.8 KiB
C++

//===-- SBWatchpoint.h ----------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef LLDB_SBWatchpoint_h_
#define LLDB_SBWatchpoint_h_
#include "lldb/API/SBDefines.h"
namespace lldb {
class LLDB_API SBWatchpoint {
public:
SBWatchpoint();
SBWatchpoint(const lldb::SBWatchpoint &rhs);
SBWatchpoint(const lldb::WatchpointSP &wp_sp);
~SBWatchpoint();
const lldb::SBWatchpoint &operator=(const lldb::SBWatchpoint &rhs);
explicit operator bool() const;
bool operator==(const SBWatchpoint &rhs) const;
bool operator!=(const SBWatchpoint &rhs) const;
bool IsValid() const;
SBError GetError();
watch_id_t GetID();
/// With -1 representing an invalid hardware index.
int32_t GetHardwareIndex();
lldb::addr_t GetWatchAddress();
size_t GetWatchSize();
void SetEnabled(bool enabled);
bool IsEnabled();
uint32_t GetHitCount();
uint32_t GetIgnoreCount();
void SetIgnoreCount(uint32_t n);
const char *GetCondition();
void SetCondition(const char *condition);
bool GetDescription(lldb::SBStream &description, DescriptionLevel level);
void Clear();
lldb::WatchpointSP GetSP() const;
void SetSP(const lldb::WatchpointSP &sp);
static bool EventIsWatchpointEvent(const lldb::SBEvent &event);
static lldb::WatchpointEventType
GetWatchpointEventTypeFromEvent(const lldb::SBEvent &event);
static lldb::SBWatchpoint GetWatchpointFromEvent(const lldb::SBEvent &event);
private:
friend class SBTarget;
friend class SBValue;
std::weak_ptr<lldb_private::Watchpoint> m_opaque_wp;
};
} // namespace lldb
#endif // LLDB_SBWatchpoint_h_