Remove unnecessary include

Author: MathewHDYT

src/Callback.h

@@ -3,7 +3,6 @@
 
 // Local includes.
 #include "Configuration.h"
-#include "Container.h"
 
 // Library includes.
 #include <ArduinoJson.h>
@@ -17,22 +16,24 @@
 /// @brief Container signature, makes it possible to use the Container name everywhere instead of having to differentiate between C++ STL support or not
 template<typename T>
 using Container = std::vector<T>;
+#else
+#include "Container.h"
 #endif // THINGSBOARD_ENABLE_STL && THINGSBOARD_ENABLE_DYNAMIC
 
 
 /// @brief General purpose safe callback wrapper. Expects either c-style or c++ style function pointer,
 /// depending on if the C++ STL has been implemented on the given device or not.
 /// Simply wraps that function pointer and before calling it ensures it is valid
-/// @tparam return_typ Type the given callback method should return
+/// @tparam return_type Type the given callback method should return
 /// @tparam argument_types Types the given callback method should receive
-template<typename return_typ, typename... argument_types>
+template<typename return_type, typename... argument_types>
 class Callback {
   public:
     /// @brief Callback signature
 #if THINGSBOARD_ENABLE_STL
-    using function = std::function<return_typ(argument_types... arguments)>;
+    using function = std::function<return_type(argument_types... arguments)>;
 #else
-    using function = return_typ (*)(argument_types... arguments);
+    using function = return_type (*)(argument_types... arguments);
 #endif // THINGSBOARD_ENABLE_STL
 
     /// @brief Constructs empty callback, will result in never being called. Internals are simply default constructed as nullptr
@@ -58,9 +59,9 @@ class Callback {
     /// @param ...arguments Optional additional arguments that are simply formwarded to the subscribed callback if it exists
     /// @return Argument returned by the previously subscribed callback or if none or nullptr is subscribed
     /// we instead return a defaulted instance of the requested return variable
-    return_typ Call_Callback(argument_types const &... arguments) const {
+    return_type Call_Callback(argument_types const &... arguments) const {
         if (!m_callback) {
-          return return_typ();
+          return return_type();
         }
         return m_callback(arguments...);
     }