devbox
小桥流水78
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

百度自动驾驶apollo源码解读16:/cyber/message 模块_百度apollo 2.0源码

作者：小桥流水78 | 2024-07-21 23:43:07

赞

踩

百度apollo 2.0源码

此模块主要实现的是protobuf的序列化和反序列化的工作，主要包含以下文件：
1.message_header系列(头文件、测试文件)：消息头，序列化的时候将次头放在protobuf形成的内存前面，主要记录一些属性值，比如消息序列号、消息体的大小等，message_traits里面有两个接口ParseFromHC和SerializeToHC 就是专用来序列化和反序列化带这种带消息头的数据的，我们知道cyber有三种通讯方式：1.同进程内部 2.同主机跨进程 3.不同主机 值得注意的是只有第一种方式采用的上这种消息头，具体为什么以后在做分析
2.message_traits系列(头文件、测试文件)：序列化和反序列化和message的属性设置、查询接口汇总。此文件众多接口存在的意义：cyber收发消息种类总分为三种：
        a.由.proto文件编译生成的，这种消息都是继承自google::protobuf::Message，并且会自带很多接口函数，比如查询、设置字段值的，查询设置整体proto属性值的，比如SetTypeName、ByteSizeLong等，有静态函数，也有成员函数，还有序列化、反序列化的ParseFromArray、ParseFromString、SerializeToArray、SerializeToString等
        b.原始消息RawMessage，有文件raw_message实现，为了统一规范，该类实现了类似protobuf实现的接口函数
        c.用于python通信的PyMessageWrap，由py_message文件实现，原理类似RawMessage。说完了消息种类有三种，第一种还是不定数量的实现，为了给他们提供统一的对外接口，才有了该文件，对模板函数进行多次重载，用于实现不同的消息种类，最后给外面呈现的统一接口名字。
3.protobuf_factory系列(头文件、实现文件、测试文件、traits文件)：对消息进行注册和查询，注册主要包括消息、消息描述、消息文件描述等，注册之后就可以根据上述任一值查询到其他值。
4.py_message系列(头文件、测试文件、traits文件)：用于python使用cyber通讯的消息体，（个人拙见：traits文件存在意义不大，因为message_traits写的模板类已包含对应的功能）
5.raw_message系列(头文件、测试文件、traits文件)：用于普通消息使用cyber通讯的消息体，（个人拙见：traits文件存在意义不大，因为message_traits写的模板类已包含对应的功能）

有个问题：py_message和raw_message两个两个类存在的意义是什么，仿照proto生成方式生成了一些列接口函数，我的最初猜测是除了传递proto消息外多了一种传递格式，按道理来讲proto是跨语言的，也就是说C++和python可以直接通过proto格式通讯，不过后来我看了看python代码好像不是那么回事儿，cyber的python和c++通讯好像离不开py_message,详细请看我的下一篇文章。

我给message_traits.h代码文件加了注释贴出来，能看懂这个文件就能看懂其他文件吧

  1. /******************************************************************************
  2.  * Copyright 2018 The Apollo Authors. All Rights Reserved.
  3.  *
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  *
  8.  * http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  *****************************************************************************/
  16.  
  17. #ifndef CYBER_MESSAGE_MESSAGE_TRAITS_H_
  18. #define CYBER_MESSAGE_MESSAGE_TRAITS_H_
  19.  
  20. #include <string>
  21.  
  22. #include "cyber/base/macros.h"
  23. #include "cyber/common/log.h"
  24. #include "cyber/message/message_header.h"
  25. #include "cyber/message/protobuf_traits.h"
  26. #include "cyber/message/py_message_traits.h"
  27. #include "cyber/message/raw_message_traits.h"
  28.  
  29. namespace apollo {
  30. namespace cyber {
  31. namespace message {
  32.  
  33. //写在之前
  34. //typeid(T).name()在C++里面可以获取任何类型的名字，无论他是int、bool、std::map亦或者是自定义的类
  35.  
  36. //DEFINE_TYPE_TRAIT宏用法之前文章有详细的描述，在此做个大概介绍HasByteSize<T>::value的bool值可判定T有无ByteSizeLong接口
  37. //其他以此类推
  38. DEFINE_TYPE_TRAIT(HasByteSize, ByteSizeLong)
  39. DEFINE_TYPE_TRAIT(HasType, TypeName)
  40. DEFINE_TYPE_TRAIT(HasSetType, SetTypeName)
  41. DEFINE_TYPE_TRAIT(HasGetDescriptorString, GetDescriptorString)
  42. DEFINE_TYPE_TRAIT(HasDescriptor, descriptor)
  43. DEFINE_TYPE_TRAIT(HasFullName, full_name)
  44. DEFINE_TYPE_TRAIT(HasSerializeToString, SerializeToString)
  45. DEFINE_TYPE_TRAIT(HasParseFromString, ParseFromString)
  46. DEFINE_TYPE_TRAIT(HasSerializeToArray, SerializeToArray)
  47. DEFINE_TYPE_TRAIT(HasParseFromArray, ParseFromArray)
  48.  
  49. //新建一个模板类，此类可以汇总序列化接口，四个接口必须都有HasSerializer<T>::value的值才为true
  50. template <typename T>
  51. class HasSerializer {
  52.  public:
  53.   static constexpr bool value =
  54.       HasSerializeToString<T>::value && HasParseFromString<T>::value &&
  55.       HasSerializeToArray<T>::value && HasParseFromArray<T>::value;
  56. };
  57.  
  58. // avoid potential ODR violation
  59. template <typename T>
  60. constexpr bool HasSerializer<T>::value;
  61.  
  62. //七个重载函数MessageType，根据条件1.有无接口TypeName 2.接口是静态接口还是成员接口 3.是否继承自
  63. //google::protobuf::Message 4.有无函数参数 这四个条件不同情况进行不同6个的重载
  64. //重载1：有TypeName接口，是成员函数，有函数参数
  65. template <typename T,
  66.           typename std::enable_if<HasType<T>::value &&
  67.                                       std::is_member_function_pointer<
  68.                                           decltype(&T::TypeName)>::value,
  69.                                   bool>::type = 0>
  70. std::string MessageType(const T& message) {
  71.   return message.TypeName();
  72. }
  73. //重载2：有TypeName接口，不是成员函数（是静态接口），有函数参数
  74. template <typename T,
  75.           typename std::enable_if<HasType<T>::value &&
  76.                                       !std::is_member_function_pointer<
  77.                                           decltype(&T::TypeName)>::value,
  78.                                   bool>::type = 0>
  79. std::string MessageType(const T& message) {
  80.   return T::TypeName();
  81. }
  82. //重载3：无TypeName接口，不继承自google::protobuf::Message，有函数参数
  83. template <typename T,
  84.           typename std::enable_if<
  85.               !HasType<T>::value &&
  86.                   !std::is_base_of<google::protobuf::Message, T>::value,
  87.               bool>::type = 0>
  88. std::string MessageType(const T& message) {
  89.   return typeid(T).name();
  90. }
  91. //重载4：有TypeName接口，不是成员函数，没函数参数
  92. template <typename T,
  93.           typename std::enable_if<HasType<T>::value &&
  94.                                       !std::is_member_function_pointer<
  95.                                           decltype(&T::TypeName)>::value,
  96.                                   bool>::type = 0>
  97. std::string MessageType() {
  98.   return T::TypeName();
  99. }
  100. //重载5：无TypeName接口，不继承自google::protobuf::Message，没函数参数
  101. template <typename T,
  102.           typename std::enable_if<
  103.               !HasType<T>::value &&
  104.                   !std::is_base_of<google::protobuf::Message, T>::value,
  105.               bool>::type = 0>
  106. std::string MessageType() {
  107.   return typeid(T).name();
  108. }
  109. //重载6：有TypeName接口，是成员函数（是静态接口）,不继承自google::protobuf::Message，没函数参数
  110. template <
  111.     typename T,
  112.     typename std::enable_if<
  113.         HasType<T>::value &&
  114.             std::is_member_function_pointer<decltype(&T::TypeName)>::value &&
  115.             !std::is_base_of<google::protobuf::Message, T>::value,
  116.         bool>::type = 0>
  117. std::string MessageType() {
  118.   return typeid(T).name();
  119. }
  120. //SetTypeName两个重载，模板参数T有SetTypeName接口就调用，没有就不调用
  121. template <typename T>
  122. typename std::enable_if<HasSetType<T>::value, void>::type SetTypeName(
  123.     const std::string& type_name, T* message) {
  124.   message->SetTypeName(type_name);
  125. }
  126.  
  127. template <typename T>
  128. typename std::enable_if<!HasSetType<T>::value, void>::type SetTypeName(
  129.     const std::string& type_name, T* message) {}
  130. //ByteSize两个重载，模板参数T有ByteSizeLong接口就调用，没有就不调用，直接返回-1
  131. template <typename T>
  132. typename std::enable_if<HasByteSize<T>::value, int>::type ByteSize(
  133.     const T& message) {
  134.   return static_cast<int>(message.ByteSizeLong());
  135. }
  136.  
  137. template <typename T>
  138. typename std::enable_if<!HasByteSize<T>::value, int>::type ByteSize(
  139.     const T& message) {
  140.   (void)message;
  141.   return -1;
  142. }
  143. //FullByteSize代表消息头+消息体的大小
  144. template <typename T>
  145. int FullByteSize(const T& message) {
  146.   int content_size = ByteSize(message);
  147.   if (content_size < 0) {
  148.     return content_size;
  149.   }
  150.   return content_size + static_cast<int>(sizeof(MessageHeader));
  151. }
  152. //ParseFromArray两个重载，模板参数T有ParseFromArra接口就调用，没有就不调用，直接返回false
  153. template <typename T>
  154. typename std::enable_if<HasParseFromArray<T>::value, bool>::type ParseFromArray(
  155.     const void* data, int size, T* message) {
  156.   return message->ParseFromArray(data, size);
  157. }
  158.  
  159. template <typename T>
  160. typename std::enable_if<!HasParseFromArray<T>::value, bool>::type
  161. ParseFromArray(const void* data, int size, T* message) {
  162.   return false;
  163. }
  164. //ParseFromString两个重载，模板参数T有ParseFromString接口就调用，没有就不调用，直接返回false
  165. template <typename T>
  166. typename std::enable_if<HasParseFromString<T>::value, bool>::type
  167. ParseFromString(const std::string& str, T* message) {
  168.   return message->ParseFromString(str);
  169. }
  170.  
  171. template <typename T>
  172. typename std::enable_if<!HasParseFromString<T>::value, bool>::type
  173. ParseFromString(const std::string& str, T* message) {
  174.   return false;
  175. }
  176. //ParseFromHC两个重载，HC我理解为HeaderContent的缩写，思思为消息头和消息体
  177. //模板参数T有HasParseFromArray接口就做一番处理，没有直接返回false
  178. template <typename T>
  179. typename std::enable_if<HasParseFromArray<T>::value, bool>::type ParseFromHC(
  180.     const void* data, int size, T* message) {
  181.   const auto header_size = sizeof(MessageHeader);
  182.   RETURN_VAL_IF(size < (int)header_size, false);
  183.   const MessageHeader* header = static_cast<const MessageHeader*>(data);
  184.   RETURN_VAL_IF((size - header_size) < header->content_size(), false);
  185.   SetTypeName(header->msg_type(), message);
  186.   return message->ParseFromArray(
  187.       static_cast<const void*>(static_cast<const char*>(data) + header_size),
  188.       header->content_size());
  189. }
  190.  
  191. template <typename T>
  192. typename std::enable_if<!HasParseFromArray<T>::value, bool>::type ParseFromHC(
  193.     const void* data, int size, T* message) {
  194.   return false;
  195. }
  196. //SerializeToArray两个重载，模板参数T有SerializeToArray接口就调用，没有就不调用，直接返回false
  197. template <typename T>
  198. typename std::enable_if<HasSerializeToArray<T>::value, bool>::type
  199. SerializeToArray(const T& message, void* data, int size) {
  200.   return message.SerializeToArray(data, size);
  201. }
  202.  
  203. template <typename T>
  204. typename std::enable_if<!HasSerializeToArray<T>::value, bool>::type
  205. SerializeToArray(const T& message, void* data, int size) {
  206.   return false;
  207. }
  208. //SerializeToString两个重载，模板参数T有SerializeToString接口就调用，没有就不调用，直接返回false
  209. template <typename T>
  210. typename std::enable_if<HasSerializeToString<T>::value, bool>::type
  211. SerializeToString(const T& message, std::string* str) {
  212.   return message.SerializeToString(str);
  213. }
  214.  
  215. template <typename T>
  216. typename std::enable_if<!HasSerializeToString<T>::value, bool>::type
  217. SerializeToString(const T& message, std::string* str) {
  218.   return false;
  219. }
  220. //SerializeToHC两个重载，模板参数T有SerializeToArray接口就调用，没有就不调用，直接返回false
  221. template <typename T>
  222. typename std::enable_if<HasSerializeToArray<T>::value, bool>::type
  223. SerializeToHC(const T& message, void* data, int size) {
  224.   int msg_size = ByteSize(message);
  225.   if (msg_size < 0) {
  226.     return false;
  227.   }
  228.   const std::string& type_name = MessageType(message);
  229.   MessageHeader header;
  230.   header.set_msg_type(type_name.data(), type_name.size());
  231.   header.set_content_size(msg_size);
  232.   if (sizeof(header) > static_cast<size_t>(size)) {
  233.     return false;
  234.   }
  235.   char* ptr = reinterpret_cast<char*>(data);
  236.   memcpy(ptr, static_cast<const void*>(&header), sizeof(header));
  237.   ptr += sizeof(header);
  238.   int left_size = size - static_cast<int>(sizeof(header));
  239.   return SerializeToArray(message, reinterpret_cast<void*>(ptr), left_size);
  240. }
  241.  
  242. template <typename T>
  243. typename std::enable_if<!HasSerializeToArray<T>::value, bool>::type
  244. SerializeToHC(const T& message, void* data, int size) {
  245.   return false;
  246. }
  247. //GetDescriptorString三个重载之一，模板T有GetDescriptorString接口，直接调用该接口
  248. template <typename T, typename std::enable_if<HasGetDescriptorString<T>::value,
  249.                                               bool>::type = 0>
  250. void GetDescriptorString(const std::string& type, std::string* desc_str) {
  251.   T::GetDescriptorString(type, desc_str);
  252. }
  253. //GetDescriptorString三个重载之一，模板T无GetDescriptorString接口，并且非继承自google::protobuf::Message
  254. //直接返回false
  255. template <typename T,
  256.           typename std::enable_if<
  257.               !HasGetDescriptorString<T>::value &&
  258.                   !std::is_base_of<google::protobuf::Message, T>::value,
  259.               bool>::type = 0>
  260. void GetDescriptorString(const std::string& type, std::string* desc_str) {}
  261. //GetDescriptorString三个重载之一，模板T非继承自google::protobuf::Message
  262. //直接返回false(这样一看上面那个重载有点多余)
  263. template <typename MessageT,
  264.           typename std::enable_if<
  265.               !std::is_base_of<google::protobuf::Message, MessageT>::value,
  266.               int>::type = 0>
  267. void GetDescriptorString(const MessageT& message, std::string* desc_str) {}
  268. //GetFullName两个重载之一，模板参数Descriptor有full_name接口，利用T::descriptor()获取到Descriptor
  269. //感觉这个写法并不安全，没后判定模板T一定就有静态接口descriptor
  270. template <
  271.     typename T, typename Descriptor,
  272.     typename std::enable_if<HasFullName<Descriptor>::value, bool>::type = 0>
  273. std::string GetFullName() {
  274.   return T::descriptor()->full_name();
  275. }
  276. //GetFullName两个重载之二，模板参数Descriptor无full_name接口，
  277. template <
  278.     typename T, typename Descriptor,
  279.     typename std::enable_if<!HasFullName<Descriptor>::value, bool>::type = 0>
  280. std::string GetFullName() {
  281.   return typeid(T).name();
  282. }
  283.  
  284. //GetFullName三个重载之一，模板参数T有descriptor接口，T并非继承自google::protobuf::Message
  285. template <typename T,
  286.           typename std::enable_if<
  287.               HasDescriptor<T>::value &&
  288.                   !std::is_base_of<google::protobuf::Message, T>::value,
  289.               bool>::type = 0>
  290. std::string GetMessageName() {
  291.   return GetFullName<T, decltype(*T::descriptor())>();
  292. }
  293. //GetFullName三个重载之二，模板参数T有descriptor接口，T继承自google::protobuf::Message
  294. template <typename T,
  295.           typename std::enable_if<
  296.               HasDescriptor<T>::value &&
  297.                   std::is_base_of<google::protobuf::Message, T>::value,
  298.               bool>::type = 0>
  299. std::string GetMessageName() {
  300.   return T::descriptor()->full_name();
  301. }
  302. //GetFullName三个重载之三，模板参数T没有descriptor接口，
  303. template <typename T,
  304.           typename std::enable_if<!HasDescriptor<T>::value, bool>::type = 0>
  305. std::string GetMessageName() {
  306.   return typeid(T).name();
  307. }
  308.  
  309. }  // namespace message
  310. }  // namespace cyber
  311. }  // namespace apollo
  312.  
  313. #endif  // CYBER_MESSAGE_MESSAGE_TRAITS_H_

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/小桥流水78/article/detail/862644
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号