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