Merge pull request #189 from ed7coyne/modular-protocols

Add concept of multiple protocols to SerialTransciever.

Author: ed7coyne

examples/FirebaseSerialHost_ESP8266/FirebaseSerialHost_ESP8266.ino

@@ -55,6 +55,7 @@ void setup() {
     delay(5000);
   }
 
+  transceiver.RegisterProtocol(new DatabaseProtocol());
   transceiver.begin(&data_serial);
 }
 

examples/FirebaseSerialTerminal_ESP8266/FirebaseSerialTerminal_ESP8266.ino

@@ -55,6 +55,7 @@ void setup() {
   Serial.print("connected: ");
   Serial.println(WiFi.localIP());
 
+  transceiver.RegisterProtocol(new DatabaseProtocol());
   transceiver.begin(&Serial);
 }
 

examples/FirebaseSerialTerminal_ESP8266/begin.txt

@@ -1,2 +1,2 @@
-BEGIN $YOUR_HOST $YOUR_SECRET
+BEGIN_DB $YOUR_HOST $YOUR_SECRET
 

src/SerialTransceiver.h

@@ -1,5 +1,8 @@
 #include <string>
 
 #include "modem/SerialTransceiver.h"
+#include "modem/db/DatabaseProtocol.h"
+
 // Bring them into the base namespace for easier use in arduino ide.
 using firebase::modem::SerialTransceiver;
+using firebase::modem::DatabaseProtocol;

src/modem/SerialProtocol.h

@@ -0,0 +1,37 @@
+#ifndef MODEM_SERIAL_PROTOCOL_H
+#define MODEM_SERIAL_PROTOCOL_H
+
+#include <WString.h>
+#include <vector>
+
+namespace firebase {
+namespace modem {
+
+class InputStream;
+class OutputStream;
+
+/*
+ * Define generic baseclass for all serial protocols that wish to share
+ * the common commandspace.
+ */
+class SerialProtocol {
+ public:
+  virtual ~SerialProtocol() = default;
+
+  /*
+   * Returns all commands this protocol supports, commands are single words.
+   * Returned vector MUST be sorted.
+   */
+  virtual const std::vector<String>& commands() const = 0;
+
+  /*
+   * Execute command, takes over the serial line until execution is done.
+   */
+  virtual void Execute(const String& command, InputStream* in, OutputStream* out) = 0;
+
+};
+
+}  // modem
+}  // firebase
+
+#endif  // MODEM_SERIAL_PROTOCOL_H

src/modem/SerialTransceiver.cpp

@@ -1,15 +1,19 @@
 #include "SerialTransceiver.h"
 
+#include <algorithm>
+
 namespace firebase {
 namespace modem {
 
 void SerialTransceiver::begin(Stream* serial) {
-  std::unique_ptr<Firebase> fbase;
-
   in_.reset(new ArduinoInputStream(serial));
   out_.reset(new ArduinoOutputStream(serial));
 }
 
+void SerialTransceiver::RegisterProtocol(std::unique_ptr<SerialProtocol> protocol) {
+  protocols_.push_back(std::move(protocol));
+}
+
 void SerialTransceiver::loop() {
   String command_name = in_->readStringUntil(' ');
 
@@ -18,44 +22,23 @@ void SerialTransceiver::loop() {
     return;
   }
 
-  if (command_name == "BEGIN") {
-    BeginCommand command;
-    if (command.execute(command_name, in_.get(), out_.get())) {
-      fbase_ = std::move(command.firebase());
+  bool command_found = false;
+  for (auto& protocol : protocols_) {
+    const std::vector<String>& commands = protocol->commands();
+    if (std::binary_search(commands.begin(), commands.end(), command_name)) {
+      protocol->Execute(command_name, in_.get(), out_.get());
+      command_found = true;
+      break;
     }
-    return;
-  } else if (!fbase_) {
-    in_->drain();
-    out_->println("-FAIL Must call BEGIN before anything else.");
-    return;
   }
 
-  std::unique_ptr<Command> command = CreateCommand(command_name, fbase_.get());
-  if (!command) {
+  if (!command_found) {
     in_->drain();
     out_->println(String("-FAIL Invalid command '") + command_name + "'." );
     return;
   }
-
-  command->execute(command_name, in_.get(), out_.get());
 }
 
-std::unique_ptr<Command> SerialTransceiver::CreateCommand(const String& text,
-                                                          Firebase* fbase) {
-  std::unique_ptr<Command> command;
-  if (text == "GET") {
-    command.reset(new GetCommand(fbase));
-  } else if (text == "SET") {
-    command.reset(new SetCommand(fbase));
-  } else if (text == "PUSH") {
-    command.reset(new PushCommand(fbase));
-  } else if (text == "REMOVE") {
-    command.reset(new RemoveCommand(fbase));
-  } else if (text == "BEGIN_STREAM") {
-    command.reset(new StreamCommand(fbase));
-  }
-  return command;
-}
 
 }  // modem
 }  // firebase

src/modem/SerialTransceiver.h

@@ -2,24 +2,30 @@
 #define MODEM_SERIAL_TRANSCIEVER_H
 
 #include <memory>
+#include <map>
 
-#include "Firebase.h"
-#include "modem/commands.h"
+#include "modem/SerialProtocol.h"
+#include "modem/input-stream.h"
+#include "modem/output-stream.h"
 
 namespace firebase {
 namespace modem {
 
 class SerialTransceiver {
  public:
+  void RegisterProtocol(std::unique_ptr<SerialProtocol> protocol);
+  // Also takes ownership as above but more arduino friendly.
+  void RegisterProtocol(SerialProtocol* protocol) {
+    RegisterProtocol(std::unique_ptr<SerialProtocol>(protocol));
+  }
+
   void begin(Stream* serial);
   void loop();
 
  private:
-  std::unique_ptr<Command> CreateCommand(const String& name, Firebase* fbase);
-
-  std::unique_ptr<Firebase> fbase_;
   std::unique_ptr<ArduinoInputStream> in_;
   std::unique_ptr<ArduinoOutputStream> out_;
+  std::vector<std::unique_ptr<SerialProtocol>> protocols_;
 };
 
 }  // modem

src/modem/command.h

@@ -0,0 +1,31 @@
+#ifndef MODEM_COMMAND_H
+#define MODEM_COMMAND_H
+
+#include "Firebase.h"
+#include "modem/output-stream.h"
+#include "modem/input-stream.h"
+
+namespace firebase {
+namespace modem {
+
+class Command {
+ public:
+  Command(Firebase* fbase) : fbase_(fbase) {}
+
+  // Execute command, reading any additional data needed from stream.
+  // Return false if execution failed.
+  virtual bool execute(const String& command,
+                       InputStream* in, OutputStream* out) = 0;
+ protected:
+  Firebase& fbase() {
+    return *fbase_;
+  }
+
+ private:
+  Firebase* fbase_;
+};
+
+}  // modem
+}  // firebase
+
+#endif //MODEM_COMMAND_H

src/modem/db/DatabaseProtocol.cpp

@@ -0,0 +1,61 @@
+#include "modem/db/DatabaseProtocol.h"
+
+namespace firebase {
+namespace modem {
+namespace {
+const std::vector<String> kCommands {
+  "BEGIN_DB",
+  "GET",
+  "SET",
+  "PUSH",
+  "REMOVE",
+  "BEGIN_STREAM"
+};
+}
+
+const std::vector<String>& DatabaseProtocol::commands() const {
+  return kCommands;
+}
+
+void DatabaseProtocol::Execute(const String& command_name, InputStream* in,
+                               OutputStream* out) {
+  if (command_name == "BEGIN_DB") {
+    BeginCommand command;
+    if (command.execute(command_name, in, out)) {
+      fbase_ = std::move(command.firebase());
+    }
+    return;
+  } else if (!fbase_) {
+    in->drain();
+    out->println("-FAIL Must call BEGIN_DB before anything else.");
+    return;
+  }
+
+  std::unique_ptr<Command> command = CreateCommand(command_name, fbase_.get());
+  if (!command) {
+    in->drain();
+    out->println(String("-FAIL unhandled command '") + command_name + "'." );
+    return;
+  }
+  
+  command->execute(command_name, in, out);
+}
+
+std::unique_ptr<Command> DatabaseProtocol::CreateCommand(const String& text,
+                                                         Firebase* fbase) {
+  std::unique_ptr<Command> command;
+  if (text == "GET") {
+    command.reset(new GetCommand(fbase));
+  } else if (text == "SET") {
+    command.reset(new SetCommand(fbase));
+  } else if (text == "PUSH") {
+    command.reset(new PushCommand(fbase));
+  } else if (text == "REMOVE") {
+    command.reset(new RemoveCommand(fbase));
+  } else if (text == "BEGIN_STREAM") {
+    command.reset(new StreamCommand(fbase));
+  }
+  return command;
+}
+} // modem
+} // firebase

src/modem/db/DatabaseProtocol.h

@@ -0,0 +1,26 @@
+#ifndef MDOEM_DB_DATABASE_PROTOCOL_H
+#define MODEM_DB_DATABASE_PROTOCOL_H
+
+#include "modem/SerialProtocol.h"
+#include "modem/db/commands.h"
+#include "Firebase.h"
+
+namespace firebase {
+namespace modem {
+
+class DatabaseProtocol : public SerialProtocol {
+ public:
+  const std::vector<String>& commands() const override;
+  void Execute(const String& command, InputStream* in, OutputStream* out) override;
+ private:
+  std::unique_ptr<Command> CreateCommand(const String& text, Firebase* fbase);
+
+  std::unique_ptr<Firebase> fbase_;
+};
+
+
+}  // modem
+}  // firebase
+
+
+#endif  // MODEM_DB_DATABASE_PROTOCOL_H