Crazy update to use shared_ptr and get rid of old ArduinoJson library…

… and use latest one.

src/Firebase.cpp

@@ -16,6 +16,7 @@
 #include "Firebase.h"
 
 using std::unique_ptr;
+using std::shared_ptr;
 
 namespace {
 std::string makeFirebaseURL(const std::string& path, const std::string& auth) {
@@ -42,55 +43,30 @@ const std::string& Firebase::auth() const {
 }
 
 FirebaseGet Firebase::get(const std::string& path) {
-  return FirebaseGet(host_, auth_, path, http_.get());
-}
-
-unique_ptr<FirebaseGet> Firebase::getPtr(const std::string& path) {
-  return unique_ptr<FirebaseGet>(new FirebaseGet(host_, auth_, path, http_.get()));
+  return FirebaseGet(host_, auth_, path, http_);
 }
 
 FirebaseSet Firebase::set(const std::string& path, const std::string& value) {
-  return FirebaseSet(host_, auth_, path, value, http_.get());
-}
-
-unique_ptr<FirebaseSet> Firebase::setPtr(const std::string& path,
-                                         const std::string& value) {
-  return unique_ptr<FirebaseSet>(
-      new FirebaseSet(host_, auth_, path, value, http_.get()));
+  return FirebaseSet(host_, auth_, path, value, http_);
 }
 
 FirebasePush Firebase::push(const std::string& path, const std::string& value) {
-  return FirebasePush(host_, auth_, path, value, http_.get());
-}
-unique_ptr<FirebasePush> Firebase::pushPtr(const std::string& path, const std::string& value) {
-  return unique_ptr<FirebasePush>(
-      new FirebasePush(host_, auth_, path, value, http_.get()));
+  return FirebasePush(host_, auth_, path, value, http_);
 }
 
 FirebaseRemove Firebase::remove(const std::string& path) {
-  return FirebaseRemove(host_, auth_, path, http_.get());
-}
-
-unique_ptr<FirebaseRemove> Firebase::removePtr(const std::string& path) {
-  return unique_ptr<FirebaseRemove>(
-      new FirebaseRemove(host_, auth_, path, http_.get()));
+  return FirebaseRemove(host_, auth_, path, http_);
 }
 
 FirebaseStream Firebase::stream(const std::string& path) {
   // TODO: create new client dedicated to stream.
-  return FirebaseStream(host_, auth_, path, http_.get());
-}
-
-unique_ptr<FirebaseStream> Firebase::streamPtr(const std::string& path) {
-  // TODO: create new client dedicated to stream.
-  return unique_ptr<FirebaseStream>(
-      new FirebaseStream(host_, auth_, path, http_.get()));
+  return FirebaseStream(host_, auth_, path, http_);
 }
 
 // FirebaseCall
 FirebaseCall::FirebaseCall(const std::string& host, const std::string& auth,
                            const char* method, const std::string& path,
-                           const std::string& data, FirebaseHttpClient* http) : http_(http) {
+                           const std::string& data, const std::shared_ptr<FirebaseHttpClient> http) : http_(http) {
   std::string path_with_auth = makeFirebaseURL(path, auth);
   http_->setReuseConnection(true);
   http_->begin(host, path_with_auth);
@@ -141,22 +117,24 @@ FirebaseCall::~FirebaseCall() {
 
 const JsonObject& FirebaseCall::json() {
   //TODO(edcoyne): This is not efficient, we should do something smarter with
-  //the buffers.
-  buffer_ = DynamicJsonBuffer();
-  return buffer_.parseObject(response().c_str());
+  //the buffers. kotl: Is this still valid?
+  if (buffer_.get() == NULL) {
+    buffer_.reset(new StaticJsonBuffer<FIREBASE_JSONBUFFER_SIZE>());
+  }
+  return buffer_.get()->parseObject(response().c_str());
 }
 
 // FirebaseGet
 FirebaseGet::FirebaseGet(const std::string& host, const std::string& auth,
                          const std::string& path,
-                         FirebaseHttpClient* http)
+                         const std::shared_ptr<FirebaseHttpClient> http)
   : FirebaseCall(host, auth, "GET", path, "", http) {
 }
 
 // FirebaseSet
 FirebaseSet::FirebaseSet(const std::string& host, const std::string& auth,
        const std::string& path, const std::string& value,
-       FirebaseHttpClient* http)
+       const std::shared_ptr<FirebaseHttpClient> http)
   : FirebaseCall(host, auth, "PUT", path, value, http) {
   if (!error()) {
     // TODO: parse json
@@ -167,7 +145,7 @@ FirebaseSet::FirebaseSet(const std::string& host, const std::string& auth,
 // FirebasePush
 FirebasePush::FirebasePush(const std::string& host, const std::string& auth,
                            const std::string& path, const std::string& value,
-                           FirebaseHttpClient* http)
+                           const std::shared_ptr<FirebaseHttpClient> http)
   : FirebaseCall(host, auth, "POST", path, value, http) {
   if (!error()) {
     name_ = json()["name"].as<const char*>();
@@ -177,14 +155,14 @@ FirebasePush::FirebasePush(const std::string& host, const std::string& auth,
 // FirebaseRemove
 FirebaseRemove::FirebaseRemove(const std::string& host, const std::string& auth,
                                const std::string& path,
-                               FirebaseHttpClient* http)
+                               const std::shared_ptr<FirebaseHttpClient> http)
   : FirebaseCall(host, auth, "DELETE", path, "", http) {
 }
 
 // FirebaseStream
 FirebaseStream::FirebaseStream(const std::string& host, const std::string& auth,
                                const std::string& path,
-                               FirebaseHttpClient* http)
+                               const std::shared_ptr<FirebaseHttpClient> http)
   : FirebaseCall(host, auth, "STREAM", path, "", http) {
 }
 

src/Firebase.h

@@ -22,10 +22,11 @@
 
 #include <Arduino.h>
 #include <memory>
+#include <ArduinoJson.h>
+
 #include "FirebaseHttpClient.h"
 #include "FirebaseError.h"
-#define ARDUINOJSON_USE_ARDUINO_STRING 1
-#include "third-party/arduino-json-5.6.7/include/ArduinoJson.h"
+#include "FirebaseObject.h"
 
 class FirebaseGet;
 class FirebaseSet;
@@ -42,30 +43,24 @@ class Firebase {
 
   // Fetch json encoded `value` at `path`.
   FirebaseGet get(const std::string& path);
-  virtual std::unique_ptr<FirebaseGet> getPtr(const std::string& path);
-
   // Set json encoded `value` at `path`.
   FirebaseSet set(const std::string& path, const std::string& json);
-  virtual std::unique_ptr<FirebaseSet> setPtr(const std::string& path, const std::string& json);
 
   // Add new json encoded `value` to list at `path`.
   FirebasePush push(const std::string& path, const std::string& json);
-  virtual std::unique_ptr<FirebasePush> pushPtr(const std::string& path, const std::string& json);
 
   // Delete value at `path`.
   FirebaseRemove remove(const std::string& path);
-  virtual std::unique_ptr<FirebaseRemove> removePtr(const std::string& path);
 
   // Start a stream of events that affect value at `path`.
   FirebaseStream stream(const std::string& path);
-  virtual std::unique_ptr<FirebaseStream> streamPtr(const std::string& path);
 
  protected:
   // Used for testing.
   Firebase() {}
 
  private:
-  std::unique_ptr<FirebaseHttpClient> http_;
+  std::shared_ptr<FirebaseHttpClient> http_;
   std::string host_;
   std::string auth_;
 };
@@ -76,7 +71,7 @@ class FirebaseCall {
   FirebaseCall(const std::string& host, const std::string& auth,
                const char* method, const std::string& path,
                const std::string& data = "",
-               FirebaseHttpClient* http = NULL);
+               const std::shared_ptr<FirebaseHttpClient> http = NULL);
   virtual ~FirebaseCall();
 
   virtual const FirebaseError& error() const {
@@ -90,17 +85,17 @@ class FirebaseCall {
   const JsonObject& json();
 
  protected:
-  FirebaseHttpClient* http_;
+  const std::shared_ptr<FirebaseHttpClient> http_;
   FirebaseError error_;
   std::string response_;
-  DynamicJsonBuffer buffer_;
+  std::shared_ptr<StaticJsonBuffer<FIREBASE_JSONBUFFER_SIZE>> buffer_;
 };
 
 class FirebaseGet : public FirebaseCall {
  public:
   FirebaseGet() {}
   FirebaseGet(const std::string& host, const std::string& auth,
-              const std::string& path, FirebaseHttpClient* http = NULL);
+              const std::string& path, const std::shared_ptr<FirebaseHttpClient> http = NULL);
 
  private:
   std::string json_;
@@ -110,7 +105,7 @@ class FirebaseSet: public FirebaseCall {
  public:
   FirebaseSet() {}
   FirebaseSet(const std::string& host, const std::string& auth,
-              const std::string& path, const std::string& value, FirebaseHttpClient* http = NULL);
+              const std::string& path, const std::string& value, const std::shared_ptr<FirebaseHttpClient> http = NULL);
 
 
  private:
@@ -121,7 +116,7 @@ class FirebasePush : public FirebaseCall {
  public:
   FirebasePush() {}
   FirebasePush(const std::string& host, const std::string& auth,
-               const std::string& path, const std::string& value, FirebaseHttpClient* http = NULL);
+               const std::string& path, const std::string& value, const std::shared_ptr<FirebaseHttpClient> http = NULL);
   virtual ~FirebasePush() {}
 
   virtual const std::string& name() const {
@@ -136,15 +131,15 @@ class FirebaseRemove : public FirebaseCall {
  public:
   FirebaseRemove() {}
   FirebaseRemove(const std::string& host, const std::string& auth,
-                 const std::string& path, FirebaseHttpClient* http = NULL);
+                 const std::string& path, const std::shared_ptr<FirebaseHttpClient> http = NULL);
 };
 
 
 class FirebaseStream : public FirebaseCall {
  public:
   FirebaseStream() {}
   FirebaseStream(const std::string& host, const std::string& auth,
-                 const std::string& path, FirebaseHttpClient* http = NULL);
+                 const std::string& path, const std::shared_ptr<FirebaseHttpClient> http = NULL);
   virtual ~FirebaseStream() {}
 
   // Return if there is any event available to read.

src/FirebaseArduino.cpp

@@ -46,7 +46,7 @@ String FirebaseArduino::pushString(const String& path, const String& value) {
 String FirebaseArduino::push(const String& path, const JsonVariant& value) {
   String buf;
   value.printTo(buf);
-  auto push = FirebasePush(host_, auth_, path.c_str(), buf.c_str(), http_.get());
+  auto push = FirebasePush(host_, auth_, path.c_str(), buf.c_str(), http_);
   error_ = push.error();
   return push.name().c_str();
 }
@@ -71,12 +71,12 @@ void FirebaseArduino::setString(const String& path, const String& value) {
 void FirebaseArduino::set(const String& path, const JsonVariant& value) {
   String buf;
   value.printTo(buf);
-  auto set = FirebaseSet(host_, auth_, path.c_str(), buf.c_str(), http_.get());
+  auto set = FirebaseSet(host_, auth_, path.c_str(), buf.c_str(), http_);
   error_ = set.error();
 }
 
 FirebaseObject FirebaseArduino::get(const String& path) {
-  auto get = FirebaseGet(host_, auth_, path.c_str(), http_.get());
+  auto get = FirebaseGet(host_, auth_, path.c_str(), http_);
   error_ = get.error();
   if (failed()) {
     return FirebaseObject{""};
@@ -85,7 +85,7 @@ FirebaseObject FirebaseArduino::get(const String& path) {
 }
 
 int FirebaseArduino::getInt(const String& path) {
-  auto get = FirebaseGet(host_, auth_, path.c_str(), http_.get());
+  auto get = FirebaseGet(host_, auth_, path.c_str(), http_);
   error_ = get.error();
   if (failed()) {
     return 0;
@@ -95,7 +95,7 @@ int FirebaseArduino::getInt(const String& path) {
 
 
 float FirebaseArduino::getFloat(const String& path) {
-  auto get = FirebaseGet(host_, auth_, path.c_str(), http_.get());
+  auto get = FirebaseGet(host_, auth_, path.c_str(), http_);
   error_ = get.error();
   if (failed()) {
     return 0.0f;
@@ -104,7 +104,7 @@ float FirebaseArduino::getFloat(const String& path) {
 }
 
 String FirebaseArduino::getString(const String& path) {
-  auto get = FirebaseGet(host_, auth_, path.c_str(), http_.get());
+  auto get = FirebaseGet(host_, auth_, path.c_str(), http_);
   error_ = get.error();
   if (failed()) {
     return "";
@@ -113,20 +113,20 @@ String FirebaseArduino::getString(const String& path) {
 }
 
 bool FirebaseArduino::getBool(const String& path) {
-  auto get = FirebaseGet(host_, auth_, path.c_str(), http_.get());
+  auto get = FirebaseGet(host_, auth_, path.c_str(), http_);
   error_ = get.error();
   if (failed()) {
     return "";
   }
   return FirebaseObject(get.response().c_str()).getBool();
 }
 void FirebaseArduino::remove(const String& path) {
-  auto remove = FirebaseRemove(host_, auth_, path.c_str(), http_.get());
+  auto remove = FirebaseRemove(host_, auth_, path.c_str(), http_);
   error_ = remove.error();
 }
 
 void FirebaseArduino::stream(const String& path) {
-  auto stream = FirebaseStream(host_, auth_, path.c_str(), http_.get());
+  auto stream = FirebaseStream(host_, auth_, path.c_str(), http_);
   error_ = stream.error();
 }
 

src/FirebaseArduino.h

@@ -229,7 +229,7 @@ class FirebaseArduino {
   std::string host_;
   std::string auth_;
   FirebaseError error_;
-  std::unique_ptr<FirebaseHttpClient> http_;
+  std::shared_ptr<FirebaseHttpClient> http_;
 };
 
 extern FirebaseArduino Firebase;

src/FirebaseCloudMessaging.cpp

@@ -63,7 +63,7 @@ const FirebaseError FirebaseCloudMessaging::SendMessageToTopic(
 
 const FirebaseError FirebaseCloudMessaging::SendPayload(
     const char* payload) {
-  std::unique_ptr<FirebaseHttpClient> client(FirebaseHttpClient::create());
+  std::shared_ptr<FirebaseHttpClient> client(FirebaseHttpClient::create());
   client->begin("http://fcm.googleapis.com/fcm/send");
   client->addHeader("Authorization", auth_header_.c_str());
   client->addHeader("Content-Type", "application/json");

src/FirebaseCloudMessaging.h

@@ -26,8 +26,7 @@
 #include <vector>
 #include "FirebaseHttpClient.h"
 #include "FirebaseError.h"
-#define ARDUINOJSON_USE_ARDUINO_STRING 1
-#include "third-party/arduino-json-5.6.7/include/ArduinoJson.h"
+#include <ArduinoJson.h>
 
 // Defines the actual message to the client, for more detail on
 // options and settings see:

src/FirebaseObject.cpp

@@ -19,7 +19,8 @@
 // We need to make a copy of data here, even though it may be large.
 // It will need to be long lived.
 FirebaseObject::FirebaseObject(const char* data) : data_{data} {
-  json_ = buffer_.parse(&data_[0]);
+  buffer_.reset(new StaticJsonBuffer<FIREBASE_JSONBUFFER_SIZE>);
+  json_ = buffer_.get()->parse(&data_[0]);
   // TODO(proppy): find a way to check decoding error, tricky because
   // ArduinoJson doesn't surface error for variant parsing.
   // See: https://github.com/bblanchon/ArduinoJson/issues/279
@@ -83,7 +84,7 @@ JsonVariant FirebaseObject::getJsonVariant(const String& path) const {
     // make `start` a C string.
     *p = 0;
     // return json variant at `start`.
-    json = json.asObject().get(start);
+    json = json.asObject().get<JsonVariant>(start);
     // advance to next path element.
     start = p + 1;
   }