Rename header file to hpp.

Change-Id: I399e0c0f39b18e63e254825b6322faf77896a264
Signed-off-by: Romain Forlot <romain.forlot@iot.bzh>

1 files changed, 74 insertions, 51 deletions

diff --git a/src/can_decode_message.cpp b/src/can_decode_message.cpp
index 6bb6459..7e20f88 100644
--- a/src/can_decode_message.cpp
+++ b/src/can_decode_message.cpp
@@ -23,8 +23,8 @@
 
 #include <afb/afb-binding.h>
 
-#include "can-utils.h"
-#include "can-decoder.h"
+#include "can-utils.hpp"
+#include "can-decoder.hpp"
 #include "openxc.pb.h"
 
 union DynamicField
@@ -36,36 +36,35 @@ union DynamicField
 
 void can_decode_message(can_bus_t &can_bus)
 {
-	can_message_t *can_message;
+	can_message_t can_message;
 	std:vector <CanSignal> signals;
 	std:vector <CanSignal>::iterator signals_i;
 	openxc_VehicleMessage vehicle_message;
 	openxc_DynamicField search_key, ret;
+	bool send = true;
 	
 	decoder_t decoder();
 
-
 	while(true)
 	{
 		if(can_message = can_bus.next_can_message())
 		{
 			/* First we have to found which CanSignal is */
-			DynamicField signal_id = (double)can_message.get_id();
-			search_key = build_DynamicField(openxc_DynamicField_Type_NUM, signal_id)
+			search_key = build_DynamicField(openxc_DynamicField_Type::openxc_DynamicField_Type_NUM, (double)can_message.get_id())
 
-			signals = find_signals(search_key);
+			signals = find_can_signals(search_key);
 			
 			/* Decoding the message ! Don't kill the messenger ! */
-			for(signals_i=signals.begin(); signal_i != signals.end(); signals_i++)
-			{
-				subscribed_signals_i = subscribed_signals.find(signals_i);
+			for(const auto& sig : signals)
+			{	
+			  subscribed_signals_i = subscribed_signals.find(sig);
 				
 				if(subscribed_signals_i != subscribed_signals.end() &&
 					afb_event_is_valid(subscribed_signals_i->second))
 				{
-					ret = decoder.decodeSignal(&sig, can_message, SIGNALS, SIGNALS.size(), true);
+					ret = decoder.decodeSignal(sig, can_message, getSignals(), &send);
 
-					s_message = build_SimpleMessage(subscribed_signals_i->first->genericName, ret);
+					s_message = build_SimpleMessage(sig.genericName, ret);
 						
 					vehicle_message = build_VehicleMessage_with_SimpleMessage(openxc_DynamicField_Type::openxc_DynamicField_Type_NUM, s_message);
 					vehicle_message_q.push(vehicle_message);
@@ -79,69 +78,93 @@ void can_decode_message(can_bus_t &can_bus)
  * Build a specific VehicleMessage containing a SimpleMessage.
  */
 openxc_VehicleMessage build_VehicleMessage_with_SimpleMessage(openxc_DynamicField_Type type,
-															  openxc_SimpleMessage message)
+	const openxc_SimpleMessage& message)
 {
 	struct timeb t_msec;
 	long long int timestamp_msec;
+	
+	openxc_VehicleMessage v = {0};
+	
 	if(!ftime(&t_msec))
 	{
 		timestamp_msec = ((long long int) t_msec.time) * 1000ll + 
                         (long long int) t_msec.millitm;
 
-	return openxc_VehicleMessage v = {.has_type = true,
-					  .type = openxc_VehicleMessage_Type::openxc_VehicleMessage_Type_SIMPLE,
-					  .has_simple_message = true,
-					  .simple_message =  message,
-					  .has_timestamp = true,
-					  .timestamp = timestamp_msec};
+	  v.has_type = true:
+		v.type = openxc_VehicleMessage_Type::openxc_VehicleMessage_Type_SIMPLE;
+		v.has_simple_message = true;
+		v.simple_message =  message;
+		v.has_timestamp = true;
+		v.timestamp = timestamp_msec;
+		
+	  return v;
 	}
 
-	return openxc_VehicleMessage v = {.has_type = true,
-					  .type = openxc_VehicleMessage_Type::openxc_VehicleMessage_Type_SIMPLE,
-					  .has_simple_message = true,
-					  .simple_message =  message};
+	v.has_type = true,
+	v.type = openxc_VehicleMessage_Type::openxc_VehicleMessage_Type_SIMPLE;
+	v.has_simple_message = true;
+	v.simple_message =  message;
+					  
+  return v;
 }
 
 /*
  * Build an openxc_SimpleMessage associating a name to an openxc_DynamicField
  */
-openxc_SimpleMessage build_SimpleMessage(std:string name, openxc_DynamicField value)
+openxc_SimpleMessage build_SimpleMessage(const std::string& name, const openxc_DynamicField& value)
 {
-	return openxc_SimpleMessage s = {.has_name = true,
-									 .name = name,
-									 .has_value = true,
-									 .value = value};
+  
+  openxc_SimpleMessage s = {0};
+  
+  s.has_name = true;
+  ::strncpy(s.name, name.c_str(), 100);
+	s.has_value = true;
+  s.value = value;
+  
+	return s;
 }
 
-
+/* 
+ * Build an openxc_DynamicField depending what we pass as argument
+ */
+openxc_DynamicField build_DynamicField(const std::string& value)
+{
+  openxc_DynamicField d = {0}
+	d.has_type = true;
+	d.type = openxc_DynamicField_Type_STRING;
+	
+	d.has_string_value = true;
+	::strncpy(d.string_value, value.c_tr(), 100);
+	
+	return d;
 }
 
 /* 
- * Build an openxc_DynamicField using its type and an union.
- * Why do not use of union in first place anyway...
+ * Build an openxc_DynamicField depending what we pass as argument
  */
-openxc_DynamicField build_DynamicField(openxc_DynamicField_Type type, DynamicField field)
+openxc_DynamicField build_DynamicField(double value)
 {
-	openxc_DynamicField d = {.has_type = true,
-									.type = type};
+  openxc_DynamicField d = {0}
+	d.has_type = true;
+	d.type = openxc_DynamicField_Type_NUM;
 	
-	switch(type)
-	{
-		case openxc_DynamicField_Type_BOOL:
-			d.has_boolean_value = true;
-			d.boolean_value = field;
-			break;
-		case openxc_DynamicField_Type_NUM:
-			d.has_numeric_value = true;
-			d.numeric_value = field;
-			break;
-		case openxc_DynamicField_Type_STRING:
-			d.has_string_value = true;
-			strcpy(d.string_value, field);
-			break;
-		default:
-			return nullptr;
-	}
+	d.has_numeric_value = true;
+	d.numeric_value = field;
+	
+	return d;
+}
 
+/* 
+ * Build an openxc_DynamicField depending what we pass as argument
+ */
+openxc_DynamicField build_DynamicField(bool value)
+{
+  openxc_DynamicField d = {0}
+	d.has_type = true;
+	d.type = openxc_DynamicField_Type_BOOL;
+	
+	d.has_boolean_value = true;
+	d.boolean_value = field;
+	
 	return d;
 }
\ No newline at end of file