- Rework ExpiringTimeTracker to be based on PolledTimeout.

- Ensure espnowDelay and floodingMeshDelay always performs maintenance.

- Rework MutexTracker to use shared_ptr.

- Change enums to enum class.

- Change typedef to using.

- Add HeapMonitor class.

- Make _messageIDs be a map instead of an unordered_map to reduce heap usage.

- Use the possibly broken wifi_country ESP8266 API to check for legal WiFi channels when setting WiFi channels.

- Make MessageData, RequestData and ResponseData contain a TimeTracker rather than inherit from TimeTracker.

- Add deprecated attribute to TransmissionResult.

- Remove superfluous elses.

- Reduce cyclomatic complexity.

- Change postfix ++ and -- to prefix.

- Generalize getEncryptedConnectionIterator method.

- Increase code NRVO compatibility.

- Change _connectionAttemptTimeoutMs type from int32_t to uint32_t.

- Add deprecated attribute to ESP8266WiFiMesh.

- Add some constness to TypeConversionFunctions.

- Move base36 arrays to PROGMEM in TypeConversionFunctions.cpp.

- Add deprecated atttribute to SHA1 and MD5 hashes.

- Remove _warningsEnabled in CryptoInterface since this has been replaced by the deprecated attribute.

- Prefix all TypeConversion getters with "get".

- Improve comments.

- Fix merge conflict.

libraries/ESP8266WiFiMesh/src/ExpiringTimeTracker.cpp

@@ -24,36 +24,101 @@
 
 #include "ExpiringTimeTracker.h"
 
-ExpiringTimeTracker::ExpiringTimeTracker(uint32_t duration, uint32_t creationTimeMs) :
-  TimeTracker(creationTimeMs), _duration(duration)
-{ }
+ExpiringTimeTracker::ExpiringTimeTracker(const uint32_t duration, const uint32_t creationTimeMs) :
+  timeoutTemplate(0)
+{ 
+  setDuration(duration);
+  _start = creationTimeMs;
+}
+
+ExpiringTimeTracker::ExpiringTimeTracker(const calculatorType durationCalculator, const uint32_t creationTimeMs) :
+  timeoutTemplate(0)
+{ 
+  setDuration(durationCalculator);
+  _start = creationTimeMs;
+}
 
 uint32_t ExpiringTimeTracker::duration() const
 {
-  return _duration;
+  if(useCalculator)
+    return _durationCalculator();
+
+  return getTimeout();
 }
 
-void ExpiringTimeTracker::setRemainingDuration(uint32_t remainingDuration)
+IRAM_ATTR // called from ISR
+void ExpiringTimeTracker::setTimeout(const uint32_t newUserTimeout)
 {
-  _duration = timeSinceCreation() + remainingDuration;
+   _timeout = newUserTimeout;
+   _neverExpires = (newUserTimeout > timeMax()); // newUserTimeout < 0 is always false for uint32_t
+}
+
+void ExpiringTimeTracker::setDuration(const uint32_t duration)
+{
+  setTimeout(duration);
+  useCalculator = false;
+}
+
+void ExpiringTimeTracker::setDuration(const calculatorType durationCalculator)
+{
+  _durationCalculator = durationCalculator;
+  useCalculator = true;
+}
+
+void ExpiringTimeTracker::setRemainingDuration(const uint32_t remainingDuration)
+{
+  setDuration(elapsedTime() + remainingDuration);
+}
+
+void ExpiringTimeTracker::setRemainingDuration(const calculatorType remainingDurationCalculator)
+{
+  uint32_t currentElapsedTime = elapsedTime();
+  setDuration([remainingDurationCalculator, currentElapsedTime](){ return currentElapsedTime + remainingDurationCalculator(); });
 }
 
 uint32_t ExpiringTimeTracker::remainingDuration() const
 {
-  uint32_t remainingDuration = duration() - timeSinceCreation();
+  uint32_t remainingDuration = 0;
   
-  if(expired())
+  if(!expired()) // If expired, overflow will probably occur for remainingDuration calculation.
   {
-    // Overflow probably occured for remainingDuration calculation.
-    return 0;
-  }
-  else
-  {
-    return remainingDuration;
+    remainingDuration = duration() - elapsedTime();
   }
+
+  return remainingDuration;
+}
+
+uint32_t ExpiringTimeTracker::elapsedTime() const
+{
+  return millis() - _start;
 }
 
 bool ExpiringTimeTracker::expired() const
-{
-  return timeSinceCreation() >= duration();
+{  
+  if(useCalculator)
+    return elapsedTime() >= duration();
+
+  return expiredOneShot();
+}
+
+void ExpiringTimeTracker::reset()
+{
+  timeoutTemplate::reset();
+}
+
+void ExpiringTimeTracker::reset(const uint32_t newDuration)
+{
+  setDuration(newDuration);
+  ExpiringTimeTracker::reset();
+}
+
+void ExpiringTimeTracker::reset(const calculatorType newDurationCalculator)
+{
+  setDuration(newDurationCalculator);
+  ExpiringTimeTracker::reset();
+}
+
+ExpiringTimeTracker::operator bool() const
+{
+  return ExpiringTimeTracker::expired();
 }