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

1 files changed, 0 insertions, 1212 deletions

@@ -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);
-      }
-    }
-  }
-
-};