13 files changed, 1661 insertions, 47 deletions

@@ -4,7 +4,9 @@
 #include <algorithm>
 #include <liboauthcpp/liboauthcpp.h>
 #include "util.h"
-#include <unistd.h>
+#include <json.hpp>
+
+using nlohmann::json;
 
 // These are here for debugging curl stuff
 
@@ -80,11 +82,29 @@ int my_trace(CURL *handle, curl_infotype type,
 
 namespace twitter {
   
+  int client_stream_progress_callback_wrapper(void* cdata, curl_off_t, curl_off_t, curl_off_t, curl_off_t)
+  {
+    return static_cast<client::stream*>(cdata)->progress();
+  }
+  
+  size_t client_stream_write_callback_wrapper(void* ptr, size_t size, size_t nmemb, void* cdata)
+  {
+    return static_cast<client::stream*>(cdata)->write(static_cast<char*>(ptr), size, nmemb);
+  }
+  
   client::client(const auth& _arg)
   {
     _oauth_consumer = new OAuth::Consumer(_arg.getConsumerKey(), _arg.getConsumerSecret());
     _oauth_token = new OAuth::Token(_arg.getAccessKey(), _arg.getAccessSecret());
     _oauth_client = new OAuth::Client(_oauth_consumer, _oauth_token);
+    
+    std::string url = "https://api.twitter.com/1.1/account/verify_credentials.json";
+    long response_code;
+    std::string response_data;
+    if (performGet(url, response_code, response_data) && (response_code == 200))
+    {
+      _current_user = user(response_data);
+    }
   }
   
   client::~client()
@@ -94,11 +114,17 @@ namespace twitter {
     delete _oauth_consumer;
   }
   
-  response client::updateStatus(std::string msg, tweet& result, std::list<long> media_ids)
+  response client::updateStatus(std::string msg, tweet& result, tweet in_response_to, std::list<long> media_ids)
   {
     std::stringstream datastrstream;
     datastrstream << "status=" << OAuth::PercentEncode(msg);
     
+    if (in_response_to)
+    {
+      datastrstream << "&in_reply_to_status_id=";
+      datastrstream << in_response_to.getID();
+    }
+    
     if (!media_ids.empty())
     {
       datastrstream << "&media_ids=";
@@ -109,7 +135,7 @@ namespace twitter {
     std::string url = "https://api.twitter.com/1.1/statuses/update.json";
     
     long response_code;
-    json response_data;
+    std::string response_data;
     if (!performPost(url, datastr, response_code, response_data))
     {
       return response::curl_error;
@@ -147,7 +173,7 @@ namespace twitter {
     }
     
     long response_code;
-    json response_data;
+    std::string response_data;
     if (!performMultiPost("https://upload.twitter.com/1.1/media/upload.json", form.get(), response_code, response_data))
     {
       return response::curl_error;
@@ -158,7 +184,8 @@ namespace twitter {
       return codeForError(response_code, response_data);
     }
     
-    media_id = response_data["media_id"].get<long>();
+    auto response_json = json::parse(response_data);
+    media_id = response_json["media_id"].get<long>();
 
     curl_httppost* append_form_post = nullptr;
     curl_httppost* append_form_last = nullptr;
@@ -197,7 +224,8 @@ namespace twitter {
       return codeForError(response_code, response_data);
     }
     
-    if (response_data.find("processing_info") != response_data.end())
+    response_json = json::parse(response_data);
+    if (response_json.find("processing_info") != response_json.end())
     {
       std::stringstream datastr;
       datastr << "https://upload.twitter.com/1.1/media/upload.json?command=STATUS&media_id=" << media_id;
@@ -214,20 +242,183 @@ namespace twitter {
           return codeForError(response_code, response_data);
         }
         
-        if (response_data["processing_info"]["state"] == "succeeded")
+        response_json = json::parse(response_data);
+        if (response_json["processing_info"]["state"] == "succeeded")
         {
           break;
         }
         
-        int ttw = response_data["processing_info"]["check_after_secs"].get<int>();
-        sleep(ttw);
+        int ttw = response_json["processing_info"]["check_after_secs"].get<int>();
+        std::this_thread::sleep_for(std::chrono::seconds(ttw));
       }
     }
     
     return response::ok;
   }
   
-  bool client::performGet(std::string url, long& response_code, json& result)
+  response client::follow(user_id toFollow)
+  {
+    std::stringstream datastrstream;
+    datastrstream << "follow=true&user_id=";
+    datastrstream << toFollow;
+    
+    std::string datastr = datastrstream.str();
+    std::string url = "https://api.twitter.com/1.1/friendships/create.json";
+    
+    long response_code;
+    std::string response_data;
+    if (!performPost(url, datastr, response_code, response_data))
+    {
+      return response::curl_error;
+    }
+    
+    if (response_code == 200)
+    {
+      return response::ok;
+    } else {
+      return codeForError(response_code, response_data);
+    }
+  }
+  
+  response client::follow(user toFollow)
+  {
+    return follow(toFollow.getID());
+  }
+  
+  response client::unfollow(user_id toUnfollow)
+  {
+    std::stringstream datastrstream;
+    datastrstream << "user_id=";
+    datastrstream << toUnfollow;
+    
+    std::string datastr = datastrstream.str();
+    std::string url = "https://api.twitter.com/1.1/friendships/destroy.json";
+    
+    long response_code;
+    std::string response_data;
+    if (!performPost(url, datastr, response_code, response_data))
+    {
+      return response::curl_error;
+    }
+    
+    if (response_code == 200)
+    {
+      return response::ok;
+    } else {
+      return codeForError(response_code, response_data);
+    }
+  }
+  
+  response client::unfollow(user toUnfollow)
+  {
+    return unfollow(toUnfollow.getID());
+  }
+  
+  const user& client::getUser() const
+  {
+    return _current_user;
+  }
+  
+  response client::getFriends(std::set<user_id>& _ret)
+  {
+    if (!_current_user)
+    {
+      return response::unknown_error;
+    }
+    
+    long long cursor = -1;
+    std::set<user_id> result;
+    
+    while (cursor != 0)
+    {
+      std::stringstream urlstream;
+      urlstream << "https://api.twitter.com/1.1/friends/ids.json?user_id=";
+      urlstream << _current_user.getID();
+      urlstream << "&cursor=";
+      urlstream << cursor;
+  
+      std::string url = urlstream.str();
+  
+      long response_code;
+      std::string response_data;
+      if (!performGet(url, response_code, response_data))
+      {
+        return response::curl_error;
+      }
+  
+      if (response_code == 200)
+      {
+        json rjs = json::parse(response_data);
+        cursor = rjs.at("next_cursor");
+        result.insert(std::begin(rjs.at("ids")), std::end(rjs.at("ids")));
+      } else {
+        return codeForError(response_code, response_data);
+      }
+    }
+    
+    _ret = result;
+    
+    return response::ok;
+  }
+  
+  response client::getFollowers(std::set<user_id>& _ret)
+  {
+    if (!_current_user)
+    {
+      return response::unknown_error;
+    }
+    
+    long long cursor = -1;
+    std::set<user_id> result;
+    
+    while (cursor != 0)
+    {
+      std::stringstream urlstream;
+      urlstream << "https://api.twitter.com/1.1/followers/ids.json?user_id=";
+      urlstream << _current_user.getID();
+      urlstream << "&cursor=";
+      urlstream << cursor;
+  
+      std::string url = urlstream.str();
+  
+      long response_code;
+      std::string response_data;
+      if (!performGet(url, response_code, response_data))
+      {
+        return response::curl_error;
+      }
+  
+      if (response_code == 200)
+      {
+        json rjs = json::parse(response_data);
+        cursor = rjs.at("next_cursor");
+        result.insert(std::begin(rjs.at("ids")), std::end(rjs.at("ids")));
+      } else {
+        return codeForError(response_code, response_data);
+      }
+    }
+    
+    _ret = result;
+    
+    return response::ok;
+  }
+  
+  void client::setUserStreamNotifyCallback(stream::notify_callback callback)
+  {
+    _user_stream.setNotifyCallback(callback);
+  }
+  
+  void client::startUserStream()
+  {
+    _user_stream.start();
+  }
+  
+  void client::stopUserStream()
+  {
+    _user_stream.stop();
+  }
+  
+  bool client::performGet(std::string url, long& response_code, std::string& result)
   {
     std::ostringstream output;
     curl::curl_ios<std::ostringstream> ios(output);
@@ -255,17 +446,12 @@ namespace twitter {
     }
     
     response_code = conn.get_info<CURLINFO_RESPONSE_CODE>().get();
-    if (output.str().empty())
-    {
-      result = json();
-    } else {
-      result = json::parse(output.str());
-    }
+    result = output.str();
     
     return true;
   }
   
-  bool client::performPost(std::string url, std::string datastr, long& response_code, json& result)
+  bool client::performPost(std::string url, std::string datastr, long& response_code, std::string& result)
   {
     std::ostringstream output;
     curl::curl_ios<std::ostringstream> ios(output);
@@ -294,17 +480,12 @@ namespace twitter {
     }
     
     response_code = conn.get_info<CURLINFO_RESPONSE_CODE>().get();
-    if (output.str().empty())
-    {
-      result = json();
-    } else {
-      result = json::parse(output.str());
-    }
+    result = output.str();
     
     return true;
   }
   
-  bool client::performMultiPost(std::string url, const curl_httppost* fields, long& response_code, json& result)
+  bool client::performMultiPost(std::string url, const curl_httppost* fields, long& response_code, std::string& result)
   {
     std::ostringstream output;
     curl::curl_ios<std::ostringstream> ios(output);
@@ -333,23 +514,19 @@ namespace twitter {
     }
     
     response_code = conn.get_info<CURLINFO_RESPONSE_CODE>().get();
-    
-    if (output.str().empty())
-    {
-      result = json();
-    } else {
-      result = json::parse(output.str());
-    }
+    result = output.str();
     
     return true;
   }
   
-  response client::codeForError(int response_code, json response_data) const
+  response client::codeForError(int response_code, std::string response_data) const
   {
+    auto response_json = json::parse(response_data);
+    
     std::set<int> error_codes;
-    if (response_data.find("errors") != response_data.end())
+    if (response_json.find("errors") != response_json.end())
     {
-      std::transform(std::begin(response_data["errors"]), std::end(response_data["errors"]), std::inserter(error_codes, std::begin(error_codes)), [] (const json& error) {
+      std::transform(std::begin(response_json["errors"]), std::end(response_json["errors"]), std::inserter(error_codes, std::begin(error_codes)), [] (const json& error) {
         return error["code"].get<int>();
       });
     }
@@ -407,4 +584,208 @@ namespace twitter {
     }
   }
   
+  client::stream::stream(client& _client) : _client(_client)
+  {
+    
+  }
+  
+  bool client::stream::isRunning() const
+  {
+    return _thread.joinable();
+  }
+  
+  void client::stream::setNotifyCallback(notify_callback _n)
+  {
+    std::lock_guard<std::mutex> _notify_lock(_notify_mutex);
+    _notify = _n;
+  }
+    
+  void client::stream::start()
+  {
+    std::lock_guard<std::mutex> _running_lock(_running_mutex);
+    
+    if (!_thread.joinable())
+    {
+      _thread = std::thread(&stream::run, this);
+    }
+  }
+  
+  void client::stream::stop()
+  {
+    std::lock_guard<std::mutex> _running_lock(_running_mutex);
+    
+    if (_thread.joinable())
+    {
+      _stop = true;
+      _thread.join();
+      _stop = false;
+    }
+  }
+  
+  void client::stream::run()
+  {
+    curl::curl_easy conn;
+    std::string url = "https://userstream.twitter.com/1.1/user.json";
+    
+    curl::curl_header headers;
+    std::string oauth_header = _client._oauth_client->getFormattedHttpHeader(OAuth::Http::Get, url, "");
+    if (!oauth_header.empty())
+    {
+      headers.add(oauth_header);
+    }
+    
+    conn.add<CURLOPT_WRITEFUNCTION>(client_stream_write_callback_wrapper);
+    conn.add<CURLOPT_WRITEDATA>(this);
+    conn.add<CURLOPT_HEADERFUNCTION>(nullptr);
+    conn.add<CURLOPT_HEADERDATA>(nullptr);
+    conn.add<CURLOPT_XFERINFOFUNCTION>(client_stream_progress_callback_wrapper);
+    conn.add<CURLOPT_XFERINFODATA>(this);
+    conn.add<CURLOPT_NOPROGRESS>(0);
+    //conn.add<CURLOPT_VERBOSE>(1);
+    //conn.add<CURLOPT_DEBUGFUNCTION>(my_trace);
+    conn.add<CURLOPT_URL>(url.c_str());
+    conn.add<CURLOPT_HTTPHEADER>(headers.get());
+    
+    _backoff_type = backoff::none;
+    _backoff_amount = std::chrono::milliseconds(0);
+    for (;;)
+    {
+      bool failure = false;
+      try {
+        conn.perform();
+      } catch (curl::curl_easy_exception error)
+      {
+        failure = true;
+        if ((error.get_code() == CURLE_ABORTED_BY_CALLBACK) && _stop)
+        {
+          break;
+        } else {
+          if (_backoff_type == backoff::none)
+          {
+            _established = false;
+            _backoff_type = backoff::network;
+            _backoff_amount = std::chrono::milliseconds(0);
+          }
+        }
+      }
+      
+      if (!failure)
+      {
+        long response_code = conn.get_info<CURLINFO_RESPONSE_CODE>().get();
+        if (response_code == 420)
+        {
+          if (_backoff_type == backoff::none)
+          {
+            _established = false;
+            _backoff_type = backoff::rate_limit;
+            _backoff_amount = std::chrono::minutes(1);
+          }
+        } else if (response_code != 200)
+        {
+          if (_backoff_type == backoff::none)
+          {
+            _established = false;
+            _backoff_type = backoff::http;
+            _backoff_amount = std::chrono::seconds(5);
+          }
+        } else {
+          break;
+        }
+      }
+      
+      std::this_thread::sleep_for(_backoff_amount);
+
+      switch (_backoff_type)
+      {
+        case backoff::network:
+        {
+          if (_backoff_amount < std::chrono::seconds(16))
+          {
+            _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;
+        }
+      }
+    }
+  }
+  
+  int client::stream::write(char* ptr, size_t size, size_t nmemb)
+  {
+    for (size_t i = 0; i < size*nmemb; i++)
+    {
+      if (ptr[i] == '\r')
+      {
+        i++; // Skip the \n
+        
+        if (!_buffer.empty())
+        {
+          notification n(_buffer, _client._current_user);
+          if (n.getType() == notification::type::friends)
+          {
+            _established = true;
+            _backoff_type = backoff::none;
+            _backoff_amount = std::chrono::milliseconds(0);
+          }
+          
+          {
+            std::lock_guard<std::mutex> _notify_lock(_notify_mutex);
+        
+            if (_notify)
+            {
+              _notify(n);
+            }
+          }
+                    
+          _buffer = "";
+        }
+      } else {
+        _buffer.push_back(ptr[i]);
+      }
+    }
+    
+    {
+      std::lock_guard<std::mutex> _stall_lock(_stall_mutex);
+      time(&_last_write);
+    }
+    
+    return size*nmemb;
+  }
+  
+  int client::stream::progress()
+  {
+    if (_stop)
+    {
+      return 1;
+    }
+    
+    if (_established)
+    {
+      std::lock_guard<std::mutex> _stall_lock(_stall_mutex);
+      if (difftime(time(NULL), _last_write) >= 90)
+      {
+        return 1;
+      }
+    }
+    
+    return 0;
+  }
+  
 };
@@ -7,6 +7,12 @@
 #include <list>
 #include <curl_easy.h>
 #include <curl_header.h>
+#include <thread>
+#include <mutex>
+#include "notification.h"
+#include <set>
+#include <ctime>
+#include <chrono>
 
 namespace OAuth {
   class Consumer;
@@ -18,21 +24,82 @@ namespace twitter {
   
   class client {
     public:
+      class stream {
+        public:
+          typedef std::function<void(notification _notification)> notify_callback;
+          
+          stream(client& _client);
+          
+          void setNotifyCallback(notify_callback _n);
+          
+          bool isRunning() const;
+          void start();
+          void stop();
+          
+        private:
+          enum class backoff {
+            none,
+            network,
+            http,
+            rate_limit
+          };
+          
+          void run();
+          int progress();
+          int write(char* ptr, size_t size, size_t nmemb);
+          
+          friend int client_stream_progress_callback_wrapper(void* stream, curl_off_t, curl_off_t, curl_off_t, curl_off_t);
+          friend size_t client_stream_write_callback_wrapper(void* ptr, size_t size, size_t nmemb, void* stream);
+          
+          client& _client;
+          notify_callback _notify;
+          bool _stop = false;
+          std::thread _thread;
+          std::mutex _running_mutex;
+          std::mutex _notify_mutex;
+          std::mutex _stall_mutex;
+          std::string _buffer;
+          time_t _last_write;
+          bool _established = false;
+          backoff _backoff_type = backoff::none;
+          std::chrono::milliseconds _backoff_amount;
+      };
+      
       client(const auth& _auth);
       ~client();
       
-      response updateStatus(std::string msg, tweet& result, std::list<long> media_ids = {});
+      response updateStatus(std::string msg, tweet& result, tweet in_response_to = tweet(), std::list<long> media_ids = {});
       response uploadMedia(std::string media_type, const char* data, long data_length, long& media_id);
       
+      response follow(user_id toFollow);
+      response follow(user toFollow);
+      
+      response unfollow(user_id toUnfollow);
+      response unfollow(user toUnfollow);
+      
+      response getFriends(std::set<user_id>& result);
+      response getFollowers(std::set<user_id>& result);
+      
+      const user& getUser() const;
+      
+      void setUserStreamNotifyCallback(stream::notify_callback callback);
+      void startUserStream();
+      void stopUserStream();
+      
     private:
+      friend class stream;
+      
       OAuth::Consumer* _oauth_consumer;
       OAuth::Token* _oauth_token;
       OAuth::Client* _oauth_client;
       
-      bool performGet(std::string url, long& response_code, json& result);
-      bool performPost(std::string url, std::string dataStr, long& response_code, json& result);
-      bool performMultiPost(std::string url, const curl_httppost* fields, long& response_code, json& result);
-      response codeForError(int httpcode, json errors) const;
+      user _current_user;
+      stream _user_stream{*this};
+      
+      bool performGet(std::string url, long& response_code, std::string& result);
+      bool performPost(std::string url, std::string dataStr, long& response_code, std::string& result);
+      bool performMultiPost(std::string url, const curl_httppost* fields, long& response_code, std::string& result);
+      response codeForError(int httpcode, std::string errors) const;
   };
   
 };
@@ -0,0 +1,10 @@
+#include "direct_message.h"
+
+namespace twitter {
+  
+  direct_message::direct_message(std::string data)
+  {
+    
+  }
+  
+};
@@ -0,0 +1,15 @@
+#ifndef DIRECT_MESSAGE_H_2B2AE3F8
+#define DIRECT_MESSAGE_H_2B2AE3F8
+
+#include <string>
+
+namespace twitter {
+  
+  class direct_message {
+    public:
+      direct_message(std::string data);
+  };
+  
+};
+
+#endif /* end of include guard: DIRECT_MESSAGE_H_2B2AE3F8 */
@@ -0,0 +1,15 @@
+#include "list.h"
+
+namespace twitter {
+  
+  list::list()
+  {
+    
+  }
+  
+  list::list(std::string data)
+  {
+    
+  }
+  
+};
@@ -0,0 +1,16 @@
+#ifndef LIST_H_D7DEA7D8
+#define LIST_H_D7DEA7D8
+
+#include <string>
+
+namespace twitter {
+  
+  class list {
+    public:
+      list();
+      list(std::string data);
+  };
+  
+};
+
+#endif /* end of include guard: LIST_H_D7DEA7D8 */
@@ -0,0 +1,848 @@
+#include "notification.h"
+#include <cassert>
+#include <new>
+#include <json.hpp>
+
+using nlohmann::json;
+
+namespace twitter {
+  
+  notification::type notification::getType() const
+  {
+    return _type;
+  }
+  
+  notification::notification() : _type(type::invalid)
+  {
+    
+  }
+  
+  notification::notification(std::string data, const user& current_user)
+  {
+    auto _data = json::parse(data);
+    
+    if (_data.find("in_reply_to_status_id") != _data.end())
+    {
+      _type = type::tweet;
+      
+      new(&_tweet) tweet(data);
+    } else if (_data.find("event") != _data.end())
+    {
+      std::string event = _data.at("event");
+      user source(_data.at("source").dump());
+      user target(_data.at("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(_data.at("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(_data.at("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")
+      {
+        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(_data.at("target_object").dump());
+      } else if (event == "list_destroyed")
+      {
+        _type = type::list_destroyed;
+        
+        new(&_list) list(_data.at("target_object").dump());
+      } else if (event == "list_updated")
+      {
+        _type = type::list_updated;
+        
+        new(&_list) list(_data.at("target_object").dump());
+      } else if (event == "list_member_added")
+      {
+        new(&_user_and_list._list) list(_data.at("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(_data.at("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(_data.at("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(_data.at("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(_data.at("target_object").dump());
+      }
+    } else if (_data.find("warning") != _data.end())
+    {
+      new(&_warning) std::string(_data.at("warning").at("message").get<std::string>());
+      
+      if (_data.at("warning").at("code") == "FALLING_BEHIND")
+      {
+        _type = type::stall;
+      } else if (_data.at("warning").at("code") == "FOLLOWS_OVER_LIMIT")
+      {
+        _type = type::follow_limit;
+      } else {
+        _type = type::unknown_warning;
+      }
+    } else if (_data.find("delete") != _data.end())
+    {
+      _type = type::deletion;
+      
+      _user_id_and_tweet_id._tweet_id = _data.at("delete").at("status").at("id");
+      _user_id_and_tweet_id._user_id = _data.at("delete").at("status").at("user_id");
+    } else if (_data.find("scrub_geo") != _data.end())
+    {
+      _type = type::scrub_location;
+      
+      _user_id_and_tweet_id._tweet_id = _data.at("scrub_geo").at("up_to_status_id");
+      _user_id_and_tweet_id._user_id = _data.at("scrub_geo").at("user_id");
+    } else if (_data.find("limit") != _data.end())
+    {
+      _type = type::limit;
+      
+      _limit = _data.at("limit").at("track");
+    } else if (_data.find("status_withheld") != _data.end())
+    {
+      _type = type::withhold_status;
+      
+      _withhold_status._user_id = _data.at("status_withheld").at("user_id");
+      _withhold_status._tweet_id = _data.at("status_withheld").at("id");
+      
+      new(&_withhold_status._countries) std::vector<std::string>();
+      for (auto s : _data.at("status_withheld").at("withheld_in_countries"))
+      {
+        _withhold_status._countries.push_back(s);
+      }
+    } else if (_data.find("user_withheld") != _data.end())
+    {
+      _type = type::withhold_user;
+      
+      _withhold_user._user_id = _data.at("user_withheld").at("id");
+      
+      new(&_withhold_user._countries) std::vector<std::string>();
+      for (auto s : _data.at("user_withheld").at("withheld_in_countries"))
+      {
+        _withhold_user._countries.push_back(s);
+      }
+    } else if (_data.find("disconnect") != _data.end())
+    {
+      _type = type::disconnect;
+      
+      switch (_data.at("disconnect").at("code").get<int>())
+      {
+        case 1: _disconnect = disconnect_code::shutdown; break;
+        case 2: _disconnect = disconnect_code::duplicate; break;
+        case 4: _disconnect = disconnect_code::stall; break;
+        case 5: _disconnect = disconnect_code::normal; break;
+        case 6: _disconnect = disconnect_code::token_revoked; break;
+        case 7: _disconnect = disconnect_code::admin_logout; break;
+        case 9: _disconnect = disconnect_code::limit; break;
+        case 10: _disconnect = disconnect_code::exception; break;
+        case 11: _disconnect = disconnect_code::broker; break;
+        case 12: _disconnect = disconnect_code::load; break;
+        default: _disconnect = disconnect_code::unknown;
+      }
+    } else if (_data.find("friends") != _data.end())
+    {
+      _type = type::friends;
+      
+      new(&_friends) std::set<user_id>(_data.at("friends").begin(), _data.at("friends").end());
+    } else if (_data.find("direct_message") != _data.end())
+    {
+      _type = type::direct;
+      
+      new(&_direct_message) direct_message(_data.at("direct_message").dump());
+    } else {
+      _type = type::unknown;
+    }
+  }
+  
+  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:
+      case type::follow:
+      case type::followed:
+      case type::unfollow:
+      {
+        new(&_user) user(other._user);
+        
+        break;
+      }
+      
+      case type::favorite:
+      case type::favorited:
+      case type::unfavorite:
+      case type::unfavorited:
+      case type::quoted:
+      {
+        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:
+      case type::list_removed:
+      case type::list_subscribe:
+      case type::list_subscribed:
+      case type::list_unsubscribe:
+      case type::list_unsubscribed:
+      {
+        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;
+      }
+    }
+  }
+  
+  notification& notification::operator=(const notification& other)
+  {
+    this->~notification();
+    
+    _type = other._type;
+    
+    switch (_type)
+    {
+      case type::tweet:
+      {
+        new(&_tweet) tweet(other._tweet);
+        
+        break;
+      }
+      
+      case type::update_user:
+      case type::block:
+      case type::unblock:
+      case type::follow:
+      case type::followed:
+      case type::unfollow:
+      {
+        new(&_user) user(other._user);
+        
+        break;
+      }
+      
+      case type::favorite:
+      case type::favorited:
+      case type::unfavorite:
+      case type::unfavorited:
+      case type::quoted:
+      {
+        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:
+      case type::list_removed:
+      case type::list_subscribe:
+      case type::list_subscribed:
+      case type::list_unsubscribe:
+      case type::list_unsubscribed:
+      {
+        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;
+      }
+    }
+    
+    return *this;
+  }
+  
+  notification::~notification()
+  {
+    switch (_type)
+    {
+      case type::tweet:
+      {
+        _tweet.~tweet();
+        
+        break;
+      }
+      
+      case type::update_user:
+      case type::block:
+      case type::unblock:
+      case type::follow:
+      case type::followed:
+      case type::unfollow:
+      {
+        _user.~user();
+        
+        break;
+      }
+      
+      case type::favorite:
+      case type::favorited:
+      case type::unfavorite:
+      case type::unfavorited:
+      case type::quoted:
+      {
+        _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:
+      case type::list_removed:
+      case type::list_subscribe:
+      case type::list_subscribed:
+      case type::list_unsubscribe:
+      case type::list_unsubscribed:
+      {
+        _user_and_list._user.~user();
+        _user_and_list._list.~list();
+        
+        break;
+      }
+      
+      case type::stall:
+      case type::follow_limit:
+      {
+        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;
+      }
+    }
+  }
+  
+  tweet notification::getTweet() const
+  {
+    switch (_type)
+    {
+      case type::tweet:
+      {
+        return _tweet;
+      }
+      
+      case type::favorite:
+      case type::favorited:
+      case type::unfavorite:
+      case type::unfavorited:
+      case type::quoted:
+      {
+        return _user_and_tweet._tweet;
+      }
+      
+      default:
+      {
+        assert(false);
+        
+        return tweet();
+      }
+    }
+  }
+  
+  user notification::getUser() const
+  {
+    switch (_type)
+    {
+      case type::update_user:
+      case type::block:
+      case type::unblock:
+      case type::follow:
+      case type::followed:
+      case type::unfollow:
+      {
+        return _user;
+      }
+      
+      case type::favorite:
+      case type::favorited:
+      case type::unfavorite:
+      case type::unfavorited:
+      case type::quoted:
+      {
+        return _user_and_tweet._user;
+      }
+      
+      case type::list_add:
+      case type::list_added:
+      case type::list_remove:
+      case type::list_removed:
+      case type::list_subscribe:
+      case type::list_subscribed:
+      case type::list_unsubscribe:
+      case type::list_unsubscribed:
+      {
+        return _user_and_list._user;
+      }
+      
+      default:
+      {
+        assert(false);
+        
+        return user();
+      }
+    }
+  }
+  
+  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:
+      case type::list_removed:
+      case type::list_subscribe:
+      case type::list_subscribed:
+      case type::list_unsubscribe:
+      case type::list_unsubscribed:
+      {
+        return _user_and_list._list;
+      }
+      
+      default:
+      {
+        assert(false);
+        
+        return list();
+      }
+    }
+  }
+  
+  tweet_id notification::getTweetID() const
+  {
+    switch (_type)
+    {
+      case type::deletion:
+      case type::scrub_location:
+      {
+        return _user_id_and_tweet_id._tweet_id;
+      }
+      
+      case type::withhold_status:
+      {
+        return _withhold_status._tweet_id;
+      }
+      
+      default:
+      {
+        assert(false);
+        
+        return 0;
+      }
+    }
+  }
+  
+  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;
+      }
+
+      default:
+      {
+        assert(false);
+        
+        return 0;
+      }
+    }
+  }
+  
+  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;
+      }
+
+      default:
+      {
+        assert(false);
+        
+        return std::vector<std::string>();
+      }
+    }
+  }
+  
+  disconnect_code notification::getDisconnectCode() const
+  {
+    assert(_type == type::disconnect);
+    
+    return _disconnect;
+  }
+  
+  std::set<user_id> notification::getFriends() const
+  {
+    assert(_type == type::friends);
+    
+    return _friends;
+  }
+  
+  direct_message notification::getDirectMessage() const
+  {
+    assert(_type == type::direct);
+    
+    return _direct_message;
+  }
+  
+  int notification::getLimit() const
+  {
+    assert(_type == type::limit);
+    
+    return _limit;
+  }
+  
+  std::string notification::getWarning() const
+  {
+    switch (_type)
+    {
+      case type::stall:
+      case type::follow_limit:
+      case type::unknown_warning:
+      {
+        return _warning;
+      }
+      
+      default:
+      {
+        assert(false);
+        
+        return "";
+      }
+    }
+  }
+  
+  notification::operator bool() const
+  {
+    return _type != type::invalid;
+  }
+  
+};
@@ -0,0 +1,145 @@
+#ifndef NOTIFICATION_H_69AEF4CC
+#define NOTIFICATION_H_69AEF4CC
+
+#include <string>
+#include <vector>
+#include <set>
+#include "tweet.h"
+#include "user.h"
+#include "list.h"
+#include "direct_message.h"
+
+namespace twitter {
+  
+  enum class disconnect_code {
+    shutdown,
+    duplicate,
+    stall,
+    normal,
+    token_revoked,
+    admin_logout,
+    limit,
+    exception,
+    broker,
+    load,
+    unknown
+  };
+  
+  class notification {
+    public:
+      enum class type {
+        // Tweet object
+        tweet,
+        
+        // User object
+        update_user,
+        block,
+        unblock,
+        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,
+        list_remove,
+        list_removed,
+        list_subscribe,
+        list_subscribed,
+        list_unsubscribe,
+        list_unsubscribed,
+        
+        // Warning
+        stall,
+        follow_limit,
+        unknown_warning,
+        
+        // User ID and tweet ID
+        deletion,
+        scrub_location,
+        
+        // Special
+        limit,
+        withhold_status,
+        withhold_user,
+        disconnect,
+        friends,
+        direct,
+        
+        // Nothing
+        unknown,
+        invalid
+      };
+      
+      type getType() const;
+      
+      notification();
+      notification(std::string data, const user& current_user);
+      notification(const notification& other);
+      notification& operator=(const notification& other);
+      ~notification();
+      
+      tweet getTweet() const;
+      user getUser() const;
+      list getList() const;
+      tweet_id getTweetID() const;
+      user_id getUserID() const;
+      std::vector<std::string> getCountries() const;
+      disconnect_code getDisconnectCode() const;
+      std::set<user_id> getFriends() const;
+      direct_message getDirectMessage() const;
+      int getLimit() const;
+      std::string getWarning() const;
+      
+      operator bool() const;
+      
+    private:
+      union {
+        tweet _tweet;
+        user _user;
+        list _list;
+        struct {
+          user _user;
+          tweet _tweet;
+        } _user_and_tweet;
+        struct {
+          user _user;
+          list _list;
+        } _user_and_list;
+        std::string _warning;
+        struct {
+          user_id _user_id;
+          tweet_id _tweet_id;
+        } _user_id_and_tweet_id;
+        int _limit;
+        struct {
+          user_id _user_id;
+          tweet_id _tweet_id;
+          std::vector<std::string> _countries;
+        } _withhold_status;
+        struct {
+          user_id _user_id;
+          std::vector<std::string> _countries;
+        } _withhold_user;
+        disconnect_code _disconnect;
+        std::set<user_id> _friends;
+        direct_message _direct_message;
+      };
+      type _type;
+  };
+  
+};
+
+#endif /* end of include guard: NOTIFICATION_H_69AEF4CC */
@@ -1,15 +1,41 @@
 #include "tweet.h"
+#include <json.hpp>
+
+using nlohmann::json;
 
 namespace twitter {
   
-  tweet::tweet()
+  tweet::tweet() : _valid(false)
+  {
+    
+  }
+  
+  tweet::tweet(std::string data) : _valid(true)
+  {
+    auto _data = json::parse(data);
+    _id = _data.at("id");
+    _text = _data.at("text");
+    _author = user(_data.at("user").dump());
+  }
+  
+  tweet_id tweet::getID() const
+  {
+    return _id;
+  }
+  
+  std::string tweet::getText() const
+  {
+    return _text;
+  }
+  
+  const user& tweet::getAuthor() const
   {
-    _valid = false;
+    return _author;
   }
   
-  tweet::tweet(const json& data)
+  tweet::operator bool() const
   {
-    _valid = true;
+    return _valid;
   }
   
 };
@@ -1,19 +1,29 @@
 #ifndef TWEET_H_CE980721
 #define TWEET_H_CE980721
 
-#include <json.hpp>
-
-using nlohmann::json;
+#include <string>
+#include "user.h"
 
 namespace twitter {
   
+  typedef unsigned long long tweet_id;
+  
   class tweet {
     public:
       tweet();
-      tweet(const json& _data);
+      tweet(std::string data);
+      
+      tweet_id getID() const;
+      std::string getText() const;
+      const user& getAuthor() const;
+      
+      operator bool() const;
       
     private:
       bool _valid;
+      tweet_id _id;
+      std::string _text;
+      user _author;
   };
   
 };
@@ -12,5 +12,9 @@ namespace twitter {
 #include "auth.h"
 #include "client.h"
 #include "tweet.h"
+#include "user.h"
+#include "notification.h"
+#include "list.h"
+#include "direct_message.h"
 
 #endif /* end of include guard: TWITTER_H_AC7A7666 */
@@ -0,0 +1,46 @@
+#include "user.h"
+#include <json.hpp>
+
+using nlohmann::json;
+
+namespace twitter {
+  
+  user::user() : _valid(false)
+  {
+    
+  }
+  
+  user::user(std::string data) : _valid(true)
+  {
+    auto _data = json::parse(data);
+    _id = _data.at("id");
+    _screen_name = _data.at("screen_name");
+    _name = _data.at("name");
+  }
+  
+  user_id user::getID() const
+  {
+    return _id;
+  }
+  
+  std::string user::getScreenName() const
+  {
+    return _screen_name;
+  }
+  
+  std::string user::getName() const
+  {
+    return _name;
+  }
+  
+  user::operator bool() const
+  {
+    return _valid;
+  }
+  
+  bool user::operator==(const user& other) const
+  {
+    return _id == other._id;
+  }
+
+};
@@ -0,0 +1,31 @@
+#ifndef USER_H_BF3AB38C
+#define USER_H_BF3AB38C
+
+#include <string>
+
+namespace twitter {
+  
+  typedef unsigned long long user_id;
+  
+  class user {
+    public:
+      user();
+      user(std::string data);
+      
+      user_id getID() const;
+      std::string getScreenName() const;
+      std::string getName() const;
+      
+      operator bool() const;
+      bool operator==(const user& other) const;
+      
+    private:
+      bool _valid = false;
+      user_id _id;
+      std::string _screen_name;
+      std::string _name;
+  };
+  
+};
+
+#endif /* end of include guard: USER_H_BF3AB38C */