Added timeline polling

Because the streaming API will sunset on August 16th, it is essential to implement timeline polling so that the library can still be used to access tweets. This commit breaks the current API even for clients still using the streaming API because the OAuth connection data was pulled from twitter::client into twitter::auth. Other than that, almost everything works the same, and if a client wants to update their libtwitter++ within the next week and a half, they are free to.

16 files changed, 934 insertions, 822 deletions

@@ -10,7 +10,19 @@ include_directories(vendor/liboauthcpp/include)
 add_subdirectory(vendor/curlcpp)
 include_directories(${CURLCPP_SOURCE_DIR}/include)
 
-add_library(twitter++ src/client.cpp src/stream.cpp src/auth.cpp src/tweet.cpp src/codes.cpp src/notification.cpp src/direct_message.cpp src/list.cpp src/user.cpp src/configuration.cpp)
-set_property(TARGET twitter++ PROPERTY CXX_STANDARD 11)
+add_library(twitter++
+  src/client.cpp
+  src/request.cpp
+  src/timeline.cpp
+  src/stream.cpp
+  src/tweet.cpp
+  src/codes.cpp
+  src/notification.cpp
+  src/direct_message.cpp
+  src/list.cpp
+  src/user.cpp
+  src/configuration.cpp)
+
+set_property(TARGET twitter++ PROPERTY CXX_STANDARD 14)
 set_property(TARGET twitter++ PROPERTY CXX_STANDARD_REQUIRED ON)
 target_link_libraries(twitter++ oauthcpp curlcpp curl pthread)
@@ -1,45 +0,0 @@
-#include "auth.h"
-
-namespace twitter {
-  
-  void auth::setConsumerKey(std::string _arg)
-  {
-    _consumer_key = _arg;
-  }
-  
-  void auth::setConsumerSecret(std::string _arg)
-  {
-    _consumer_secret = _arg;
-  }
-  
-  void auth::setAccessKey(std::string _arg)
-  {
-    _access_key = _arg;
-  }
-  
-  void auth::setAccessSecret(std::string _arg)
-  {
-    _access_secret = _arg;
-  }
-  
-  std::string auth::getConsumerKey() const
-  {
-    return _consumer_key;
-  }
-  
-  std::string auth::getConsumerSecret() const
-  {
-    return _consumer_secret;
-  }
-  
-  std::string auth::getAccessKey() const
-  {
-    return _access_key;
-  }
-  
-  std::string auth::getAccessSecret() const
-  {
-    return _access_secret;
-  }
-    
-};
@@ -2,28 +2,36 @@
 #define AUTH_H_48EF85FD
 
 #include <string>
+#include "../vendor/liboauthcpp/include/liboauthcpp/liboauthcpp.h"
 
 namespace twitter {
-  
+
   class auth {
-    public:
-      void setConsumerKey(std::string _arg);
-      void setConsumerSecret(std::string _arg);
-      void setAccessKey(std::string _arg);
-      void setAccessSecret(std::string _arg);
-      
-      std::string getConsumerKey() const;
-      std::string getConsumerSecret() const;
-      std::string getAccessKey() const;
-      std::string getAccessSecret() const;
-      
-    private:
-      std::string _consumer_key;
-      std::string _consumer_secret;
-      std::string _access_key;
-      std::string _access_secret;
+  public:
+
+    auth(
+      std::string consumerKey,
+      std::string consumerSecret,
+      std::string accessKey,
+      std::string accessSecret) :
+        consumer_(std::move(consumerKey), std::move(consumerSecret)),
+        token_(std::move(accessKey), std::move(accessSecret)),
+        client_(&consumer_, &token_)
+    {
+    }
+
+    const OAuth::Client& getClient() const
+    {
+      return client_;
+    }
+
+  private:
+
+    OAuth::Consumer consumer_;
+    OAuth::Token token_;
+    OAuth::Client client_;
   };
-  
+
 };
 
 #endif /* end of include guard: AUTH_H_48EF85FD */
@@ -2,385 +2,65 @@
 #include <sstream>
 #include <set>
 #include <algorithm>
-#include <liboauthcpp/liboauthcpp.h>
-#include <curl_easy.h>
-#include <curl_header.h>
 #include <json.hpp>
 #include <thread>
-
-// These are here for debugging curl stuff
-
-static
-void dump(const char *text,
-          FILE *stream, unsigned char *ptr, size_t size)
-{
-  size_t i;
-  size_t c;
-  unsigned int width=80;
- 
-  fprintf(stream, "%s, %10.10ld bytes (0x%8.8lx)\n",
-          text, (long)size, (long)size);
- 
-  for(i=0; i<size; i+= width) {
-    fprintf(stream, "%4.4lx: ", (long)i);
- 
-    /* show hex to the left
-    for(c = 0; c < width; c++) {
-      if(i+c < size)
-        fprintf(stream, "%02x ", ptr[i+c]);
-      else
-        fputs("   ", stream);
-    }*/
- 
-    /* show data on the right */
-    for(c = 0; (c < width) && (i+c < size); c++) {
-      char x = (ptr[i+c] >= 0x20 && ptr[i+c] < 0x80) ? ptr[i+c] : '.';
-      fputc(x, stream);
-    }
- 
-    fputc('\n', stream); /* newline */
-  }
-}
- 
-static
-int my_trace(CURL *handle, curl_infotype type,
-             char *data, size_t size,
-             void *userp)
-{
-  const char *text;
-  (void)handle; /* prevent compiler warning */
- 
-  switch (type) {
-  case CURLINFO_TEXT:
-    fprintf(stderr, "== Info: %s", data);
-  default: /* in case a new one is introduced to shock us */
-    return 0;
- 
-  case CURLINFO_HEADER_OUT:
-    text = "=> Send header";
-    break;
-  case CURLINFO_DATA_OUT:
-    text = "=> Send data";
-    break;
-  case CURLINFO_SSL_DATA_OUT:
-    text = "=> Send SSL data";
-    break;
-  case CURLINFO_HEADER_IN:
-    text = "<= Recv header";
-    break;
-  case CURLINFO_DATA_IN:
-    text = "<= Recv data";
-    break;
-  case CURLINFO_SSL_DATA_IN:
-    text = "<= Recv SSL data";
-    break;
-  }
- 
-  dump(text, stderr, (unsigned char *)data, size);
-  return 0;
-}
+#include "request.h"
 
 namespace twitter {
-  
-  class request
-  {
-  public:
-    
-    explicit request(std::string url) try
-      : _ios(_output), _conn(_ios)
-    {
-      _conn.add<CURLOPT_URL>(url.c_str());
-    } catch (const curl::curl_easy_exception& error)
-    {
-      error.print_traceback();
-    
-      assert(false);
-    }
-    
-    std::string perform()
-    {
-      try
-      {
-        _conn.perform();
-      } catch (const curl::curl_easy_exception& error)
-      {
-        std::throw_with_nested(connection_error());
-      }
-    
-      int response_code = _conn.get_info<CURLINFO_RESPONSE_CODE>().get();
-      std::string result = _output.str();
-    
-      if (response_code / 100 != 2)
-      {
-        nlohmann::json response_json;
-      
-        try
-        {
-          response_json = nlohmann::json::parse(result);
-        } catch (const std::invalid_argument& e)
-        {
-          std::throw_with_nested(invalid_response(result));
-        }
-    
-        for (nlohmann::json& error : response_json["errors"])
-        {
-          int error_code;
-          std::string error_message;
-      
-          try
-          {
-            error_code = error["code"].get<int>();
-            error_message = error["message"].get<std::string>();
-          } catch (const std::domain_error& e)
-          {
-            std::throw_with_nested(invalid_response(result));
-          }
-      
-          switch (error_code)
-          {
-          case 32:
-          case 135:
-          case 215:
-            throw bad_auth(error_message);
-        
-          case 44:
-            throw invalid_media(error_message);
-        
-          case 64:
-            throw account_suspended(error_message);
-        
-          case 88:
-            throw rate_limit_exceeded(error_message);
-        
-          case 89:
-            throw bad_token(error_message);
-        
-          case 130:
-            throw server_overloaded(error_message);
-        
-          case 131:
-            throw server_error(error_message);
-      
-          case 185:
-            throw update_limit_exceeded(error_message);
-        
-          case 186:
-            throw bad_length(error_message);
-        
-          case 187:
-            throw duplicate_status(error_message);
-        
-          case 226:
-            throw suspected_spam(error_message);
-        
-          case 261:
-            throw write_restricted(error_message);
-          }
-        }
 
-        if (response_code == 429)
-        {
-          throw rate_limit_exceeded("HTTP 429 Too Many Requests");
-        } else if (response_code == 500)
-        {
-          throw server_error("HTTP 500 Internal Server Error");
-        } else if (response_code == 502)
-        {
-          throw server_unavailable("HTTP 502 Bad Gateway");
-        } else if (response_code == 503)
-        {
-          throw server_overloaded("HTTP 503 Service Unavailable");
-        } else if (response_code == 504)
-        {
-          throw server_timeout("HTTP 504 Gateway Timeout");
-        }
-      
-        throw unknown_error(response_code, result);
-      }
-    
-      return result;
-    }
-    
-  private:
-    
-    std::ostringstream _output;
-    curl::curl_ios<std::ostringstream> _ios;
-    
-  protected:
-    
-    curl::curl_easy _conn;
-  };
-  
-  class get : public request
-  {
-  public:
-    
-    get(const OAuth::Client& oauth_client, std::string url) try
-      : request(url)
-    {
-      std::string oauth_header = oauth_client.getFormattedHttpHeader(OAuth::Http::Get, url, "");
-      if (!oauth_header.empty())
-      {
-        _headers.add(std::move(oauth_header));
-      }
-  
-      _conn.add<CURLOPT_HTTPHEADER>(_headers.get());
-    } catch (const OAuth::ParseError& error)
-    {
-      std::cout << "Error generating OAuth header:" << std::endl;
-      std::cout << error.what() << std::endl;
-      std::cout << "This is likely due to a malformed URL." << std::endl;
-    
-      assert(false);
-    } catch (const curl::curl_easy_exception& error)
-    {
-      error.print_traceback();
-  
-      assert(false);
-    }
-    
-  private:
-    
-    curl::curl_header _headers;
-  };
-  
-  class post : public request
-  {
-  public:
-    
-    post(const OAuth::Client& oauth_client, std::string url, std::string datastr) try
-      : request(url)
-    {
-      std::string oauth_header = oauth_client.getFormattedHttpHeader(OAuth::Http::Post, url, datastr);
-      if (!oauth_header.empty())
-      {
-        _headers.add(std::move(oauth_header));
-      }
-  
-      _conn.add<CURLOPT_HTTPHEADER>(_headers.get());
-      _conn.add<CURLOPT_COPYPOSTFIELDS>(datastr.c_str());
-    } catch (const OAuth::ParseError& error)
-    {
-      std::cout << "Error generating OAuth header:" << std::endl;
-      std::cout << error.what() << std::endl;
-      std::cout << "This is likely due to a malformed URL." << std::endl;
-    
-      assert(false);
-    } catch (const curl::curl_easy_exception& error)
-    {
-      error.print_traceback();
-  
-      assert(false);
-    }
-    
-  private:
-    
-    curl::curl_header _headers;
-  };
-  
-  class multipost : public request
-  {
-  public:
-    
-    multipost(const OAuth::Client& oauth_client, std::string url, const curl_httppost* fields) try
-      : request(url)
-    {
-      std::string oauth_header = oauth_client.getFormattedHttpHeader(OAuth::Http::Post, url, "");
-      if (!oauth_header.empty())
-      {
-        _headers.add(std::move(oauth_header));
-      }
-  
-      _conn.add<CURLOPT_HTTPHEADER>(_headers.get());
-      _conn.add<CURLOPT_HTTPPOST>(fields);
-    } catch (const OAuth::ParseError& error)
-    {
-      std::cout << "Error generating OAuth header:" << std::endl;
-      std::cout << error.what() << std::endl;
-      std::cout << "This is likely due to a malformed URL." << std::endl;
-    
-      assert(false);
-    } catch (const curl::curl_easy_exception& error)
-    {
-      error.print_traceback();
-  
-      assert(false);
-    }
-    
-  private:
-    
-    curl::curl_header _headers;
-  };
-    
-  client::client(const auth& _arg)
-  {
-    _oauth_consumer =
-      make_unique<OAuth::Consumer>(
-        _arg.getConsumerKey(),
-        _arg.getConsumerSecret());
-          
-    _oauth_token =
-      make_unique<OAuth::Token>(
-        _arg.getAccessKey(),
-        _arg.getAccessSecret());
-          
-    _oauth_client =
-      make_unique<OAuth::Client>(
-        _oauth_consumer.get(),
-        _oauth_token.get());
-    
-    _current_user =
-      make_unique<user>(
-        get(*_oauth_client,
+  client::client(
+    const auth& _arg) :
+      auth_(_arg),
+      currentUser_(
+        get(auth_,
           "https://api.twitter.com/1.1/account/verify_credentials.json")
-        .perform());
+            .perform())
+  {
   }
-  
-  client::~client() = default;
-  
+
   tweet client::updateStatus(std::string msg, std::list<long> media_ids) const
   {
     std::stringstream datastrstream;
     datastrstream << "status=" << OAuth::PercentEncode(msg);
-    
+
     if (!media_ids.empty())
     {
       datastrstream << "&media_ids=";
       datastrstream << twitter::implode(std::begin(media_ids), std::end(media_ids), ",");
     }
-    
+
     return tweet(
-      post(*_oauth_client,
+      post(auth_,
         "https://api.twitter.com/1.1/statuses/update.json",
         datastrstream.str())
       .perform());
   }
-  
+
   tweet client::replyToTweet(std::string msg, tweet_id in_response_to, std::list<long> media_ids) const
   {
     std::stringstream datastrstream;
     datastrstream << "status=" << OAuth::PercentEncode(msg);
     datastrstream << "&in_reply_to_status_id=";
     datastrstream << in_response_to;
-    
+
     if (!media_ids.empty())
     {
       datastrstream << "&media_ids=";
       datastrstream << twitter::implode(std::begin(media_ids), std::end(media_ids), ",");
     }
-    
+
     return tweet(
-      post(*_oauth_client,
+      post(auth_,
         "https://api.twitter.com/1.1/statuses/update.json",
         datastrstream.str())
       .perform());
   }
-  
+
   long client::uploadMedia(std::string media_type, const char* data, long data_length) const try
   {
     curl::curl_form form;
     std::string str_data_length = std::to_string(data_length);
-    
+
     curl::curl_pair<CURLformoption, std::string> command_name(CURLFORM_COPYNAME, "command");
     curl::curl_pair<CURLformoption, std::string> command_cont(CURLFORM_COPYCONTENTS, "INIT");
     curl::curl_pair<CURLformoption, std::string> bytes_name(CURLFORM_COPYNAME, "total_bytes");
@@ -397,15 +77,15 @@ namespace twitter {
       curl::curl_pair<CURLformoption, std::string> category_cont(CURLFORM_COPYCONTENTS, "tweet_gif");
       form.add(category_name, category_cont);
     }
-    
+
     std::string init_response =
-      multipost(*_oauth_client,
+      multipost(auth_,
         "https://upload.twitter.com/1.1/media/upload.json",
         form.get())
       .perform();
 
     long media_id;
-    
+
     try
     {
       nlohmann::json response_json = nlohmann::json::parse(init_response);
@@ -429,29 +109,29 @@ namespace twitter {
     {
       assert(false);
     }
-    
-    multipost(*_oauth_client, "https://upload.twitter.com/1.1/media/upload.json", append_form_post).perform();
-    
+
+    multipost(auth_, "https://upload.twitter.com/1.1/media/upload.json", append_form_post).perform();
+
     curl_formfree(append_form_post);
-    
+
     curl::curl_form finalize_form;
     std::string str_media_id = std::to_string(media_id);
-    
+
     curl::curl_pair<CURLformoption, std::string> command3_name(CURLFORM_COPYNAME, "command");
     curl::curl_pair<CURLformoption, std::string> command3_cont(CURLFORM_COPYCONTENTS, "FINALIZE");
     curl::curl_pair<CURLformoption, std::string> media_id_name(CURLFORM_COPYNAME, "media_id");
     curl::curl_pair<CURLformoption, std::string> media_id_cont(CURLFORM_COPYCONTENTS, str_media_id);
     finalize_form.add(command3_name, command3_cont);
     finalize_form.add(media_id_name, media_id_cont);
-    
+
     std::string finalize_response =
-      multipost(*_oauth_client,
+      multipost(auth_,
         "https://upload.twitter.com/1.1/media/upload.json",
         finalize_form.get())
       .perform();
 
     nlohmann::json finalize_json;
-    
+
     try
     {
       finalize_json = nlohmann::json::parse(finalize_response);
@@ -459,26 +139,26 @@ namespace twitter {
     {
       std::throw_with_nested(invalid_response(finalize_response));
     }
-    
+
     if (finalize_json.find("processing_info") != finalize_json.end())
     {
       std::stringstream datastr;
       datastr << "https://upload.twitter.com/1.1/media/upload.json?command=STATUS&media_id=" << media_id;
-      
+
       for (;;)
       {
-        std::string status_response = get(*_oauth_client, datastr.str()).perform();
-        
+        std::string status_response = get(auth_, datastr.str()).perform();
+
         try
         {
           nlohmann::json status_json = nlohmann::json::parse(status_response);
           std::string state = status_json["processing_info"]["state"].get<std::string>();
-          
+
           if (state == "succeeded")
           {
             break;
           }
-          
+
           int ttw = status_json["processing_info"]["check_after_secs"].get<int>();
           std::this_thread::sleep_for(std::chrono::seconds(ttw));
         } catch (const std::invalid_argument& error)
@@ -490,20 +170,18 @@ namespace twitter {
         }
       }
     }
-    
+
     return media_id;
   } catch (const curl::curl_exception& error)
   {
-    error.print_traceback();
-    
-    assert(false);
+    std::throw_with_nested(connection_error());
   }
-  
+
   std::set<user_id> client::getFriends(user_id id) const
   {
     long long cursor = -1;
     std::set<user_id> result;
-    
+
     while (cursor != 0)
     {
       std::stringstream urlstream;
@@ -511,14 +189,14 @@ namespace twitter {
       urlstream << id;
       urlstream << "&cursor=";
       urlstream << cursor;
-  
+
       std::string url = urlstream.str();
-      std::string response_data = get(*_oauth_client, url).perform();
-      
+      std::string response_data = get(auth_, url).perform();
+
       try
       {
         nlohmann::json rjs = nlohmann::json::parse(response_data);
-        
+
         cursor = rjs["next_cursor"].get<long long>();
         result.insert(std::begin(rjs["ids"]), std::end(rjs["ids"]));
       } catch (const std::invalid_argument& error)
@@ -529,25 +207,25 @@ namespace twitter {
         std::throw_with_nested(invalid_response(response_data));
       }
     }
-    
+
     return result;
   }
-  
+
   std::set<user_id> client::getFriends(const user& id) const
   {
     return getFriends(id.getID());
   }
-  
+
   std::set<user_id> client::getFriends() const
   {
     return getFriends(getUser().getID());
   }
-  
+
   std::set<user_id> client::getFollowers(user_id id) const
   {
     long long cursor = -1;
     std::set<user_id> result;
-    
+
     while (cursor != 0)
     {
       std::stringstream urlstream;
@@ -555,14 +233,14 @@ namespace twitter {
       urlstream << id;
       urlstream << "&cursor=";
       urlstream << cursor;
-  
+
       std::string url = urlstream.str();
-      std::string response_data = get(*_oauth_client, url).perform();
-      
+      std::string response_data = get(auth_, url).perform();
+
       try
       {
         nlohmann::json rjs = nlohmann::json::parse(response_data);
-        
+
         cursor = rjs["next_cursor"].get<long long>();
         result.insert(std::begin(rjs["ids"]), std::end(rjs["ids"]));
       } catch (const std::invalid_argument& error)
@@ -573,43 +251,43 @@ namespace twitter {
         std::throw_with_nested(invalid_response(response_data));
       }
     }
-    
+
     return result;
   }
-  
+
   std::set<user_id> client::getFollowers(const user& id) const
   {
     return getFollowers(id.getID());
   }
-  
+
   std::set<user_id> client::getFollowers() const
   {
     return getFollowers(getUser().getID());
   }
-  
+
   void client::follow(user_id toFollow) const
   {
     std::stringstream datastrstream;
     datastrstream << "follow=true&user_id=";
     datastrstream << toFollow;
-    
-    post(*_oauth_client, "https://api.twitter.com/1.1/friendships/create.json", datastrstream.str()).perform();
+
+    post(auth_, "https://api.twitter.com/1.1/friendships/create.json", datastrstream.str()).perform();
   }
-  
+
   void client::follow(const user& toFollow) const
   {
     return follow(toFollow.getID());
   }
-  
+
   void client::unfollow(user_id toUnfollow) const
   {
     std::stringstream datastrstream;
     datastrstream << "user_id=";
     datastrstream << toUnfollow;
-    
-    post(*_oauth_client, "https://api.twitter.com/1.1/friendships/destroy.json", datastrstream.str()).perform();
+
+    post(auth_, "https://api.twitter.com/1.1/friendships/destroy.json", datastrstream.str()).perform();
   }
-  
+
   void client::unfollow(const user& toUnfollow) const
   {
     return unfollow(toUnfollow.getID());
@@ -617,23 +295,23 @@ namespace twitter {
 
   const user& client::getUser() const
   {
-    return *_current_user;
+    return currentUser_;
   }
-  
+
   const configuration& client::getConfiguration() const
   {
     if (!_configuration || (difftime(time(NULL), _last_configuration_update) > 60*60*24))
     {
       _configuration =
-        make_unique<configuration>(
-          get(*_oauth_client,
+        std::make_unique<configuration>(
+          get(auth_,
             "https://api.twitter.com/1.1/help/configuration.json")
           .perform());
 
       _last_configuration_update = time(NULL);
     }
-    
+
     return *_configuration;
   }
-  
+
 };
@@ -10,58 +10,66 @@
 #include "auth.h"
 #include "configuration.h"
 #include "util.h"
-
-namespace OAuth {
-  class Consumer;
-  class Token;
-  class Client;
-};
+#include "timeline.h"
 
 namespace twitter {
-  
+
   class client {
   public:
-    
-    client(const auth& _auth);
-    ~client();
-    
+
+    client(const auth& arg);
+
     tweet updateStatus(std::string msg, std::list<long> media_ids = {}) const;
     long uploadMedia(std::string media_type, const char* data, long data_length) const;
-    
+
     tweet replyToTweet(std::string msg, tweet_id in_response_to, std::list<long> media_ids = {}) const;
-    
+
     std::set<user_id> getFriends(user_id id) const;
     std::set<user_id> getFriends(const user& u) const;
     std::set<user_id> getFriends() const;
-    
+
     std::set<user_id> getFollowers(user_id id) const;
     std::set<user_id> getFollowers(const user& u) const;
     std::set<user_id> getFollowers() const;
-    
+
     void follow(user_id toFollow) const;
     void follow(const user& toFollow) const;
-    
+
     void unfollow(user_id toUnfollow) const;
     void unfollow(const user& toUnfollow) const;
-    
+
     const user& getUser() const;
-    
+
     const configuration& getConfiguration() const;
-    
+
+    timeline& getHomeTimeline()
+    {
+      return homeTimeline_;
+    }
+
+    timeline& getMentionsTimeline()
+    {
+      return mentionsTimeline_;
+    }
+
   private:
-    
-    friend class stream;
-    
-    std::unique_ptr<OAuth::Consumer> _oauth_consumer;
-    std::unique_ptr<OAuth::Token> _oauth_token;
-    std::unique_ptr<OAuth::Client> _oauth_client;
-    
-    std::unique_ptr<user> _current_user;
-    
+
+    const auth& auth_;
+
+    user currentUser_;
+
     mutable std::unique_ptr<configuration> _configuration;
     mutable time_t _last_configuration_update;
+
+    timeline homeTimeline_ {
+      auth_,
+      "https://api.twitter.com/1.1/statuses/home_timeline.json"};
+
+    timeline mentionsTimeline_ {
+      auth_,
+      "https://api.twitter.com/1.1/statuses/mentions_timeline.json"};
   };
-  
+
 };
 
 #endif /* end of include guard: TWITTER_H_ABFF6A12 */
@@ -6,18 +6,16 @@
 #include "client.h"
 
 namespace twitter {
-  
+
   notification::type notification::getType() const
   {
     return _type;
   }
-  
-  notification::notification(const client& tclient, std::string data)
+
+  notification::notification(const user& current_user, std::string data)
   {
-    const user& current_user = tclient.getUser();
-    
     nlohmann::json json;
-    
+
     try
     {
       json = nlohmann::json::parse(data);
@@ -25,7 +23,7 @@ namespace twitter {
     {
       std::throw_with_nested(invalid_response(data));
     }
-    
+
     try
     {
       if (!json["event"].is_null())
@@ -33,48 +31,48 @@ namespace twitter {
         std::string event = json["event"];
         user source(json["source"].dump());
         user target(json["target"].dump());
-      
+
         if (event == "user_update")
         {
           _type = type::update_user;
-        
+
           new(&_user) user(source);
         } else if (event == "block")
         {
           _type = type::block;
-        
+
           new(&_user) user(target);
         } else if (event == "unblock")
         {
           _type = type::unblock;
-        
+
           new(&_user) user(target);
         } else if (event == "favorite")
         {
           new(&_user_and_tweet._tweet) tweet(json["target_object"].dump());
-        
+
           if (current_user == source)
           {
             _type = type::favorite;
-          
+
             new(&_user_and_tweet._user) user(target);
           } else {
             _type = type::favorited;
-          
+
             new(&_user_and_tweet._user) user(source);
           }
         } else if (event == "unfavorite")
         {
           new(&_user_and_tweet._tweet) tweet(json["target_object"].dump());
-        
+
           if (current_user == source)
           {
             _type = type::unfavorite;
-          
+
             new(&_user_and_tweet._user) user(target);
           } else {
             _type = type::unfavorited;
-          
+
             new(&_user_and_tweet._user) user(source);
           }
         } else if (event == "follow")
@@ -82,93 +80,93 @@ namespace twitter {
           if (current_user == source)
           {
             _type = type::follow;
-          
+
             new(&_user) user(target);
           } else {
             _type = type::followed;
-          
+
             new(&_user) user(source);
           }
         } else if (event == "unfollow")
         {
           _type = type::unfollow;
-        
+
           new(&_user) user(target);
         } else if (event == "list_created")
         {
           _type = type::list_created;
-        
+
           new(&_list) list(json["target_object"].dump());
         } else if (event == "list_destroyed")
         {
           _type = type::list_destroyed;
-        
+
           new(&_list) list(json["target_object"].dump());
         } else if (event == "list_updated")
         {
           _type = type::list_updated;
-        
+
           new(&_list) list(json["target_object"].dump());
         } else if (event == "list_member_added")
         {
           new(&_user_and_list._list) list(json["target_object"].dump());
-        
+
           if (current_user == source)
           {
             _type = type::list_add;
-          
+
             new(&_user_and_list._user) user(target);
           } else {
             _type = type::list_added;
-          
+
             new(&_user_and_list._user) user(source);
           }
         } else if (event == "list_member_removed")
         {
           new(&_user_and_list._list) list(json["target_object"].dump());
-        
+
           if (current_user == source)
           {
             _type = type::list_remove;
-          
+
             new(&_user_and_list._user) user(target);
           } else {
             _type = type::list_removed;
-          
+
             new(&_user_and_list._user) user(source);
           }
         } else if (event == "list_member_subscribe")
         {
           new(&_user_and_list._list) list(json["target_object"].dump());
-        
+
           if (current_user == source)
           {
             _type = type::list_subscribe;
-          
+
             new(&_user_and_list._user) user(target);
           } else {
             _type = type::list_subscribed;
-          
+
             new(&_user_and_list._user) user(source);
           }
         } else if (event == "list_member_unsubscribe")
         {
           new(&_user_and_list._list) list(json["target_object"].dump());
-        
+
           if (current_user == source)
           {
             _type = type::list_unsubscribe;
-          
+
             new(&_user_and_list._user) user(target);
           } else {
             _type = type::list_unsubscribed;
-          
+
             new(&_user_and_list._user) user(source);
           }
         } else if (event == "quoted_tweet")
         {
           _type = type::quoted;
-        
+
           new(&_user_and_tweet._user) user(source);
           new(&_user_and_tweet._tweet) tweet(json["target_object"].dump());
         } else {
@@ -177,7 +175,7 @@ namespace twitter {
       } else if (!json["warning"].is_null())
       {
         new(&_warning) std::string(json["warning"]["message"].get<std::string>());
-      
+
         auto warning_code = json["warning"]["code"].get<std::string>();
         if (warning_code == "FALLING_BEHIND")
         {
@@ -191,27 +189,27 @@ namespace twitter {
       } else if (!json["delete"].is_null())
       {
         _type = type::deletion;
-      
+
         _user_id_and_tweet_id._tweet_id = json["delete"]["status"]["id"].get<tweet_id>();
         _user_id_and_tweet_id._user_id = json["delete"]["status"]["user_id"].get<user_id>();
       } else if (!json["scrub_geo"].is_null())
       {
         _type = type::scrub_location;
-      
+
         _user_id_and_tweet_id._tweet_id = json["scrub_geo"]["up_to_status_id"].get<tweet_id>();
         _user_id_and_tweet_id._user_id = json["scrub_geo"]["user_id"].get<user_id>();
       } else if (!json["limit"].is_null())
       {
         _type = type::limit;
-      
+
         _limit = json["limit"]["track"].get<int>();
       } else if (!json["status_withheld"].is_null())
       {
         _type = type::withhold_status;
-      
+
         _withhold_status._user_id = json["status_withheld"]["user_id"].get<user_id>();
         _withhold_status._tweet_id = json["status_withheld"]["id"].get<tweet_id>();
-      
+
         new(&_withhold_status._countries) std::vector<std::string>();
         for (auto s : json["status_withheld"]["withheld_in_countries"])
         {
@@ -220,9 +218,9 @@ namespace twitter {
       } else if (!json["user_withheld"].is_null())
       {
         _type = type::withhold_user;
-      
+
         _withhold_user._user_id = json["user_withheld"]["id"].get<user_id>();
-      
+
         new(&_withhold_user._countries) std::vector<std::string>();
         for (auto s : json["user_withheld"]["withheld_in_countries"])
         {
@@ -231,7 +229,7 @@ namespace twitter {
       } else if (!json["disconnect"].is_null())
       {
         _type = type::disconnect;
-      
+
         switch (json["disconnect"]["code"].get<int>())
         {
           case 1: _disconnect = disconnect_code::shutdown; break;
@@ -249,16 +247,16 @@ namespace twitter {
       } else if (!json["friends"].is_null())
       {
         _type = type::friends;
-      
+
         new(&_friends) std::set<user_id>(std::begin(json["friends"]), std::end(json["friends"]));
       } else if (!json["direct_message"].is_null())
       {
         _type = type::direct;
-      
+
         new(&_direct_message) direct_message(json["direct_message"].dump());
       } else {
         _type = type::tweet;
-      
+
         new(&_tweet) tweet(data);
       }
     } catch (const std::domain_error& error)
@@ -266,20 +264,20 @@ namespace twitter {
       std::throw_with_nested(invalid_response(data));
     }
   }
-  
+
   notification::notification(const notification& other)
   {
     _type = other._type;
-    
+
     switch (_type)
     {
       case type::tweet:
       {
         new(&_tweet) tweet(other._tweet);
-      
+
         break;
       }
-    
+
       case type::update_user:
       case type::block:
       case type::unblock:
@@ -288,10 +286,10 @@ namespace twitter {
       case type::unfollow:
       {
         new(&_user) user(other._user);
-      
+
         break;
       }
-    
+
       case type::favorite:
       case type::favorited:
       case type::unfavorite:
@@ -300,19 +298,19 @@ namespace twitter {
       {
         new(&_user_and_tweet._user) user(other._user_and_tweet._user);
         new(&_user_and_tweet._tweet) tweet(other._user_and_tweet._tweet);
-      
+
         break;
       }
-    
+
       case type::list_created:
       case type::list_destroyed:
       case type::list_updated:
       {
         new(&_list) list(other._list);
-      
+
         break;
       }
-    
+
       case type::list_add:
       case type::list_added:
       case type::list_remove:
@@ -324,73 +322,73 @@ namespace twitter {
       {
         new(&_user_and_list._user) user(other._user_and_list._user);
         new(&_user_and_list._list) list(other._user_and_list._list);
-      
+
         break;
       }
-    
+
       case type::stall:
       case type::follow_limit:
       case type::unknown_warning:
       {
         new(&_warning) std::string(other._warning);
-      
+
         break;
       }
-    
+
       case type::deletion:
       case type::scrub_location:
       {
         _user_id_and_tweet_id._user_id = other._user_id_and_tweet_id._user_id;
         _user_id_and_tweet_id._tweet_id = other._user_id_and_tweet_id._tweet_id;
-      
+
         break;
       }
-    
+
       case type::limit:
       {
         _limit = other._limit;
-      
+
         break;
       }
-    
+
       case type::withhold_status:
       {
         _withhold_status._user_id = other._withhold_status._user_id;
         _withhold_status._tweet_id = other._withhold_status._tweet_id;
         new(&_withhold_status._countries) std::vector<std::string>(other._withhold_status._countries);
-      
+
         break;
       }
-    
+
       case type::withhold_user:
       {
         _withhold_user._user_id = other._withhold_user._user_id;
         new(&_withhold_user._countries) std::vector<std::string>(other._withhold_user._countries);
-      
+
         break;
       }
-    
+
       case type::disconnect:
       {
         _disconnect = other._disconnect;
-      
+
         break;
       }
-    
+
       case type::friends:
       {
         new(&_friends) std::set<user_id>(other._friends);
-      
+
         break;
       }
-    
+
       case type::direct:
       {
         new(&_direct_message) direct_message(other._direct_message);
-      
+
         break;
       }
-      
+
       case type::unknown:
       case type::invalid:
       {
@@ -398,19 +396,19 @@ namespace twitter {
       }
     }
   }
-  
+
   notification::notification(notification&& other) : notification()
   {
     swap(*this, other);
   }
-  
+
   notification& notification::operator=(notification other)
   {
     swap(*this, other);
-    
+
     return *this;
   }
-  
+
   notification::~notification()
   {
     switch (_type)
@@ -418,10 +416,10 @@ namespace twitter {
       case type::tweet:
       {
         _tweet.~tweet();
-        
+
         break;
       }
-      
+
       case type::update_user:
       case type::block:
       case type::unblock:
@@ -430,10 +428,10 @@ namespace twitter {
       case type::unfollow:
       {
         _user.~user();
-        
+
         break;
       }
-      
+
       case type::favorite:
       case type::favorited:
       case type::unfavorite:
@@ -442,19 +440,19 @@ namespace twitter {
       {
         _user_and_tweet._user.~user();
         _user_and_tweet._tweet.~tweet();
-        
+
         break;
       }
-      
+
       case type::list_created:
       case type::list_destroyed:
       case type::list_updated:
       {
         _list.~list();
-        
+
         break;
       }
-      
+
       case type::list_add:
       case type::list_added:
       case type::list_remove:
@@ -466,51 +464,51 @@ namespace twitter {
       {
         _user_and_list._user.~user();
         _user_and_list._list.~list();
-        
+
         break;
       }
-      
+
       case type::stall:
       case type::follow_limit:
       case type::unknown_warning:
       {
         using string_type = std::string;
         _warning.~string_type();
-        
+
         break;
       }
-      
+
       case type::withhold_status:
       {
         using list_type = std::vector<std::string>;
         _withhold_status._countries.~list_type();
-                
+
         break;
       }
-      
+
       case type::withhold_user:
       {
         using list_type = std::vector<std::string>;
         _withhold_user._countries.~list_type();
-        
+
         break;
       }
-            
+
       case type::friends:
       {
         using list_type = std::set<user_id>;
         _friends.~list_type();
-        
+
         break;
       }
-      
+
       case type::direct:
       {
         _direct_message.~direct_message();
-        
+
         break;
       }
-      
+
       case type::deletion:
       case type::scrub_location:
       case type::limit:
@@ -522,11 +520,11 @@ namespace twitter {
       }
     }
   }
-  
+
   void swap(notification& first, notification& second)
   {
     using type = notification::type;
-    
+
     type tempType = first._type;
     tweet tempTweet;
     user tempUser;
@@ -539,16 +537,16 @@ namespace twitter {
     disconnect_code tempDisconnectCode;
     std::set<user_id> tempFriends;
     direct_message tempDirectMessage;
-    
+
     switch (first._type)
     {
       case type::tweet:
       {
         tempTweet = std::move(first._tweet);
-        
+
         break;
       }
-      
+
       case type::update_user:
       case type::block:
       case type::unblock:
@@ -557,10 +555,10 @@ namespace twitter {
       case type::unfollow:
       {
         tempUser = std::move(first._user);
-      
+
         break;
       }
-    
+
       case type::favorite:
       case type::favorited:
       case type::unfavorite:
@@ -569,19 +567,19 @@ namespace twitter {
       {
         tempTweet = std::move(first._user_and_tweet._tweet);
         tempUser = std::move(first._user_and_tweet._user);
-      
+
         break;
       }
-    
+
       case type::list_created:
       case type::list_destroyed:
       case type::list_updated:
       {
         tempList = std::move(first._list);
-      
+
         break;
       }
-    
+
       case type::list_add:
       case type::list_added:
       case type::list_remove:
@@ -593,97 +591,97 @@ namespace twitter {
       {
         tempList = std::move(first._user_and_list._list);
         tempUser = std::move(first._user_and_list._user);
-      
+
         break;
       }
-    
+
       case type::stall:
       case type::follow_limit:
       case type::unknown_warning:
       {
         tempWarning = std::move(first._warning);
-      
+
         break;
       }
-    
+
       case type::deletion:
       case type::scrub_location:
       {
         tempUserId = first._user_id_and_tweet_id._user_id;
         tempTweetId = first._user_id_and_tweet_id._tweet_id;
-      
+
         break;
       }
-    
+
       case type::limit:
       {
         tempLimit = first._limit;
-      
+
         break;
       }
-    
+
       case type::withhold_status:
       {
         tempUserId = first._withhold_status._user_id;
         tempTweetId = first._withhold_status._tweet_id;
         tempCountries = std::move(first._withhold_status._countries);
-      
+
         break;
       }
-    
+
       case type::withhold_user:
       {
         tempUserId = first._withhold_user._user_id;
         tempCountries = std::move(first._withhold_user._countries);
-      
+
         break;
       }
-    
+
       case type::disconnect:
       {
         tempDisconnectCode = first._disconnect;
-      
+
         break;
       }
-    
+
       case type::friends:
       {
         tempFriends = std::move(first._friends);
-      
+
         break;
       }
-    
+
       case type::direct:
       {
         tempDirectMessage = std::move(first._direct_message);
-      
+
         break;
       }
-    
+
       case type::invalid:
       case type::unknown:
       {
         break;
       }
     }
-    
+
     first.~notification();
-    
+
     first._type = second._type;
-    
+
     // Okay now you need to initialize the first with the data from the second
     // And then destruct the second and initialize it with the data stored in temp
     // This is hell
-    
+
     switch (second._type)
     {
       case type::tweet:
       {
         new(&first._tweet) tweet(std::move(second._tweet));
-        
+
         break;
       }
-      
+
       case type::update_user:
       case type::block:
       case type::unblock:
@@ -692,10 +690,10 @@ namespace twitter {
       case type::unfollow:
       {
         new(&first._user) user(std::move(second._user));
-        
+
         break;
       }
-      
+
       case type::favorite:
       case type::favorited:
       case type::unfavorite:
@@ -704,19 +702,19 @@ namespace twitter {
       {
         new(&first._user_and_tweet._user) user(std::move(second._user_and_tweet._user));
         new(&first._user_and_tweet._tweet) tweet(std::move(second._user_and_tweet._tweet));
-        
+
         break;
       }
-      
+
       case type::list_created:
       case type::list_destroyed:
       case type::list_updated:
       {
         new(&first._list) list(std::move(second._list));
-        
+
         break;
       }
-      
+
       case type::list_add:
       case type::list_added:
       case type::list_remove:
@@ -728,94 +726,94 @@ namespace twitter {
       {
         new(&first._user_and_list._user) user(std::move(second._user_and_list._user));
         new(&first._user_and_list._list) list(std::move(second._user_and_list._list));
-        
+
         break;
       }
-      
+
       case type::stall:
       case type::follow_limit:
       case type::unknown_warning:
       {
         new(&first._warning) std::string(std::move(second._warning));
-        
+
         break;
       }
-      
+
       case type::deletion:
       case type::scrub_location:
       {
         first._user_id_and_tweet_id._user_id = second._user_id_and_tweet_id._user_id;
         first._user_id_and_tweet_id._tweet_id = second._user_id_and_tweet_id._tweet_id;
-        
+
         break;
       }
-      
+
       case type::limit:
       {
         first._limit = second._limit;
-        
+
         break;
       }
-      
+
       case type::withhold_status:
       {
         first._withhold_status._user_id = second._withhold_status._user_id;
         first._withhold_status._tweet_id = second._withhold_status._tweet_id;
         new(&first._withhold_status._countries) std::vector<std::string>(std::move(second._withhold_status._countries));
-        
+
         break;
       }
-      
+
       case type::withhold_user:
       {
         first._withhold_user._user_id = second._withhold_user._user_id;
         new(&first._withhold_user._countries) std::vector<std::string>(std::move(second._withhold_user._countries));
-        
+
         break;
       }
-      
+
       case type::disconnect:
       {
         first._disconnect = second._disconnect;
-        
+
         break;
       }
-      
+
       case type::friends:
       {
         new(&first._friends) std::set<user_id>(std::move(second._friends));
-        
+
         break;
       }
-      
+
       case type::direct:
       {
         new(&first._direct_message) direct_message(std::move(second._direct_message));
-        
+
         break;
       }
-      
+
       case type::invalid:
       case type::unknown:
       {
         break;
       }
     }
-    
+
     // Now destruct the second and initialize it with data from the first
     second.~notification();
-    
+
     second._type = tempType;
-    
+
     switch (tempType)
     {
       case type::tweet:
       {
         new(&second._tweet) tweet(std::move(tempTweet));
-      
+
         break;
       }
-    
+
       case type::update_user:
       case type::block:
       case type::unblock:
@@ -824,10 +822,10 @@ namespace twitter {
       case type::unfollow:
       {
         new(&second._user) user(std::move(tempUser));
-      
+
         break;
       }
-    
+
       case type::favorite:
       case type::favorited:
       case type::unfavorite:
@@ -836,19 +834,19 @@ namespace twitter {
       {
         new(&second._user_and_tweet._user) user(std::move(tempUser));
         new(&second._user_and_tweet._tweet) tweet(std::move(tempTweet));
-      
+
         break;
       }
-    
+
       case type::list_created:
       case type::list_destroyed:
       case type::list_updated:
       {
         new(&second._list) list(std::move(tempList));
-      
+
         break;
       }
-    
+
       case type::list_add:
       case type::list_added:
       case type::list_remove:
@@ -860,73 +858,73 @@ namespace twitter {
       {
         new(&second._user_and_list._user) user(std::move(tempUser));
         new(&second._user_and_list._list) list(std::move(tempList));
-      
+
         break;
       }
-    
+
       case type::stall:
       case type::follow_limit:
       case type::unknown_warning:
       {
         new(&second._warning) std::string(std::move(tempWarning));
-      
+
         break;
       }
-    
+
       case type::deletion:
       case type::scrub_location:
       {
         second._user_id_and_tweet_id._user_id = tempUserId;
         second._user_id_and_tweet_id._tweet_id = tempTweetId;
-      
+
         break;
       }
-    
+
       case type::limit:
       {
         second._limit = tempLimit;
-      
+
         break;
       }
-    
+
       case type::withhold_status:
       {
         second._withhold_status._user_id = tempUserId;
         second._withhold_status._tweet_id = tempTweetId;
         new(&second._withhold_status._countries) std::vector<std::string>(std::move(tempCountries));
-      
+
         break;
       }
-    
+
       case type::withhold_user:
       {
         second._withhold_user._user_id = tempUserId;
         new(&second._withhold_user._countries) std::vector<std::string>(std::move(tempCountries));
-      
+
         break;
       }
-    
+
       case type::disconnect:
       {
         second._disconnect = tempDisconnectCode;
-      
+
         break;
       }
-    
+
       case type::friends:
       {
         new(&second._friends) std::set<user_id>(std::move(tempFriends));
-      
+
         break;
       }
-    
+
       case type::direct:
       {
         new(&second._direct_message) direct_message(std::move(tempDirectMessage));
-      
+
         break;
       }
-    
+
       case type::invalid:
       case type::unknown:
       {
@@ -934,7 +932,7 @@ namespace twitter {
       }
     }
   }
-  
+
   const tweet& notification::getTweet() const
   {
     switch (_type)
@@ -943,7 +941,7 @@ namespace twitter {
       {
         return _tweet;
       }
-      
+
       case type::favorite:
       case type::favorited:
       case type::unfavorite:
@@ -952,14 +950,14 @@ namespace twitter {
       {
         return _user_and_tweet._tweet;
       }
-      
+
       default:
       {
         assert(false);
       }
     }
   }
-  
+
   const user& notification::getUser() const
   {
     switch (_type)
@@ -973,7 +971,7 @@ namespace twitter {
       {
         return _user;
       }
-      
+
       case type::favorite:
       case type::favorited:
       case type::unfavorite:
@@ -982,7 +980,7 @@ namespace twitter {
       {
         return _user_and_tweet._user;
       }
-      
+
       case type::list_add:
       case type::list_added:
       case type::list_remove:
@@ -994,25 +992,25 @@ namespace twitter {
       {
         return _user_and_list._user;
       }
-      
+
       default:
       {
         assert(false);
       }
     }
   }
-  
+
   const list& notification::getList() const
   {
     switch (_type)
-    {      
+    {
       case type::list_created:
       case type::list_destroyed:
       case type::list_updated:
       {
         return _list;
       }
-      
+
       case type::list_add:
       case type::list_added:
       case type::list_remove:
@@ -1024,14 +1022,14 @@ namespace twitter {
       {
         return _user_and_list._list;
       }
-      
+
       default:
       {
         assert(false);
       }
     }
   }
-  
+
   tweet_id notification::getTweetID() const
   {
     switch (_type)
@@ -1041,19 +1039,19 @@ namespace twitter {
       {
         return _user_id_and_tweet_id._tweet_id;
       }
-      
+
       case type::withhold_status:
       {
         return _withhold_status._tweet_id;
       }
-      
+
       default:
       {
         assert(false);
       }
     }
   }
-  
+
   void notification::setTweetID(tweet_id _arg)
   {
     switch (_type)
@@ -1063,34 +1061,34 @@ namespace twitter {
       {
         _user_id_and_tweet_id._tweet_id = _arg;;
       }
-      
+
       case type::withhold_status:
       {
         _withhold_status._tweet_id = _arg;
       }
-      
+
       default:
       {
         assert(false);
       }
     }
   }
-  
+
   user_id notification::getUserID() const
   {
     switch (_type)
-    {      
+    {
       case type::deletion:
       case type::scrub_location:
       {
         return _user_id_and_tweet_id._user_id;
       }
-      
+
       case type::withhold_status:
       {
         return _withhold_status._user_id;
       }
-      
+
       case type::withhold_user:
       {
         return _withhold_user._user_id;
@@ -1102,22 +1100,22 @@ namespace twitter {
       }
     }
   }
-  
+
   void notification::setUserID(user_id _arg)
   {
     switch (_type)
-    {      
+    {
       case type::deletion:
       case type::scrub_location:
       {
         _user_id_and_tweet_id._user_id = _arg;
       }
-      
+
       case type::withhold_status:
       {
         _withhold_status._user_id = _arg;
       }
-      
+
       case type::withhold_user:
       {
         _withhold_user._user_id = _arg;
@@ -1129,16 +1127,16 @@ namespace twitter {
       }
     }
   }
-  
+
   const std::vector<std::string>& notification::getCountries() const
   {
     switch (_type)
-    { 
+    {
       case type::withhold_status:
       {
         return _withhold_status._countries;
       }
-      
+
       case type::withhold_user:
       {
         return _withhold_user._countries;
@@ -1150,49 +1148,49 @@ namespace twitter {
       }
     }
   }
-  
+
   disconnect_code notification::getDisconnectCode() const
   {
     assert(_type == type::disconnect);
-    
+
     return _disconnect;
   }
-  
+
   void notification::setDisconnectCode(disconnect_code _arg)
   {
     assert(_type == type::disconnect);
-    
+
     _disconnect = _arg;
   }
-  
+
   const std::set<user_id>& notification::getFriends() const
   {
     assert(_type == type::friends);
-    
+
     return _friends;
   }
-  
+
   const direct_message& notification::getDirectMessage() const
   {
     assert(_type == type::direct);
-    
+
     return _direct_message;
   }
-  
+
   int notification::getLimit() const
   {
     assert(_type == type::limit);
-    
+
     return _limit;
   }
-  
+
   void notification::setLimit(int _arg)
   {
     assert(_type == type::limit);
-    
+
     _limit = _arg;
   }
-  
+
   const std::string& notification::getWarning() const
   {
     switch (_type)
@@ -1203,12 +1201,12 @@ namespace twitter {
       {
         return _warning;
       }
-      
+
       default:
       {
         assert(false);
       }
     }
   }
-  
+
 };
@@ -10,9 +10,9 @@
 #include "direct_message.h"
 
 namespace twitter {
-  
+
   class client;
-  
+
   enum class disconnect_code
   {
     shutdown,
@@ -27,13 +27,13 @@ namespace twitter {
     load,
     unknown
   };
-  
+
   class notification {
   public:
     enum class type {
       // Tweet object
       tweet,
-      
+
       // User object
       update_user,
       block,
@@ -41,19 +41,19 @@ namespace twitter {
       follow,
       followed,
       unfollow,
-      
+
       // User and tweet
       favorite,
       favorited,
       unfavorite,
       unfavorited,
       quoted,
-      
+
       // List
       list_created,
       list_destroyed,
       list_updated,
-      
+
       // User and list
       list_add,
       list_added,
@@ -63,16 +63,16 @@ namespace twitter {
       list_subscribed,
       list_unsubscribe,
       list_unsubscribed,
-      
+
       // Warning
       stall,
       follow_limit,
       unknown_warning,
-      
+
       // User ID and tweet ID
       deletion,
       scrub_location,
-      
+
       // Special
       limit,
       withhold_status,
@@ -80,78 +80,78 @@ namespace twitter {
       disconnect,
       friends,
       direct,
-      
+
       // Nothing
       unknown,
       invalid
     };
-    
+
     type getType() const;
-    
+
     notification() {}
-    notification(const client& tclient, std::string data);
-    
+    notification(const user& currentUser, std::string data);
+
     notification(const notification& other);
     notification(notification&& other);
     notification& operator=(notification other);
     ~notification();
-    
+
     friend void swap(notification& first, notification& second);
-    
+
     const tweet& getTweet() const;
     tweet& getTweet()
     {
       return const_cast<tweet&>(static_cast<const notification&>(*this).getTweet());
     }
-    
+
     const user& getUser() const;
     user& getUser()
     {
       return const_cast<user&>(static_cast<const notification&>(*this).getUser());
     }
-    
+
     const list& getList() const;
     list& getList()
     {
       return const_cast<list&>(static_cast<const notification&>(*this).getList());
     }
-    
+
     tweet_id getTweetID() const;
     void setTweetID(tweet_id _arg);
-    
+
     user_id getUserID() const;
     void setUserID(user_id _arg);
-    
+
     const std::vector<std::string>& getCountries() const;
     std::vector<std::string>& getCountries()
     {
       return const_cast<std::vector<std::string>&>(static_cast<const notification&>(*this).getCountries());
     }
-    
+
     disconnect_code getDisconnectCode() const;
     void setDisconnectCode(disconnect_code _arg);
-    
+
     const std::set<user_id>& getFriends() const;
     std::set<user_id>& getFriends()
     {
       return const_cast<std::set<user_id>&>(static_cast<const notification&>(*this).getFriends());
     }
-    
+
     const direct_message& getDirectMessage() const;
     direct_message& getDirectMessage()
     {
       return const_cast<direct_message&>(static_cast<const notification&>(*this).getDirectMessage());
     }
-    
+
     int getLimit() const;
     void setLimit(int _arg);
-    
+
     const std::string& getWarning() const;
     std::string& getWarning()
     {
       return const_cast<std::string&>(static_cast<const notification&>(*this).getWarning());
     }
-    
+
   private:
     union {
       tweet _tweet;
@@ -186,7 +186,7 @@ namespace twitter {
     };
     type _type = type::invalid;
   };
-  
+
 };
 
 #endif /* end of include guard: NOTIFICATION_H_69AEF4CC */
@@ -0,0 +1,264 @@
+#include "request.h"
+#include <json.hpp>
+#include "codes.h"
+
+// These are here for debugging curl stuff
+
+static
+void dump(const char *text,
+          FILE *stream, unsigned char *ptr, size_t size)
+{
+  size_t i;
+  size_t c;
+  unsigned int width=80;
+
+  fprintf(stream, "%s, %10.10ld bytes (0x%8.8lx)\n",
+          text, (long)size, (long)size);
+
+  for(i=0; i<size; i+= width) {
+    fprintf(stream, "%4.4lx: ", (long)i);
+
+    /* show hex to the left
+    for(c = 0; c < width; c++) {
+      if(i+c < size)
+        fprintf(stream, "%02x ", ptr[i+c]);
+      else
+        fputs("   ", stream);
+    }*/
+
+    /* show data on the right */
+    for(c = 0; (c < width) && (i+c < size); c++) {
+      char x = (ptr[i+c] >= 0x20 && ptr[i+c] < 0x80) ? ptr[i+c] : '.';
+      fputc(x, stream);
+    }
+
+    fputc('\n', stream); /* newline */
+  }
+}
+
+static
+int my_trace(CURL *handle, curl_infotype type,
+             char *data, size_t size,
+             void *userp)
+{
+  const char *text;
+  (void)handle; /* prevent compiler warning */
+
+  switch (type) {
+  case CURLINFO_TEXT:
+    fprintf(stderr, "== Info: %s", data);
+  default: /* in case a new one is introduced to shock us */
+    return 0;
+
+  case CURLINFO_HEADER_OUT:
+    text = "=> Send header";
+    break;
+  case CURLINFO_DATA_OUT:
+    text = "=> Send data";
+    break;
+  case CURLINFO_SSL_DATA_OUT:
+    text = "=> Send SSL data";
+    break;
+  case CURLINFO_HEADER_IN:
+    text = "<= Recv header";
+    break;
+  case CURLINFO_DATA_IN:
+    text = "<= Recv data";
+    break;
+  case CURLINFO_SSL_DATA_IN:
+    text = "<= Recv SSL data";
+    break;
+  }
+
+  dump(text, stderr, (unsigned char *)data, size);
+  return 0;
+}
+
+namespace twitter {
+
+  request::request(
+    std::string url) try :
+      ios_(output_),
+      conn_(ios_)
+  {
+    conn_.add<CURLOPT_URL>(url.c_str());
+  } catch (const curl::curl_easy_exception& error)
+  {
+    std::throw_with_nested(connection_error());
+  }
+
+  std::string request::perform()
+  {
+    try
+    {
+      conn_.perform();
+    } catch (const curl::curl_easy_exception& error)
+    {
+      std::throw_with_nested(connection_error());
+    }
+
+    int response_code = conn_.get_info<CURLINFO_RESPONSE_CODE>().get();
+    std::string result = output_.str();
+
+    if (response_code / 100 != 2)
+    {
+      nlohmann::json response_json;
+
+      try
+      {
+        response_json = nlohmann::json::parse(result);
+      } catch (const std::invalid_argument& e)
+      {
+        std::throw_with_nested(invalid_response(result));
+      }
+
+      for (nlohmann::json& error : response_json["errors"])
+      {
+        int error_code;
+        std::string error_message;
+
+        try
+        {
+          error_code = error["code"].get<int>();
+          error_message = error["message"].get<std::string>();
+        } catch (const std::domain_error& e)
+        {
+          std::throw_with_nested(invalid_response(result));
+        }
+
+        switch (error_code)
+        {
+        case 32:
+        case 135:
+        case 215:
+          throw bad_auth(error_message);
+
+        case 44:
+          throw invalid_media(error_message);
+
+        case 64:
+          throw account_suspended(error_message);
+
+        case 88:
+          throw rate_limit_exceeded(error_message);
+
+        case 89:
+          throw bad_token(error_message);
+
+        case 130:
+          throw server_overloaded(error_message);
+
+        case 131:
+          throw server_error(error_message);
+
+        case 185:
+          throw update_limit_exceeded(error_message);
+
+        case 186:
+          throw bad_length(error_message);
+
+        case 187:
+          throw duplicate_status(error_message);
+
+        case 226:
+          throw suspected_spam(error_message);
+
+        case 261:
+          throw write_restricted(error_message);
+        }
+      }
+
+      if (response_code == 429)
+      {
+        throw rate_limit_exceeded("HTTP 429 Too Many Requests");
+      } else if (response_code == 500)
+      {
+        throw server_error("HTTP 500 Internal Server Error");
+      } else if (response_code == 502)
+      {
+        throw server_unavailable("HTTP 502 Bad Gateway");
+      } else if (response_code == 503)
+      {
+        throw server_overloaded("HTTP 503 Service Unavailable");
+      } else if (response_code == 504)
+      {
+        throw server_timeout("HTTP 504 Gateway Timeout");
+      }
+
+      throw unknown_error(response_code, result);
+    }
+
+    return result;
+  }
+
+  get::get(
+    const auth& tauth,
+    std::string url) try :
+      request(url)
+  {
+    std::string oauthHeader =
+      tauth.getClient().getFormattedHttpHeader(OAuth::Http::Get, url, "");
+
+    if (!oauthHeader.empty())
+    {
+      headers_.add(std::move(oauthHeader));
+    }
+
+    conn_.add<CURLOPT_HTTPHEADER>(headers_.get());
+  } catch (const OAuth::ParseError& error)
+  {
+    std::throw_with_nested(connection_error());
+  } catch (const curl::curl_easy_exception& error)
+  {
+    std::throw_with_nested(connection_error());
+  }
+
+  post::post(
+    const auth& tauth,
+    std::string url,
+    std::string datastr) try :
+      request(url)
+  {
+    std::string oauthHeader =
+      tauth.getClient().getFormattedHttpHeader(OAuth::Http::Post, url, datastr);
+
+    if (!oauthHeader.empty())
+    {
+      headers_.add(std::move(oauthHeader));
+    }
+
+    conn_.add<CURLOPT_HTTPHEADER>(headers_.get());
+    conn_.add<CURLOPT_COPYPOSTFIELDS>(datastr.c_str());
+  } catch (const OAuth::ParseError& error)
+  {
+    std::throw_with_nested(connection_error());
+  } catch (const curl::curl_easy_exception& error)
+  {
+    std::throw_with_nested(connection_error());
+  }
+
+  multipost::multipost(
+    const auth& tauth,
+    std::string url,
+    const curl_httppost* fields) try :
+      request(url)
+  {
+    std::string oauthHeader =
+      tauth.getClient().getFormattedHttpHeader(OAuth::Http::Post, url, "");
+
+    if (!oauthHeader.empty())
+    {
+      headers_.add(std::move(oauthHeader));
+    }
+
+    conn_.add<CURLOPT_HTTPHEADER>(headers_.get());
+    conn_.add<CURLOPT_HTTPPOST>(fields);
+  } catch (const OAuth::ParseError& error)
+  {
+    std::throw_with_nested(connection_error());
+  } catch (const curl::curl_easy_exception& error)
+  {
+    std::throw_with_nested(connection_error());
+  }
+
+}
@@ -0,0 +1,73 @@
+#ifndef REQUEST_H_9D3C30E2
+#define REQUEST_H_9D3C30E2
+
+#include <string>
+#include <sstream>
+#include <curl_easy.h>
+#include <curl_header.h>
+#include "auth.h"
+
+namespace twitter {
+
+  class request
+  {
+  public:
+
+    explicit request(std::string url);
+
+    std::string perform();
+
+  private:
+
+    std::ostringstream output_;
+    curl::curl_ios<std::ostringstream> ios_;
+
+  protected:
+
+    curl::curl_easy conn_;
+  };
+
+  class get : public request
+  {
+  public:
+
+    get(
+      const auth& tauth,
+      std::string url);
+
+  private:
+
+    curl::curl_header headers_;
+  };
+
+  class post : public request
+  {
+  public:
+
+    post(
+      const auth& tauth,
+      std::string url,
+      std::string datastr);
+
+  private:
+
+    curl::curl_header headers_;
+  };
+
+  class multipost : public request
+  {
+  public:
+
+    multipost(
+      const auth& tauth,
+      std::string url,
+      const curl_httppost* fields);
+
+  private:
+
+    curl::curl_header headers_;
+  };
+
+}
+
+#endif /* end of include guard: REQUEST_H_9D3C30E2 */
@@ -4,23 +4,27 @@
 #include <curl_header.h>
 #include "util.h"
 #include "notification.h"
-#include "client.h"
+#include "request.h"
 
 namespace twitter {
 
   stream::stream(
-    const client& tclient,
+    const auth& tauth,
     notify_callback callback,
     bool with_followings,
     bool receive_all_replies,
     std::list<std::string> track,
     std::list<bounding_box> locations) :
-      _client(tclient),
+      _auth(tauth),
       _notify(callback),
+      _currentUser(get(
+        _auth,
+        "https://api.twitter.com/1.1/account/verify_credentials.json")
+          .perform()),
       _thread(&stream::run, this, generateUrl(with_followings, receive_all_replies, track, locations))
   {
   }
-  
+
   stream::~stream()
   {
     if (_thread.joinable())
@@ -29,7 +33,7 @@ namespace twitter {
       _thread.join();
     }
   }
-  
+
   std::string stream::generateUrl(
     bool with_followings,
     bool receive_all_replies,
@@ -37,68 +41,68 @@ namespace twitter {
     std::list<bounding_box> locations)
   {
     std::list<std::string> arguments;
-    
+
     if (receive_all_replies)
     {
       arguments.push_back("replies=all");
     }
-    
+
     if (!with_followings)
     {
       arguments.push_back("with=user");
     }
-    
+
     if (!track.empty())
     {
       std::ostringstream trackstr;
       trackstr << "track=";
-      
+
       for (auto it = std::begin(track); it != std::end(track); it++)
       {
         if (it != std::begin(track))
         {
           trackstr << ",";
         }
-        
+
         trackstr << OAuth::HttpEncodeQueryValue(*it);
       }
-      
+
       arguments.push_back(trackstr.str());
     }
-    
+
     if (!locations.empty())
     {
       std::ostringstream localstr;
       localstr << "locations=";
-      
+
       for (auto it = std::begin(locations); it != std::end(locations); it++)
       {
         if (it != std::begin(locations))
         {
           localstr << ",";
         }
-        
+
         localstr << (double)it->getSouthWestLongitude() << ",";
         localstr << (double)it->getSouthWestLatitude() << ",";
         localstr << (double)it->getNorthEastLongitude() << ",";
         localstr << (double)it->getNorthEastLatitude();
       }
-      
+
       arguments.push_back(localstr.str());
     }
-    
+
     std::ostringstream urlstr;
     urlstr << "https://userstream.twitter.com/1.1/user.json";
-    
+
     if (!arguments.empty())
     {
       urlstr << "?";
       urlstr << implode(std::begin(arguments), std::end(arguments), "&");
     }
-    
+
     return urlstr.str();
   }
-  
+
   void stream::run(std::string url)
   {
     _backoff_type = backoff::none;
@@ -108,15 +112,15 @@ namespace twitter {
       curl::curl_ios<stream> ios(this, [] (void* contents, size_t size, size_t nmemb, void* userp) {
         return static_cast<stream*>(userp)->write(static_cast<char*>(contents), size, nmemb);
       });
-    
+
       curl::curl_easy conn(ios);
       curl::curl_header headers;
       std::string oauth_header;
-    
+
       try
       {
-        oauth_header = _client._oauth_client->getFormattedHttpHeader(OAuth::Http::Get, url, "");
-      
+        oauth_header = _auth.getClient().getFormattedHttpHeader(OAuth::Http::Get, url, "");
+
         if (!oauth_header.empty())
         {
           headers.add(oauth_header);
@@ -126,10 +130,10 @@ namespace twitter {
         std::cout << "Error generating OAuth header:" << std::endl;
         std::cout << error.what() << std::endl;
         std::cout << "This is likely due to a malformed URL." << std::endl;
-  
+
         assert(false);
       }
-    
+
       try
       {
         conn.add<CURLOPT_HEADERFUNCTION>(nullptr);
@@ -146,10 +150,10 @@ namespace twitter {
       } catch (const curl::curl_exception& error)
       {
         error.print_traceback();
-      
+
         assert(false);
       }
-      
+
       bool failure = false;
       try
       {
@@ -169,7 +173,7 @@ namespace twitter {
           }
         }
       }
-      
+
       if (!failure)
       {
         long response_code = conn.get_info<CURLINFO_RESPONSE_CODE>().get();
@@ -198,7 +202,7 @@ namespace twitter {
           }
         }
       }
-      
+
       std::this_thread::sleep_for(_backoff_amount);
 
       switch (_backoff_type)
@@ -209,35 +213,35 @@ namespace twitter {
           {
             _backoff_amount += std::chrono::milliseconds(250);
           }
-        
+
           break;
         }
-      
+
         case backoff::http:
         {
           if (_backoff_amount < std::chrono::seconds(320))
           {
             _backoff_amount *= 2;
           }
-        
+
           break;
         }
-      
+
         case backoff::rate_limit:
         {
           _backoff_amount *= 2;
-        
+
           break;
         }
-        
+
         case backoff::none:
-        { 
+        {
           break;
         }
       }
     }
   }
-  
+
   size_t stream::write(char* ptr, size_t size, size_t nmemb)
   {
     for (size_t i = 0; i < size*nmemb; i++)
@@ -245,38 +249,38 @@ namespace twitter {
       if (ptr[i] == '\r')
       {
         i++; // Skip the \n
-        
+
         if (!_buffer.empty())
         {
-          notification n(_client, _buffer);
+          notification n(_currentUser, _buffer);
           if (n.getType() == notification::type::friends)
           {
             _established = true;
             _backoff_type = backoff::none;
             _backoff_amount = std::chrono::milliseconds(0);
           }
-          
+
           _notify(std::move(n));
-                    
+
           _buffer = "";
         }
       } else {
         _buffer.push_back(ptr[i]);
       }
     }
-    
+
     time(&_last_write);
-    
+
     return size*nmemb;
   }
-  
+
   int stream::progress()
   {
     if (_stop)
     {
       return 1;
     }
-    
+
     if (_established)
     {
       if (difftime(time(NULL), _last_write) >= 90)
@@ -284,8 +288,8 @@ namespace twitter {
         return 1;
       }
     }
-    
+
     return 0;
   }
-  
+
 }
@@ -7,32 +7,35 @@
 #include <chrono>
 #include <thread>
 #include "bounding_box.h"
+#include "auth.h"
+#include "user.h"
 
 namespace twitter {
-  
-  class client;
+
   class notification;
-  
-  class stream {
+
+  class
+  [[deprecated("The Twitter streaming API will sunset on August 16th, 2018")]]
+  stream {
   public:
-    
+
     typedef std::function<void(notification _notification)> notify_callback;
-    
+
     stream(
-      const client& tclient,
+      const auth& tauth,
       notify_callback callback,
       bool with_followings = true,
       bool receive_all_replies = false,
       std::list<std::string> track = {},
       std::list<bounding_box> locations = {});
-      
+
     ~stream();
-    
+
     stream(const stream& other) = delete;
     stream(stream&& other) = delete;
     stream& operator=(const stream& other) = delete;
     stream& operator=(stream&& other) = delete;
-    
+
   private:
     enum class backoff {
       none,
@@ -40,18 +43,18 @@ namespace twitter {
       http,
       rate_limit
     };
-    
+
     static std::string generateUrl(
       bool with_followings,
       bool receive_all_replies,
       std::list<std::string> track,
       std::list<bounding_box> locations);
-    
+
     void run(std::string url);
     int progress();
     size_t write(char* ptr, size_t size, size_t nmemb);
-    
-    const client& _client;
+
+    const auth& _auth;
     notify_callback _notify;
     bool _stop = false;
     std::string _buffer;
@@ -59,9 +62,10 @@ namespace twitter {
     bool _established = false;
     backoff _backoff_type = backoff::none;
     std::chrono::milliseconds _backoff_amount;
+    user _currentUser;
     std::thread _thread;
   };
-  
+
 }
 
 #endif /* end of include guard: STREAM_H_E9146952 */
@@ -0,0 +1,82 @@
+#include "timeline.h"
+#include <sstream>
+#include <json.hpp>
+#include "codes.h"
+#include "util.h"
+#include "request.h"
+
+namespace twitter {
+
+  timeline::timeline(
+    const auth& tauth,
+    std::string url) :
+      auth_(tauth),
+      url_(std::move(url))
+  {
+  }
+
+  std::list<tweet> timeline::poll()
+  {
+    tweet_id maxId;
+    std::list<tweet> result;
+
+    for (int i = 0; i < 5; i++)
+    {
+      std::ostringstream urlstr;
+      urlstr << url_;
+
+      std::list<std::string> arguments;
+
+      if (i > 0)
+      {
+        arguments.push_back("max_id=" + std::to_string(maxId));
+      }
+
+      if (hasSince_)
+      {
+        arguments.push_back("since_id=" + std::to_string(sinceId_));
+      }
+
+      if (!arguments.empty())
+      {
+        urlstr << "?";
+        urlstr << implode(std::begin(arguments), std::end(arguments), "&");
+      }
+
+      std::string theUrl = urlstr.str();
+      std::string response = get(auth_, theUrl).perform();
+
+      try
+      {
+        nlohmann::json rjs = nlohmann::json::parse(response);
+
+        if (rjs.empty())
+        {
+          break;
+        }
+
+        for (auto& single : rjs)
+        {
+          result.emplace_back(single.dump());
+        }
+      } catch (const std::invalid_argument& error)
+      {
+        std::throw_with_nested(invalid_response(response));
+      } catch (const std::domain_error& error)
+      {
+        std::throw_with_nested(invalid_response(response));
+      }
+
+      maxId = result.back().getID() - 1;
+    }
+
+    if (!result.empty())
+    {
+      sinceId_ = result.front().getID();
+      hasSince_ = true;
+    }
+
+    return result;
+  }
+
+};
@@ -0,0 +1,31 @@
+#ifndef TIMELINE_H_D359681C
+#define TIMELINE_H_D359681C
+
+#include <functional>
+#include <list>
+#include <string>
+#include "auth.h"
+#include "tweet.h"
+
+namespace twitter {
+
+  class timeline {
+  public:
+
+    timeline(
+      const auth& tauth,
+      std::string url);
+
+    std::list<tweet> poll();
+
+  private:
+
+    const auth& auth_;
+    std::string url_;
+    bool hasSince_ = false;
+    tweet_id sinceId_;
+  };
+
+}
+
+#endif /* end of include guard: TIMELINE_H_D359681C */
@@ -12,13 +12,13 @@ namespace twitter {
     auto json = nlohmann::json::parse(data);
     _id = json["id"].get<tweet_id>();
     _text = json["text"].get<std::string>();
-    _author = make_unique<user>(json["user"].dump());
+    _author = std::make_unique<user>(json["user"].dump());
     
     if (!json["retweeted_status"].is_null())
     {
       _is_retweet = true;
       
-      _retweeted_status = make_unique<tweet>(json["retweeted_status"].dump());
+      _retweeted_status = std::make_unique<tweet>(json["retweeted_status"].dump());
     }
     
     if (!json["entities"].is_null())
@@ -45,12 +45,12 @@ namespace twitter {
     _valid = other._valid;
     _id = other._id;
     _text = other._text;
-    _author = make_unique<user>(*other._author);
+    _author = std::make_unique<user>(*other._author);
     _is_retweet = other._is_retweet;
     
     if (_is_retweet)
     {
-      _retweeted_status = make_unique<tweet>(*other._retweeted_status);
+      _retweeted_status = std::make_unique<tweet>(*other._retweeted_status);
     }
     
     _mentions = other._mentions;
@@ -11,6 +11,7 @@ namespace twitter {
 #include "util.h"
 #include "auth.h"
 #include "client.h"
+#include "timeline.h"
 #include "stream.h"
 #include "tweet.h"
 #include "user.h"
@@ -6,31 +6,25 @@
 #include <memory>
 
 namespace twitter {
-  
+
   template <class InputIterator>
   std::string implode(InputIterator first, InputIterator last, std::string delimiter)
   {
     std::stringstream result;
-    
+
     for (InputIterator it = first; it != last; it++)
     {
       if (it != first)
       {
         result << delimiter;
       }
-      
+
       result << *it;
     }
-    
+
     return result.str();
   }
-  
-  template<typename T, typename... Args>
-  std::unique_ptr<T> make_unique(Args&&... args)
-  {
-      return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-  }
-  
+
 };
 
 #endif /* end of include guard: UTIL_H_440DEAA0 */