Made tweets, users, and notifications into copyable objects

Notifications are now also mutable. Users and tweets no longer have helper methods for interacting with the client. Fixed a bug (possibly introduced by a change to the Twitter API) that caused non-reply tweets to be marked as unknown notifications.

12 files changed, 610 insertions, 151 deletions

@@ -330,7 +330,7 @@ namespace twitter {
         _oauth_token.get());
     
     _current_user =
-      make_unique<user>(*this,
+      make_unique<user>(
         get(*_oauth_client,
           "https://api.twitter.com/1.1/account/verify_credentials.json")
         .perform());
@@ -349,7 +349,7 @@ namespace twitter {
       datastrstream << twitter::implode(std::begin(media_ids), std::end(media_ids), ",");
     }
     
-    return tweet(*this,
+    return tweet(
       post(*_oauth_client,
         "https://api.twitter.com/1.1/statuses/update.json",
         datastrstream.str())
@@ -369,7 +369,7 @@ namespace twitter {
       datastrstream << twitter::implode(std::begin(media_ids), std::end(media_ids), ",");
     }
     
-    return tweet(*this,
+    return tweet(
       post(*_oauth_client,
         "https://api.twitter.com/1.1/statuses/update.json",
         datastrstream.str())
@@ -533,6 +533,16 @@ namespace twitter {
     return result;
   }
   
+  std::set<user_id> client::getFriends(const user& id) const
+  {
+    return getFriends(id.getID());
+  }
+  
+  std::set<user_id> client::getFriends() const
+  {
+    return getFriends(getUser().getID());
+  }
+  
   std::set<user_id> client::getFollowers(user_id id) const
   {
     long long cursor = -1;
@@ -567,6 +577,16 @@ namespace twitter {
     return result;
   }
   
+  std::set<user_id> client::getFollowers(const user& id) const
+  {
+    return getFollowers(id.getID());
+  }
+  
+  std::set<user_id> client::getFollowers() const
+  {
+    return getFollowers(getUser().getID());
+  }
+  
   void client::follow(user_id toFollow) const
   {
     std::stringstream datastrstream;
@@ -576,6 +596,11 @@ namespace twitter {
     post(*_oauth_client, "https://api.twitter.com/1.1/friendships/create.json", datastrstream.str()).perform();
   }
   
+  void client::follow(const user& toFollow) const
+  {
+    return follow(toFollow.getID());
+  }
+  
   void client::unfollow(user_id toUnfollow) const
   {
     std::stringstream datastrstream;
@@ -584,6 +609,11 @@ namespace twitter {
     
     post(*_oauth_client, "https://api.twitter.com/1.1/friendships/destroy.json", datastrstream.str()).perform();
   }
+  
+  void client::unfollow(const user& toUnfollow) const
+  {
+    return unfollow(toUnfollow.getID());
+  }
 
   const user& client::getUser() const
   {
@@ -29,10 +29,20 @@ namespace twitter {
     long uploadMedia(std::string media_type, const char* data, long data_length) const;
     
     tweet replyToTweet(std::string msg, tweet_id in_response_to, std::list<long> media_ids = {}) const;
+    
     std::set<user_id> getFriends(user_id id) const;
+    std::set<user_id> getFriends(const user& u) const;
+    std::set<user_id> getFriends() const;
+    
     std::set<user_id> getFollowers(user_id id) const;
+    std::set<user_id> getFollowers(const user& u) const;
+    std::set<user_id> getFollowers() const;
+    
     void follow(user_id toFollow) const;
+    void follow(const user& toFollow) const;
+    
     void unfollow(user_id toUnfollow) const;
+    void unfollow(const user& toUnfollow) const;
     
     const user& getUser() const;
     
@@ -8,6 +8,7 @@ namespace twitter {
   class direct_message {
   public:
     
+    direct_message() {}
     explicit direct_message(std::string data);
   };
   
@@ -8,7 +8,9 @@ namespace twitter {
   class list {
   public:
     
+    list() {}
     explicit list(std::string data);
+
   };
   
 };
@@ -28,16 +28,11 @@ namespace twitter {
     
     try
     {
-      if (!json["in_reply_to_status_id"].is_null())
-      {
-        _type = type::tweet;
-      
-        new(&_tweet) tweet(tclient, data);
-      } else if (!json["event"].is_null())
+      if (!json["event"].is_null())
       {
         std::string event = json["event"];
-        user source(tclient, json["source"].dump());
-        user target(tclient, json["target"].dump());
+        user source(json["source"].dump());
+        user target(json["target"].dump());
       
         if (event == "user_update")
         {
@@ -56,7 +51,7 @@ namespace twitter {
           new(&_user) user(target);
         } else if (event == "favorite")
         {
-          new(&_user_and_tweet._tweet) tweet(tclient, json["target_object"].dump());
+          new(&_user_and_tweet._tweet) tweet(json["target_object"].dump());
         
           if (current_user == source)
           {
@@ -70,7 +65,7 @@ namespace twitter {
           }
         } else if (event == "unfavorite")
         {
-          new(&_user_and_tweet._tweet) tweet(tclient, json["target_object"].dump());
+          new(&_user_and_tweet._tweet) tweet(json["target_object"].dump());
         
           if (current_user == source)
           {
@@ -175,7 +170,9 @@ namespace twitter {
           _type = type::quoted;
         
           new(&_user_and_tweet._user) user(source);
-          new(&_user_and_tweet._tweet) tweet(tclient, json["target_object"].dump());
+          new(&_user_and_tweet._tweet) tweet(json["target_object"].dump());
+        } else {
+          _type = type::unknown;
         }
       } else if (!json["warning"].is_null())
       {
@@ -260,7 +257,9 @@ namespace twitter {
       
         new(&_direct_message) direct_message(json["direct_message"].dump());
       } else {
-        _type = type::unknown;
+        _type = type::tweet;
+      
+        new(&_tweet) tweet(data);
       }
     } catch (const std::domain_error& error)
     {
@@ -268,7 +267,7 @@ namespace twitter {
     }
   }
   
-  notification::notification(notification&& other)
+  notification::notification(const notification& other)
   {
     _type = other._type;
     
@@ -276,7 +275,7 @@ namespace twitter {
     {
       case type::tweet:
       {
-        new(&_tweet) tweet(std::move(other._tweet));
+        new(&_tweet) tweet(other._tweet);
       
         break;
       }
@@ -288,7 +287,7 @@ namespace twitter {
       case type::followed:
       case type::unfollow:
       {
-        new(&_user) user(std::move(other._user));
+        new(&_user) user(other._user);
       
         break;
       }
@@ -299,8 +298,8 @@ namespace twitter {
       case type::unfavorited:
       case type::quoted:
       {
-        new(&_user_and_tweet._user) user(std::move(other._user_and_tweet._user));
-        new(&_user_and_tweet._tweet) tweet(std::move(other._user_and_tweet._tweet));
+        new(&_user_and_tweet._user) user(other._user_and_tweet._user);
+        new(&_user_and_tweet._tweet) tweet(other._user_and_tweet._tweet);
       
         break;
       }
@@ -309,7 +308,7 @@ namespace twitter {
       case type::list_destroyed:
       case type::list_updated:
       {
-        new(&_list) list(std::move(other._list));
+        new(&_list) list(other._list);
       
         break;
       }
@@ -323,8 +322,8 @@ namespace twitter {
       case type::list_unsubscribe:
       case type::list_unsubscribed:
       {
-        new(&_user_and_list._user) user(std::move(other._user_and_list._user));
-        new(&_user_and_list._list) list(std::move(other._user_and_list._list));
+        new(&_user_and_list._user) user(other._user_and_list._user);
+        new(&_user_and_list._list) list(other._user_and_list._list);
       
         break;
       }
@@ -333,7 +332,7 @@ namespace twitter {
       case type::follow_limit:
       case type::unknown_warning:
       {
-        new(&_warning) std::string(std::move(other._warning));
+        new(&_warning) std::string(other._warning);
       
         break;
       }
@@ -358,7 +357,7 @@ namespace twitter {
       {
         _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>(std::move(other._withhold_status._countries));
+        new(&_withhold_status._countries) std::vector<std::string>(other._withhold_status._countries);
       
         break;
       }
@@ -366,7 +365,7 @@ namespace twitter {
       case type::withhold_user:
       {
         _withhold_user._user_id = other._withhold_user._user_id;
-        new(&_withhold_user._countries) std::vector<std::string>(std::move(other._withhold_user._countries));
+        new(&_withhold_user._countries) std::vector<std::string>(other._withhold_user._countries);
       
         break;
       }
@@ -380,14 +379,14 @@ namespace twitter {
     
       case type::friends:
       {
-        new(&_friends) std::set<user_id>(std::move(other._friends));
+        new(&_friends) std::set<user_id>(other._friends);
       
         break;
       }
     
       case type::direct:
       {
-        new(&_direct_message) direct_message(std::move(other._direct_message));
+        new(&_direct_message) direct_message(other._direct_message);
       
         break;
       }
@@ -400,17 +399,25 @@ namespace twitter {
     }
   }
   
-  notification& notification::operator=(notification&& other)
+  notification::notification(notification&& other) : notification()
   {
-    this->~notification();
-    
-    _type = other._type;
+    swap(*this, other);
+  }
+  
+  notification& notification::operator=(notification other)
+  {
+    swap(*this, other);
     
+    return *this;
+  }
+  
+  notification::~notification()
+  {
     switch (_type)
     {
       case type::tweet:
       {
-        new(&_tweet) tweet(std::move(other._tweet));
+        _tweet.~tweet();
         
         break;
       }
@@ -422,7 +429,7 @@ namespace twitter {
       case type::followed:
       case type::unfollow:
       {
-        new(&_user) user(std::move(other._user));
+        _user.~user();
         
         break;
       }
@@ -433,8 +440,8 @@ namespace twitter {
       case type::unfavorited:
       case type::quoted:
       {
-        new(&_user_and_tweet._user) user(std::move(other._user_and_tweet._user));
-        new(&_user_and_tweet._tweet) tweet(std::move(other._user_and_tweet._tweet));
+        _user_and_tweet._user.~user();
+        _user_and_tweet._tweet.~tweet();
         
         break;
       }
@@ -443,7 +450,7 @@ namespace twitter {
       case type::list_destroyed:
       case type::list_updated:
       {
-        new(&_list) list(std::move(other._list));
+        _list.~list();
         
         break;
       }
@@ -457,8 +464,8 @@ namespace twitter {
       case type::list_unsubscribe:
       case type::list_unsubscribed:
       {
-        new(&_user_and_list._user) user(std::move(other._user_and_list._user));
-        new(&_user_and_list._list) list(std::move(other._user_and_list._list));
+        _user_and_list._user.~user();
+        _user_and_list._list.~list();
         
         break;
       }
@@ -467,65 +474,192 @@ namespace twitter {
       case type::follow_limit:
       case type::unknown_warning:
       {
-        new(&_warning) std::string(std::move(other._warning));
+        using string_type = std::string;
+        _warning.~string_type();
         
         break;
       }
       
-      case type::deletion:
-      case type::scrub_location:
+      case type::withhold_status:
       {
-        _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;
-        
+        using list_type = std::vector<std::string>;
+        _withhold_status._countries.~list_type();
+                
         break;
       }
       
-      case type::limit:
+      case type::withhold_user:
       {
-        _limit = other._limit;
+        using list_type = std::vector<std::string>;
+        _withhold_user._countries.~list_type();
         
         break;
       }
-      
-      case type::withhold_status:
+            
+      case type::friends:
       {
-        _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>(std::move(other._withhold_status._countries));
+        using list_type = std::set<user_id>;
+        _friends.~list_type();
         
         break;
       }
       
-      case type::withhold_user:
+      case type::direct:
       {
-        _withhold_user._user_id = other._withhold_user._user_id;
-        new(&_withhold_user._countries) std::vector<std::string>(std::move(other._withhold_user._countries));
+        _direct_message.~direct_message();
         
         break;
       }
       
+      case type::deletion:
+      case type::scrub_location:
+      case type::limit:
       case type::disconnect:
+      case type::unknown:
+      case type::invalid:
       {
-        _disconnect = other._disconnect;
+        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::friends:
+      case type::update_user:
+      case type::block:
+      case type::unblock:
+      case type::follow:
+      case type::followed:
+      case type::unfollow:
       {
-        new(&_friends) std::set<user_id>(std::move(other._friends));
-        
+        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);
       
-      case type::direct:
+        break;
+      }
+    
+      case type::list_created:
+      case type::list_destroyed:
+      case type::list_updated:
       {
-        new(&_direct_message) direct_message(std::move(other._direct_message));
-        
+        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:
       {
@@ -533,16 +667,19 @@ namespace twitter {
       }
     }
     
-    return *this;
-  }
-  
-  notification::~notification()
-  {
-    switch (_type)
+    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:
       {
-        _tweet.~tweet();
+        new(&first._tweet) tweet(std::move(second._tweet));
         
         break;
       }
@@ -554,7 +691,7 @@ namespace twitter {
       case type::followed:
       case type::unfollow:
       {
-        _user.~user();
+        new(&first._user) user(std::move(second._user));
         
         break;
       }
@@ -565,8 +702,8 @@ namespace twitter {
       case type::unfavorited:
       case type::quoted:
       {
-        _user_and_tweet._user.~user();
-        _user_and_tweet._tweet.~tweet();
+        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;
       }
@@ -575,7 +712,7 @@ namespace twitter {
       case type::list_destroyed:
       case type::list_updated:
       {
-        _list.~list();
+        new(&first._list) list(std::move(second._list));
         
         break;
       }
@@ -589,8 +726,8 @@ namespace twitter {
       case type::list_unsubscribe:
       case type::list_unsubscribed:
       {
-        _user_and_list._user.~user();
-        _user_and_list._list.~list();
+        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;
       }
@@ -599,49 +736,199 @@ namespace twitter {
       case type::follow_limit:
       case type::unknown_warning:
       {
-        using string_type = std::string;
-        _warning.~string_type();
+        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:
       {
-        using list_type = std::vector<std::string>;
-        _withhold_status._countries.~list_type();
-                
+        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:
       {
-        using list_type = std::vector<std::string>;
-        _withhold_user._countries.~list_type();
+        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:
       {
-        using list_type = std::set<user_id>;
-        _friends.~list_type();
+        new(&first._friends) std::set<user_id>(std::move(second._friends));
         
         break;
       }
       
       case type::direct:
       {
-        _direct_message.~direct_message();
+        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:
-      case type::unknown:
+      {
+        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;
       }
@@ -767,6 +1054,28 @@ namespace twitter {
     }
   }
   
+  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)
@@ -794,6 +1103,33 @@ namespace twitter {
     }
   }
   
+  void notification::setUserID(user_id _arg)
+  {
+    switch (_type)
+    {      
+      case type::deletion:
+      case type::scrub_location:
+      {
+        _user_id_and_tweet_id._user_id = _arg;
+      }
+      
+      case type::withhold_status:
+      {
+        _withhold_status._user_id = _arg;
+      }
+      
+      case type::withhold_user:
+      {
+        _withhold_user._user_id = _arg;
+      }
+
+      default:
+      {
+        assert(false);
+      }
+    }
+  }
+  
   const std::vector<std::string>& notification::getCountries() const
   {
     switch (_type)
@@ -822,6 +1158,13 @@ namespace twitter {
     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);
@@ -843,6 +1186,13 @@ namespace twitter {
     return _limit;
   }
   
+  void notification::setLimit(int _arg)
+  {
+    assert(_type == type::limit);
+    
+    _limit = _arg;
+  }
+  
   const std::string& notification::getWarning() const
   {
     switch (_type)
@@ -88,25 +88,69 @@ namespace twitter {
     
     type getType() const;
     
+    notification() {}
     notification(const client& tclient, std::string data);
+    
+    notification(const notification& other);
     notification(notification&& other);
-    notification& operator=(notification&& other);
+    notification& operator=(notification other);
     ~notification();
     
-    notification(const notification& other) = delete;
-    notification& operator=(const notification& other) = delete;
+    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 {
@@ -140,7 +184,7 @@ namespace twitter {
       std::set<user_id> _friends;
       direct_message _direct_message;
     };
-    type _type;
+    type _type = type::invalid;
   };
   
 };
@@ -256,7 +256,7 @@ namespace twitter {
             _backoff_amount = std::chrono::milliseconds(0);
           }
           
-          _notify(n);
+          _notify(std::move(n));
                     
           _buffer = "";
         }
@@ -16,7 +16,7 @@ namespace twitter {
   class stream {
   public:
     
-    typedef std::function<void(const notification& _notification)> notify_callback;
+    typedef std::function<void(notification _notification)> notify_callback;
     
     stream(
       const client& tclient,
@@ -6,19 +6,19 @@
 
 namespace twitter {
   
-  tweet::tweet(const client& tclient, std::string data) try
-    : _client(tclient)
+  tweet::tweet(std::string data) try
+    : _valid(true)
   {
     auto json = nlohmann::json::parse(data);
     _id = json["id"].get<tweet_id>();
     _text = json["text"].get<std::string>();
-    _author = make_unique<user>(_client, json["user"].dump());
+    _author = make_unique<user>(json["user"].dump());
     
     if (!json["retweeted_status"].is_null())
     {
       _is_retweet = true;
       
-      _retweeted_status = make_unique<tweet>(_client, json["retweeted_status"].dump());
+      _retweeted_status = make_unique<tweet>(json["retweeted_status"].dump());
     }
     
     if (!json["entities"].is_null())
@@ -40,14 +40,53 @@ namespace twitter {
     std::throw_with_nested(malformed_object("tweet", data));
   }
   
-  std::string tweet::generateReplyPrefill() const
+  tweet::tweet(const tweet& other)
+  {
+    _valid = other._valid;
+    _id = other._id;
+    _text = other._text;
+    _author = make_unique<user>(*other._author);
+    _is_retweet = other._is_retweet;
+    
+    if (_is_retweet)
+    {
+      _retweeted_status = make_unique<tweet>(*other._retweeted_status);
+    }
+    
+    _mentions = other._mentions;
+  }
+  
+  tweet::tweet(tweet&& other) : tweet()
+  {
+    swap(*this, other);
+  }
+  
+  tweet& tweet::operator=(tweet other)
+  {
+    swap(*this, other);
+    
+    return *this;
+  }
+  
+  void swap(tweet& first, tweet& second)
+  {
+    std::swap(first._valid, second._valid);
+    std::swap(first._id, second._id);
+    std::swap(first._text, second._text);
+    std::swap(first._author, second._author);
+    std::swap(first._is_retweet, second._is_retweet);
+    std::swap(first._retweeted_status, second._retweeted_status);
+    std::swap(first._mentions, second._mentions);
+  }
+  
+  std::string tweet::generateReplyPrefill(const user& me) const
   {
     std::ostringstream output;
     output << "@" << _author->getScreenName() << " ";
     
     for (auto mention : _mentions)
     {
-      if ((mention.first != _author->getID()) && (mention.first != _client.getUser().getID()))
+      if ((mention.first != _author->getID()) && (mention.first != me.getID()))
       {
         output << "@" << mention.second << " ";
       }
@@ -56,20 +95,12 @@ namespace twitter {
     return output.str();
   }
   
-  tweet tweet::reply(std::string message, std::list<long> media_ids) const
-  {
-    return _client.replyToTweet(message, _id, media_ids);
-  }
-  
-  bool tweet::isMyTweet() const
-  {
-    return *_author == _client.getUser();
-  }
-  
   std::string tweet::getURL() const
   {
+    assert(_valid);
+    
     std::ostringstream urlstr;
-    urlstr << "https://twitter.com";
+    urlstr << "https://twitter.com/";
     urlstr << _author->getScreenName();
     urlstr << "/statuses/";
     urlstr << _id;
@@ -18,57 +18,65 @@ namespace twitter {
   class tweet {
     public:
       
-      tweet(const client& tclient, std::string data);
+      tweet() {}
+      tweet(std::string data);
       
-      tweet(const tweet& other) = delete;
-      tweet& operator=(const tweet& other) = delete;
+      tweet(const tweet& other);
+      tweet(tweet&& other);
       
-      tweet(tweet&& other) = default;
-      tweet& operator=(tweet&& other) = default;
+      tweet& operator=(tweet other);
+      
+      friend void swap(tweet& first, tweet& second);
       
       tweet_id getID() const
       {
+        assert(_valid);
+        
         return _id;
       }
       
       std::string getText() const
       {
+        assert(_valid);
+        
         return _text;
       }
       
       const user& getAuthor() const
       {
+        assert(_valid);
+        
         return *_author;
       }
 
       bool isRetweet() const
       {
+        assert(_valid);
+        
         return _is_retweet;
       }
       
       const tweet& getRetweet() const
       {
-        assert(_is_retweet);
+        assert(_valid && _is_retweet);
         
         return *_retweeted_status;
       }
       
       const std::vector<std::pair<user_id, std::string>>& getMentions() const
       {
+        assert(_valid);
+        
         return _mentions;
       }
       
-      std::string generateReplyPrefill() const;
-      
-      tweet reply(std::string message, std::list<long> media_ids = {}) const;
-      
-      bool isMyTweet() const;
+      std::string generateReplyPrefill(const user& me) const;
       
       std::string getURL() const;
       
     private:
       
-      const client& _client;
+      bool _valid = false;
       tweet_id _id;
       std::string _text;
       std::unique_ptr<user> _author;
@@ -5,8 +5,8 @@
 
 namespace twitter {
   
-  user::user(const client& tclient, std::string data) try
-    : _client(tclient)
+  user::user(std::string data) try
+    : _valid(true)
   {
     auto json = nlohmann::json::parse(data);
     _id = json["id"].get<user_id>();
@@ -19,25 +19,5 @@ namespace twitter {
   {
     std::throw_with_nested(malformed_object("user", data));
   }
-  
-  std::set<user_id> user::getFriends() const
-  {
-    return _client.getFriends(_id);
-  }
-  
-  std::set<user_id> user::getFollowers() const
-  {
-    return _client.getFollowers(_id);
-  }
-  
-  void user::follow() const
-  {
-    _client.follow(_id);
-  }
-  
-  void user::unfollow() const
-  {
-    _client.unfollow(_id);
-  }
 
 };
@@ -3,6 +3,7 @@
 
 #include <string>
 #include <set>
+#include <cassert>
 
 namespace twitter {
   
@@ -13,20 +14,27 @@ namespace twitter {
   class user {
     public:
       
-      user(const client& tclient, std::string data);
+      user() {}
+      user(std::string data);
       
       user_id getID() const
       {
+        assert(_valid);
+        
         return _id;
       }
       
       std::string getScreenName() const
       {
+        assert(_valid);
+        
         return _screen_name;
       }
       
       std::string getName() const
       {
+        assert(_valid);
+        
         return _name;
       }
       
@@ -40,14 +48,9 @@ namespace twitter {
         return _id != other._id;
       }
       
-      std::set<user_id> getFriends() const;
-      std::set<user_id> getFollowers() const;
-      void follow() const;
-      void unfollow() const;
-      
     private:
       
-      const client& _client;
+      bool _valid = false;
       user_id _id;
       std::string _screen_name;
       std::string _name;