blob: fa228483e97f003594b01ce18eee0fc4dbca5963 (
plain)
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
118
119
120
121
122
123
124
125
126
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
* Copyright (C) 2019, Google Inc.
*
* object.cpp - Base object
*/
#include <libcamera/object.h>
#include <libcamera/signal.h>
#include "log.h"
#include "thread.h"
/**
* \file object.h
* \brief Base object to support automatic signal disconnection
*/
namespace libcamera {
/**
* \class Object
* \brief Base object to support automatic signal disconnection
*
* The Object class simplifies signal/slot handling for classes implementing
* slots. By inheriting from Object, an object is automatically disconnected
* from all connected signals when it gets destroyed.
*
* Object instances are bound to the thread in which they're created. When a
* message is posted to an object, its handler will run in the object's thread.
* This allows implementing easy message passing between threads by inheriting
* from the Object class.
*
* \sa Message, Signal, Thread
*/
Object::Object()
: pendingMessages_(0)
{
thread_ = Thread::current();
}
Object::~Object()
{
for (SignalBase *signal : signals_)
signal->disconnect(this);
if (pendingMessages_)
thread()->removeMessages(this);
}
/**
* \brief Post a message to the object's thread
* \param[in] msg The message
*
* This method posts the message \a msg to the message queue of the object's
* thread, to be delivered to the object through the message() method in the
* context of its thread. Message ownership is passed to the thread, and the
* message will be deleted after being delivered.
*
* Messages are delivered through the thread's event loop. If the thread is not
* running its event loop the message will not be delivered until the event
* loop gets started.
*/
void Object::postMessage(std::unique_ptr<Message> msg)
{
thread()->postMessage(std::move(msg), this);
}
/**
* \brief Message handler for the object
* \param[in] msg The message
*
* This virtual method receives messages for the object. It is called in the
* context of the object's thread, and can be overridden to process custom
* messages. The parent Object::message() method shall be called for any
* message not handled by the override method.
*
* The message \a msg is valid only for the duration of the call, no reference
* to it shall be kept after this method returns.
*/
void Object::message(Message *msg)
{
}
/**
* \fn Object::thread()
* \brief Retrieve the thread the object is bound to
* \return The thread the object is bound to
*/
/**
* \brief Move the object to a different thread
* \param[in] thread The target thread
*
* This method moves the object from the current thread to the new \a thread.
* It shall be called from the thread in which the object currently lives,
* otherwise the behaviour is undefined.
*/
void Object::moveToThread(Thread *thread)
{
ASSERT(Thread::current() == thread_);
if (thread_ == thread)
return;
thread->moveObject(this);
}
void Object::connect(SignalBase *signal)
{
signals_.push_back(signal);
}
void Object::disconnect(SignalBase *signal)
{
for (auto iter = signals_.begin(); iter != signals_.end(); ) {
if (*iter == signal)
iter = signals_.erase(iter);
else
iter++;
}
}
}; /* namespace libcamera */
|
