17#ifndef CYBER_NODE_NODE_H_
18#define CYBER_NODE_NODE_H_
31template <
typename M0,
typename M1,
typename M2,
typename M3>
46 template <
typename M0,
typename M1,
typename M2,
typename M3>
49 friend bool Init(
const char*,
const std::string&);
50 friend std::unique_ptr<Node>
CreateNode(
const std::string&,
58 const std::string&
Name()
const;
68 template <
typename MessageT>
70 -> std::shared_ptr<Writer<MessageT>>;
79 template <
typename MessageT>
81 -> std::shared_ptr<Writer<MessageT>>;
93 template <
typename MessageT>
96 -> std::shared_ptr<cyber::Reader<MessageT>>;
107 template <
typename MessageT>
110 -> std::shared_ptr<cyber::Reader<MessageT>>;
121 template <
typename MessageT>
124 -> std::shared_ptr<cyber::Reader<MessageT>>;
135 template <
typename Request,
typename Response>
139 -> std::shared_ptr<Service<Request, Response>>;
149 template <
typename Request,
typename Response>
151 -> std::shared_ptr<Client<Request, Response>>;
173 template <
typename MessageT>
174 auto GetReader(
const std::string& channel_name)
175 -> std::shared_ptr<Reader<MessageT>>;
178 explicit Node(
const std::string& node_name,
179 const std::string& name_space =
"");
181 std::string node_name_;
182 std::string name_space_;
184 std::mutex readers_mutex_;
185 std::map<std::string, std::shared_ptr<ReaderBase>> readers_;
187 std::unique_ptr<NodeChannelImpl> node_channel_impl_ =
nullptr;
188 std::unique_ptr<NodeServiceImpl> node_service_impl_ =
nullptr;
191template <
typename MessageT>
193 -> std::shared_ptr<Writer<MessageT>> {
194 return node_channel_impl_->template CreateWriter<MessageT>(role_attr);
197template <
typename MessageT>
199 -> std::shared_ptr<Writer<MessageT>> {
200 return node_channel_impl_->template CreateWriter<MessageT>(channel_name);
203template <
typename MessageT>
206 -> std::shared_ptr<Reader<MessageT>> {
207 std::lock_guard<std::mutex> lg(readers_mutex_);
208 if (readers_.find(role_attr.channel_name()) != readers_.end()) {
209 AWARN <<
"Failed to create reader: reader with the same channel already "
213 auto reader = node_channel_impl_->template CreateReader<MessageT>(
214 role_attr, reader_func);
215 if (reader !=
nullptr) {
216 readers_.emplace(std::make_pair(role_attr.channel_name(), reader));
221template <
typename MessageT>
224 -> std::shared_ptr<cyber::Reader<MessageT>> {
225 std::lock_guard<std::mutex> lg(readers_mutex_);
226 if (readers_.find(config.channel_name) != readers_.end()) {
227 AWARN <<
"Failed to create reader: reader with the same channel already "
232 node_channel_impl_->template CreateReader<MessageT>(config, reader_func);
233 if (reader !=
nullptr) {
234 readers_.emplace(std::make_pair(config.channel_name, reader));
239template <
typename MessageT>
242 -> std::shared_ptr<Reader<MessageT>> {
243 std::lock_guard<std::mutex> lg(readers_mutex_);
244 if (readers_.find(channel_name) != readers_.end()) {
245 AWARN <<
"Failed to create reader: reader with the same channel already "
249 auto reader = node_channel_impl_->template CreateReader<MessageT>(
250 channel_name, reader_func);
251 if (reader !=
nullptr) {
252 readers_.emplace(std::make_pair(channel_name, reader));
257template <
typename Request,
typename Response>
259 const std::string& service_name,
261 service_callback) -> std::shared_ptr<Service<Request, Response>> {
262 return node_service_impl_->template CreateService<Request, Response>(
263 service_name, service_callback);
266template <
typename Request,
typename Response>
268 -> std::shared_ptr<Client<Request, Response>> {
269 return node_service_impl_->template CreateClient<Request, Response>(
273template <
typename MessageT>
275 -> std::shared_ptr<Reader<MessageT>> {
276 std::lock_guard<std::mutex> lg(readers_mutex_);
277 auto it = readers_.find(name);
278 if (it != readers_.end()) {
279 return std::dynamic_pointer_cast<Reader<MessageT>>(it->second);
Node is the fundamental building block of Cyber RT.
bool DeleteReader(const std::string &channel_name)
auto CreateReader(const std::string &channel_name, const CallbackFunc< MessageT > &reader_func=nullptr) -> std::shared_ptr< cyber::Reader< MessageT > >
Create a Reader with specific message type with channel name qos and other configs used will be defau...
friend std::unique_ptr< Node > CreateNode(const std::string &, const std::string &)
auto GetReader(const std::string &channel_name) -> std::shared_ptr< Reader< MessageT > >
Get the Reader object that subscribe channel_name
void ClearData()
clear all readers' data
auto CreateClient(const std::string &service_name) -> std::shared_ptr< Client< Request, Response > >
Create a Client object to request Service with service_name
const std::string & Name() const
Get node's name.
auto CreateService(const std::string &service_name, const typename Service< Request, Response >::ServiceCallback &service_callback) -> std::shared_ptr< Service< Request, Response > >
Create a Service object with specific service_name
friend bool Init(const char *, const std::string &)
auto CreateWriter(const proto::RoleAttributes &role_attr) -> std::shared_ptr< Writer< MessageT > >
Create a Writer with specific message type.
void Observe()
Observe all readers' data
std::function< void(const std::shared_ptr< Request > &, std::shared_ptr< Response > &)> ServiceCallback
std::function< void(const std::shared_ptr< M0 > &)> CallbackFunc