Removed stream functionality

The Twitter streaming API has officially sunset, so the stream functionality can no longer be used. Because of this, there is no need to keep it in the codebase.

refs #3

6 files changed, 0 insertions, 1774 deletions

@@ -14,10 +14,8 @@ 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
@@ -1,1212 +0,0 @@
-#include "notification.h"
-#include <cassert>
-#include <new>
-#include <json.hpp>
-#include "codes.h"
-#include "client.h"
-
-namespace twitter {
-
-  notification::type notification::getType() const
-  {
-    return _type;
-  }
-
-  notification::notification(const user& current_user, std::string data)
-  {
-    nlohmann::json json;
-
-    try
-    {
-      json = nlohmann::json::parse(data);
-    } catch (const std::invalid_argument& error)
-    {
-      std::throw_with_nested(invalid_response(data));
-    }
-
-    try
-    {
-      if (!json["event"].is_null())
-      {
-        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")
-        {
-          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 {
-          _type = type::unknown;
-        }
-      } 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")
-        {
-          _type = type::stall;
-        } else if (warning_code == "FOLLOWS_OVER_LIMIT")
-        {
-          _type = type::follow_limit;
-        } else {
-          _type = type::unknown_warning;
-        }
-      } 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"])
-        {
-          _withhold_status._countries.push_back(s);
-        }
-      } 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"])
-        {
-          _withhold_user._countries.push_back(s);
-        }
-      } else if (!json["disconnect"].is_null())
-      {
-        _type = type::disconnect;
-
-        switch (json["disconnect"]["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 (!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)
-    {
-      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:
-      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;
-      }
-
-      case type::unknown:
-      case type::invalid:
-      {
-        break;
-      }
-    }
-  }
-
-  notification::notification(notification&& other) : notification()
-  {
-    swap(*this, other);
-  }
-
-  notification& notification::operator=(notification other)
-  {
-    swap(*this, other);
-
-    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:
-      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:
-      case type::disconnect:
-      case type::unknown:
-      case type::invalid:
-      {
-        break;
-      }
-    }
-  }
-
-  void swap(notification& first, notification& second)
-  {
-    using type = notification::type;
-
-    type tempType = first._type;
-    tweet tempTweet;
-    user tempUser;
-    list tempList;
-    std::string tempWarning;
-    user_id tempUserId;
-    tweet_id tempTweetId;
-    int tempLimit;
-    std::vector<std::string> tempCountries;
-    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:
-      case type::follow:
-      case type::followed:
-      case type::unfollow:
-      {
-        tempUser = std::move(first._user);
-
-        break;
-      }
-
-      case type::favorite:
-      case type::favorited:
-      case type::unfavorite:
-      case type::unfavorited:
-      case type::quoted:
-      {
-        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:
-      case type::list_removed:
-      case type::list_subscribe:
-      case type::list_subscribed:
-      case type::list_unsubscribe:
-      case type::list_unsubscribed:
-      {
-        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:
-      case type::follow:
-      case type::followed:
-      case type::unfollow:
-      {
-        new(&first._user) user(std::move(second._user));
-
-        break;
-      }
-
-      case type::favorite:
-      case type::favorited:
-      case type::unfavorite:
-      case type::unfavorited:
-      case type::quoted:
-      {
-        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:
-      case type::list_removed:
-      case type::list_subscribe:
-      case type::list_subscribed:
-      case type::list_unsubscribe:
-      case type::list_unsubscribed:
-      {
-        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:
-      case type::follow:
-      case type::followed:
-      case type::unfollow:
-      {
-        new(&second._user) user(std::move(tempUser));
-
-        break;
-      }
-
-      case type::favorite:
-      case type::favorited:
-      case type::unfavorite:
-      case type::unfavorited:
-      case type::quoted:
-      {
-        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:
-      case type::list_removed:
-      case type::list_subscribe:
-      case type::list_subscribed:
-      case type::list_unsubscribe:
-      case type::list_unsubscribed:
-      {
-        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:
-      {
-        break;
-      }
-    }
-  }
-
-  const 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);
-      }
-    }
-  }
-
-  const 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);
-      }
-    }
-  }
-
-  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:
-      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);
-      }
-    }
-  }
-
-  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);
-      }
-    }
-  }
-
-  void notification::setTweetID(tweet_id _arg)
-  {
-    switch (_type)
-    {
-      case type::deletion:
-      case type::scrub_location:
-      {
-        _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;
-      }
-
-      default:
-      {
-        assert(false);
-      }
-    }
-  }
-
-  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;
-      }
-
-      default:
-      {
-        assert(false);
-      }
-    }
-  }
-
-  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;
-      }
-
-      default:
-      {
-        assert(false);
-      }
-    }
-  }
-
-  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)
-    {
-      case type::stall:
-      case type::follow_limit:
-      case type::unknown_warning:
-      {
-        return _warning;
-      }
-
-      default:
-      {
-        assert(false);
-      }
-    }
-  }
-
-};
@@ -1,192 +0,0 @@
-#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 {
-
-  class client;
-
-  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(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;
-      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 = type::invalid;
-  };
-
-};
-
-#endif /* end of include guard: NOTIFICATION_H_69AEF4CC */
@@ -1,295 +0,0 @@
-#include "stream.h"
-#include <liboauthcpp/liboauthcpp.h>
-#include <curl_easy.h>
-#include <curl_header.h>
-#include "util.h"
-#include "notification.h"
-#include "request.h"
-
-namespace twitter {
-
-  stream::stream(
-    const auth& tauth,
-    notify_callback callback,
-    bool with_followings,
-    bool receive_all_replies,
-    std::list<std::string> track,
-    std::list<bounding_box> locations) :
-      _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())
-    {
-      _stop = true;
-      _thread.join();
-    }
-  }
-
-  std::string stream::generateUrl(
-    bool with_followings,
-    bool receive_all_replies,
-    std::list<std::string> track,
-    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;
-    _backoff_amount = std::chrono::milliseconds(0);
-    for (;;)
-    {
-      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 = _auth.getClient().getFormattedHttpHeader(OAuth::Http::Get, url, "");
-
-        if (!oauth_header.empty())
-        {
-          headers.add(oauth_header);
-        }
-      } 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);
-      }
-
-      try
-      {
-        conn.add<CURLOPT_HEADERFUNCTION>(nullptr);
-        conn.add<CURLOPT_HEADERDATA>(nullptr);
-        conn.add<CURLOPT_XFERINFOFUNCTION>([] (void* cdata, curl_off_t, curl_off_t, curl_off_t, curl_off_t) {
-          return static_cast<stream*>(cdata)->progress();
-        });
-        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());
-      } catch (const curl::curl_exception& error)
-      {
-        error.print_traceback();
-
-        assert(false);
-      }
-
-      bool failure = false;
-      try
-      {
-        conn.perform();
-      } catch (const 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 {
-          if (_backoff_type == backoff::none)
-          {
-            _established = false;
-            _backoff_type = backoff::network;
-            _backoff_amount = std::chrono::milliseconds(0);
-          }
-        }
-      }
-
-      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;
-        }
-
-        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++)
-    {
-      if (ptr[i] == '\r')
-      {
-        i++; // Skip the \n
-
-        if (!_buffer.empty())
-        {
-          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)
-      {
-        return 1;
-      }
-    }
-
-    return 0;
-  }
-
-}
@@ -1,71 +0,0 @@
-#ifndef STREAM_H_E9146952
-#define STREAM_H_E9146952
-
-#include <functional>
-#include <list>
-#include <string>
-#include <chrono>
-#include <thread>
-#include "bounding_box.h"
-#include "auth.h"
-#include "user.h"
-
-namespace twitter {
-
-  class notification;
-
-  class
-  [[deprecated("The Twitter streaming API will sunset on August 16th, 2018")]]
-  stream {
-  public:
-
-    typedef std::function<void(notification _notification)> notify_callback;
-
-    stream(
-      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,
-      network,
-      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 auth& _auth;
-    notify_callback _notify;
-    bool _stop = false;
-    std::string _buffer;
-    time_t _last_write;
-    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 */
@@ -12,10 +12,8 @@ namespace twitter {
 #include "auth.h"
 #include "client.h"
 #include "timeline.h"
-#include "stream.h"
 #include "tweet.h"
 #include "user.h"
-#include "notification.h"
 #include "list.h"
 #include "direct_message.h"
 #include "configuration.h"