GCC Code Coverage Report

Directory: ./
File: src/phoenix_composeType.h
Date: 2025-11-27 16:23:05
Exec Total Coverage
Lines: 20 21 95.2%
Functions: 33 33 100.0%
Branches: 27 30 90.0%
Line Branch Exec Source
1 /***************************************
2 Auteur : Pierre Aubert
3 Mail : pierre.aubert@lapp.in2p3.fr
4 Licence : CeCILL-C
5 ****************************************/
6
7 #ifndef __PHOENIX_COMPOSETYPE_H__
8 #define __PHOENIX_COMPOSETYPE_H__
9
10 #include <string>
11 #include <vector>
12 #include <map>
13
14 #include "type_stream_get_type.h"
15
16 template <typename R, typename... T>
17 std::string phoenix_getTypeToStr(R (*func)(T...));
18
19 ///@brief Generic DataStream class
20 template<typename T>
21 struct TypeStream{
22 ///Convert the generic type into a string
23 /** @return corresponding string
24 */
25 42 static std::string getTypeToStr(){
26 42 return phoenix_getTypeName<T>();
27 }
28 };
29
30 ///@brief Generic std::vector type abstraction
31 template<typename T>
32 struct TypeStream<std::vector<T> >{
33 ///Convert the std::vector< T > type into a string
34 /** @return corresponding string
35 */
36 2 static std::string getTypeToStr(){
37
3/3
✓ Branch 0 (2→3) taken 2 times.
✓ Branch 2 (3→4) taken 2 times.
✓ Branch 4 (4→5) taken 2 times.
 2 return "std::vector<" + TypeStream<T>::getTypeToStr() + " >";
38 }
39 };
40
41 ///@brief Generic std::list type abstraction
42 template<typename T>
43 struct TypeStream<std::list<T> >{
44 ///Convert the std::list< T > type into a string
45 /** @return corresponding string
46 */
47 2 static std::string getTypeToStr(){
48
3/3
✓ Branch 0 (2→3) taken 2 times.
✓ Branch 2 (3→4) taken 2 times.
✓ Branch 4 (4→5) taken 2 times.
 2 return "std::list<" + TypeStream<T>::getTypeToStr() + " >";
49 }
50 };
51
52 ///@brief Generic std::map type abstraction
53 template<typename T, typename U>
54 struct TypeStream<std::map<T, U> >{
55 ///Convert the std::map< T > type into a string
56 /** @return corresponding string
57 */
58 2 static std::string getTypeToStr(){
59
6/6
✓ Branch 0 (2→3) taken 2 times.
✓ Branch 2 (3→4) taken 2 times.
✓ Branch 4 (4→5) taken 2 times.
✓ Branch 6 (5→6) taken 2 times.
✓ Branch 8 (6→7) taken 2 times.
✓ Branch 10 (7→8) taken 2 times.
 2 return "std::map<" + TypeStream<T>::getTypeToStr() + ", " + TypeStream<U>::getTypeToStr() + " >";
60 }
61 };
62
63 ///@brief Generic std::pair type abstraction
64 template<typename T, typename U>
65 struct TypeStream<std::pair<T, U> >{
66 ///Convert the std::pair< T, U > type into a string
67 /** @return corresponding string
68 */
69 2 static std::string getTypeToStr(){
70
6/6
✓ Branch 0 (2→3) taken 2 times.
✓ Branch 2 (3→4) taken 2 times.
✓ Branch 4 (4→5) taken 2 times.
✓ Branch 6 (5→6) taken 2 times.
✓ Branch 8 (6→7) taken 2 times.
✓ Branch 10 (7→8) taken 2 times.
 2 return "std::pair<" + TypeStream<T>::getTypeToStr() + ", " + TypeStream<U>::getTypeToStr() + " >";
71 }
72 };
73
74 template<typename T>
75 std::string phoenix_getTypeToStr();
76 template<typename T>
77 std::string phoenix_getTypeToStr(const T & data);
78
79 ///@brief Serialise a call type into a std::string
80 template <int First, int Last>
81 struct ConvertTupleTypeToString{
82 ///Create the corresponding string to a tuple
83 /** @param tupleCall : called tuple of function parameters
84 * @return corresponding string
85 */
86 template <typename T>
87 10 static std::string getTypeToStr(const T & tupleCall){
88 if(First < Last){
89 10 auto value = std::get<First>(tupleCall);
90
1/3
✓ Branch 0 (3→4) taken 10 times.
✗ Branch 2 (14→15) not taken.
✗ Branch 3 (14→16) not taken.
 10 std::string type = phoenix_getTypeToStr(value);
91 if(First + 1 < Last){
92
1/1
✓ Branch 0 (4→5) taken 4 times.
 4 type += ", ";
93 }
94
2/2
✓ Branch 0 (4→5) taken 10 times.
✓ Branch 2 (5→6) taken 10 times.
 10 type += ConvertTupleTypeToString<First+1, Last>::getTypeToStr(tupleCall);
95
1/2
✗ Branch 0 (7→8) not taken.
✓ Branch 1 (7→9) taken 10 times.
 10 return type;
96 ✗ }
97 return "";
98 }
99 };
100
101 ///@brief Serialise a call type into a std::string
102 template <int N>
103 struct ConvertTupleTypeToString<N, N>{
104 ///End function which creates the corresponding vectortrue of PComposeType to a function call
105 /** @param[out] vecType : vector of PComposeType of the function call
106 * @param tupleCall : called tuple of function parameters
107 * @return true on success, false otherwise
108 */
109 template <typename T>
110
1/1
✓ Branch 0 (4→5) taken 7 times.
 21 static std::string getTypeToStr(const T & tupleCall){return "";}
111 };
112
113 ///@brief Generic std::tuple type abstraction
114 template<typename... T>
115 struct TypeStream<std::tuple<T... > >{
116 ///Convert the std::tuple< T > type into a string
117 /** @return corresponding string
118 */
119 7 static std::string getTypeToStr(){
120 6 std::tuple<T...> args = std::tuple<T...>();
121
3/3
✓ Branch 0 (2→3) taken 7 times.
✓ Branch 2 (3→4) taken 7 times.
✓ Branch 4 (4→5) taken 7 times.
 7 return "std::tuple<" + ConvertTupleTypeToString<0, std::tuple_size<std::tuple<T... > >{} >::getTypeToStr(args) + " >";
122 }
123 };
124
125
126 #include "phoenix_composeType_impl.h"
127
128 #endif
129