include/lldb/API/SBBreakpointName.h


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

//===-- SBBreakpointName.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_SBBreakpointName_h_
#define LLDB_SBBreakpointName_h_

#include "lldb/API/SBDefines.h"

class SBBreakpointNameImpl;

namespace lldb {

class LLDB_API SBBreakpointName {
public:
//  typedef bool (*BreakpointHitCallback)(void *baton, SBProcess &process,
//                                        SBThread &thread,
//                                        lldb::SBBreakpointLocation &location);

  SBBreakpointName();
  
  SBBreakpointName(SBTarget &target, const char *name);
  
  SBBreakpointName(SBBreakpoint &bkpt, const char *name);

  SBBreakpointName(const lldb::SBBreakpointName &rhs);

  ~SBBreakpointName();

  const lldb::SBBreakpointName &operator=(const lldb::SBBreakpointName &rhs);

  // Tests to see if the opaque breakpoint object in this object matches the
  // opaque breakpoint object in "rhs".
  bool operator==(const lldb::SBBreakpointName &rhs);

  bool operator!=(const lldb::SBBreakpointName &rhs);

  bool IsValid() const;
  
  const char *GetName() const;

  void SetEnabled(bool enable);

  bool IsEnabled();

  void SetOneShot(bool one_shot);

  bool IsOneShot() const;

  void SetIgnoreCount(uint32_t count);

  uint32_t GetIgnoreCount() const;

  void SetCondition(const char *condition);

  const char *GetCondition();

  void SetAutoContinue(bool auto_continue);

  bool GetAutoContinue();

  void SetThreadID(lldb::tid_t sb_thread_id);

  lldb::tid_t GetThreadID();

  void SetThreadIndex(uint32_t index);

  uint32_t GetThreadIndex() const;

  void SetThreadName(const char *thread_name);

  const char *GetThreadName() const;

  void SetQueueName(const char *queue_name);

  const char *GetQueueName() const;

  void SetCallback(SBBreakpointHitCallback callback, void *baton);

  void SetScriptCallbackFunction(const char *callback_function_name);

  void SetCommandLineCommands(SBStringList &commands);

  bool GetCommandLineCommands(SBStringList &commands);

  SBError SetScriptCallbackBody(const char *script_body_text);
  
  const char *GetHelpString() const;
  void SetHelpString(const char *help_string);
  
  bool GetAllowList() const;
  void SetAllowList(bool value);
    
  bool GetAllowDelete();
  void SetAllowDelete(bool value);
    
  bool GetAllowDisable();
  void SetAllowDisable(bool value);

  bool GetDescription(lldb::SBStream &description);

private:
  friend class SBTarget;
  
  lldb_private::BreakpointName *GetBreakpointName() const;
  void UpdateName(lldb_private::BreakpointName &bp_name);

  std::unique_ptr<SBBreakpointNameImpl> m_impl_up;
};

} // namespace lldb

#endif // LLDB_SBBreakpointName_h_