Coverage Report

Created: 2022-07-16 07:03

/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/include/lldb/Host/MainLoopBase.h
Line
Count
Source (jump to first uncovered line)
1
//===-- MainLoopBase.h ------------------------------------------*- C++ -*-===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
9
#ifndef LLDB_HOST_MAINLOOPBASE_H
10
#define LLDB_HOST_MAINLOOPBASE_H
11
12
#include "lldb/Utility/IOObject.h"
13
#include "lldb/Utility/Status.h"
14
#include "llvm/Support/ErrorHandling.h"
15
#include <functional>
16
17
namespace lldb_private {
18
19
// The purpose of this class is to enable multiplexed processing of data from
20
// different sources without resorting to multi-threading. Clients can register
21
// IOObjects, which will be monitored for readability, and when they become
22
// ready, the specified callback will be invoked. Monitoring for writability is
23
// not supported, but can be easily added if needed.
24
//
25
// The RegisterReadObject function return a handle, which controls the duration
26
// of the monitoring. When this handle is destroyed, the callback is
27
// deregistered.
28
//
29
// This class simply defines the interface common for all platforms, actual
30
// implementations are platform-specific.
31
class MainLoopBase {
32
private:
33
  class ReadHandle;
34
35
public:
36
57
  MainLoopBase() = default;
37
57
  virtual ~MainLoopBase() = default;
38
39
  typedef std::unique_ptr<ReadHandle> ReadHandleUP;
40
41
  typedef std::function<void(MainLoopBase &)> Callback;
42
43
  virtual ReadHandleUP RegisterReadObject(const lldb::IOObjectSP &object_sp,
44
                                          const Callback &callback,
45
0
                                          Status &error) {
46
0
    llvm_unreachable("Not implemented");
47
0
  }
48
49
  // Add a pending callback that will be executed once after all the pending
50
  // events are processed. The callback will be executed even if termination
51
  // was requested.
52
0
  virtual void AddPendingCallback(const Callback &callback) {
53
0
    llvm_unreachable("Not implemented");
54
0
  }
55
56
  // Waits for registered events and invoke the proper callbacks. Returns when
57
  // all callbacks deregister themselves or when someone requests termination.
58
0
  virtual Status Run() { llvm_unreachable("Not implemented"); }
59
60
  // Requests the exit of the Run() function.
61
0
  virtual void RequestTermination() { llvm_unreachable("Not implemented"); }
62
63
protected:
64
86
  ReadHandleUP CreateReadHandle(const lldb::IOObjectSP &object_sp) {
65
86
    return ReadHandleUP(new ReadHandle(*this, object_sp->GetWaitableHandle()));
66
86
  }
67
68
0
  virtual void UnregisterReadObject(IOObject::WaitableHandle handle) {
69
0
    llvm_unreachable("Not implemented");
70
0
  }
71
72
private:
73
  class ReadHandle {
74
  public:
75
86
    ~ReadHandle() { m_mainloop.UnregisterReadObject(m_handle); }
76
77
  private:
78
    ReadHandle(MainLoopBase &mainloop, IOObject::WaitableHandle handle)
79
86
        : m_mainloop(mainloop), m_handle(handle) {}
80
81
    MainLoopBase &m_mainloop;
82
    IOObject::WaitableHandle m_handle;
83
84
    friend class MainLoopBase;
85
    ReadHandle(const ReadHandle &) = delete;
86
    const ReadHandle &operator=(const ReadHandle &) = delete;
87
  };
88
89
  MainLoopBase(const MainLoopBase &) = delete;
90
  const MainLoopBase &operator=(const MainLoopBase &) = delete;
91
};
92
93
} // namespace lldb_private
94
95
#endif // LLDB_HOST_MAINLOOPBASE_H