WebSVN – HomeAutomation – Diff – /trunk/PcSoftware/Atom1.5/src/can/Protocol.cpp

 #include "Protocol.h"
 #include <stdexcept>
 #include <string.h>
+#include <stdint.h>
 #include <boost/lexical_cast.hpp>
 #include "common/log.h"
 namespace atom {
 namespace can {
 Protocol::Pointer Protocol::instance_;
 static const std::string log_module_ = "can::protocol";
 Protocol::Protocol() : LOG("can::Protocol")
+{
+}
 Protocol::~Protocol()
 {
 }
 void Protocol::Create()
+{
   Protocol::instance_ = Protocol::Pointer(new Protocol());
 }
 Protocol::Pointer Protocol::Instance()
+{
   return Protocol::instance_;
 }
 void Protocol::Delete()
+{
   Protocol::instance_.reset();
+}
 bool Protocol::Load(std::string file_path)
+{
   try
+  {
     this->root_node_.LoadFile(file_path);
   }
   catch (std::runtime_error& e)
   {
     LOG.Error(e.what());
     return false;
+  }
   LOG.Info("Protocol loaded successfully.");
 std::string Protocol::LookupNMTCommandName(unsigned int command_id)
+{
     try
+    {
         return this->root_node_.FindChild("nmt_messages").SelectChild("id", boost::lexical_cast<std::string>(command_id)).GetAttributeValue("name");
     }
     catch (std::runtime_error& e)
     {
         LOG.Error(e.what());
         throw std::runtime_error("No such nmt command found, id = " + boost::lexical_cast<std::string>(command_id));
     }
+}
 unsigned int Protocol::ResolveNMTCommandId(std::string command_name)
 {
     try
+    {
         return boost::lexical_cast<unsigned int >(this->root_node_.FindChild("nmt_messages").SelectChild("name", command_name).GetAttributeValue("id"));
     }
+    catch (std::runtime_error& e)
+    {
+        LOG.Error(e.what());
+        throw std::runtime_error("No such nmt command found, name = " + command_name);
+    }
+}
+std::string Protocol::GetDefineId(std::string name, std::string group)
+{
+    try
+    {
+        return this->root_node_.FindChild("defines").SelectChild("name", name, "group", group).GetAttributeValue("id");
+    }
     catch (std::runtime_error& e)
     {
-        LOG.Error(e.what());
-        throw std::runtime_error("No such nmt command found, name = " + command_name);
-    }
-}
-std::string Protocol::GetDefineId(std::string name, std::string group)
-{
-    try
-    {
-        return this->root_node_.FindChild("defines").SelectChild("name", name, "group", group).GetAttributeValue("id");
-    }
-    catch (std::runtime_error& e)
-    {
         LOG.Error(e.what());
         throw std::runtime_error("No such define found, name = " + name + ", group = " + group);
     }
+}
 std::string Protocol::LookupDirectionFlag(unsigned int direction_flag)
+{
     try
+    {
         return this->root_node_.FindChild("defines").SelectChild("id", boost::lexical_cast<std::string>(direction_flag), "group", "DirectionFlag").GetAttributeValue("name");
+    }
     catch (std::runtime_error& e)
+    {
         LOG.Error(e.what());
         throw std::runtime_error("No such direction flag found, direction_flag = " + boost::lexical_cast<std::string>(direction_flag));
     }
+}
 unsigned int Protocol::ResolveDirectionFlag(std::string direction_name)
+{
     try
     {
         return boost::lexical_cast<unsigned int>(this->root_node_.FindChild("defines").SelectChild("name", direction_name, "group", "DirectionFlag").GetAttributeValue("id"));
     }
     catch (std::runtime_error& e)
     {
         LOG.Error(e.what());
         throw std::runtime_error("No such direction flag found, direction_name = " + direction_name);
     }
 }
 std::string Protocol::LookupModuleName(unsigned int module_id)
 {
     try
     {
         return this->root_node_.FindChild("modules").SelectChild("id", boost::lexical_cast<std::string>(module_id)).GetAttributeValue("name");
+    }
     catch (std::runtime_error& e)
+    {
         LOG.Error(e.what());
 unsigned int Protocol::ResolveModuleId(std::string module_name)
+{
     if (module_name == "")
+    {
         return 0;
     }
     try
     {
         return boost::lexical_cast<unsigned int>(this->root_node_.FindChild("modules").SelectChild("name", module_name).GetAttributeValue("id"));
     }
     catch (std::runtime_error& e)
     {
         LOG.Error(e.what());
         throw std::runtime_error("No such module name found, " + module_name);
     }
 }
 xml::Node::NodeList Protocol::GetCommandVariables(std::string command_name, std::string module_name)
 {
     xml::Node node;
     try
+    {
         node = this->root_node_.FindChild("commands").SelectChild("name", command_name, "module", module_name);
         try
         {
             return node.FindChild("variables").GetChildren();
         }
         catch (std::runtime_error& e)
         {
             return xml::Node::NodeList();
         }
     }
     catch (std::runtime_error& e)
     {
     }
     try
     {
         node = this->root_node_.FindChild("commands").SelectChild("name", command_name);
         try
         {
             return node.FindChild("variables").GetChildren();
         }
         catch (std::runtime_error& e)
         {
             return xml::Node::NodeList();
         }
     }
     catch (std::runtime_error& e)
+    {
         LOG.Error(e.what());
         throw std::runtime_error("Could not find variables for command, name = " + command_name + ", module = " + module_name);
+    }
     bitset.Write(start_bit, bit_length, raw_bit_value);
+}
 std::string Protocol::DecodeUint(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)
+{
-    unsigned long raw_bit_value = bitset.Read(start_bit, bit_length);
+    uint64_t raw_bit_value = bitset.Read(start_bit, bit_length);
     //LOG.Debug("DecodeUint: raw_bit_value=" + boost::lexical_cast<std::string>(raw_bit_value));
-    return boost::lexical_cast<std::string>((unsigned long)raw_bit_value);
+    return boost::lexical_cast<std::string>((uint64_t)raw_bit_value);
+}
 void Protocol::EncodeUint(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length, std::string value)
+{
-    unsigned long raw_bit_value = boost::lexical_cast<unsigned long>(value);
+    uint64_t raw_bit_value = boost::lexical_cast<uint64_t>(value);
     bitset.Write(start_bit, bit_length, raw_bit_value);
+}
 std::string Protocol::DecodeFloat(common::Bitset& bitset, unsigned int start_bit, unsigned int bit_length)

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom1.5/src/can/Protocol.cpp – Rev 2066 → 2118