-
Notifications
You must be signed in to change notification settings - Fork 0
/
Network.hpp
203 lines (151 loc) · 7.39 KB
/
Network.hpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
/****************************************************************************************************************************
Title : Network.hpp
Author : Modified by Kasaf Shah
Description : header/interface files for Network class
Date modified :11/20/2022
****************************************************************************************************************************/
#ifndef NETWORK_
#define NETWORK_
#include <fstream>
#include <vector>
#include <string>
#include <sstream>
#include "Post.hpp"
#include "LinkedList.hpp"
#include "Account.hpp"
template <typename ItemType>
class Network
{
public:
/** default constructor**/
Network();
/**
@return account_count_ : the current size of the bag
**/
int getSizeOfNetwork() const;
/**
@return true if account_count_ == 0, false otherwise
**/
bool isEmpty() const;
/**
@param : a POINTER to the item that will be added to the Network
@return : bool- true if the item was successfully added, false otherwise
@post : stores a pointer to the item, if there is room. This is a network specific function,
it has an additional constraint: the item will be added only if no other item in the network
has the same username (usernames are considered unique)
Finally, the Account being added to the network will update it's private member to point to this network
*/
bool addAccount(ItemType* new_entry);
/**
Mutator function
@param : a POINTER to the item that will be removed from Network
@return : true if if the item was successfully removed, false otherwise
@post : updates the bag/network to remove the pointer, if a pointer to that item was found.
*/
bool removeAccount(ItemType* an_entry);
/**
@post :removes all accounts from the network
**/
void clear();
/**
@return : true if an_etry is found in network_, false otherwise
**/
bool containsAccount(const ItemType &an_entry) const;
/**
Mutator function
@param : the name of an input file
@pre : The format of the text file is as follows:
username password
username password
;
where ';' signals the end of the file. Check the provided example (accounts.txt).
@post : Reads every line in the input file, creates an Account from that information and
adds the Account to the network. If a line of input is missing some required information,
it prints out "Improper Format" and terminates.
Keep in mind that, although the input will always be an Account, the Network class is
a template, thus it will store a pointer to a generic type. It will do so by creating a new
dynamic object of type ItemType but passing the account information (username and password)
as to the Account constructor. This is a bit hacky, but it will work for our Network.
*/
void populateNetwork(const std::string input);
/**
Accessor function
@param : a reference to the item whose feed will be displayed
@post : prints the feed of the given account by checking who they are following
and displaying all the posts from the feed that were made by those accounts.
Keep in mind that the Network parameters are general template types
in this project rather than accounts, although this functionality is
specific to accounts.
*/
void printFeedForAccount(ItemType &an_entry);
/**
@param : a reference to an item (account) and the username of the account
it wants to follow
@return : true if the item was authorized to follow, false otherwise
@post : the referenced Account follows another account with the username
specified by the second argument if they both exist in the network
*/
bool authenticateFollow(ItemType &an_entry, const std::string username) const;
/**
@param : a pointer to Post
@post : the post is added to the feed if the account username is in the network
*/
void addToFeed(Post* p);
/**
@param : a pointer to Post
@return : true if post was removed from feed, false otherwise
@post : the post is removed from to the feed if there
*/
bool removePostFromFeed(Post* post);
/**
@param : a pointer to Post
@return : true if post was found and moved to the front of the feed,
false otherwise
@post : The post is moved to the front of the feed
*/
bool updateFeed(Post* post);
/**
Accessor function
@post : prints the feed by displaying all the posts from the feed
*/
void printFeed();
/**
The (set) difference between two sets A and B is the set that
consists of the elements of A which are not elements of B
@param : a_network to be subtracted from the Network Bag calling the function
@post : removes all the data from network_ that is also found in a_network
**/
void operator-=( Network<ItemType> &a_network);
/*
@param : A string (word or phrase, case-sensitive) passed by reference
@return : The number of items removed from the list
@post : Any Post that contains the provided word or phrase in it's title,
body or both is removed from the Network's `feed_` as well as
the Account's `posts_`.
*/
int removeIfContains(const std::string &postBody);
/*@param : The Comparator to sort with
@param : A POINTER to an integer counter that gets incremented every time a swap between two Nodes occurs
(this is for testing purposes).
IT IS IMPORTANT TO PASS OUR GRADESCOPE TESTS TAHT EACH
TIME BUBBLE SORT MAKES A SWAP YOU INCREMENT THIS COUNTER.
@return : A COPY of the feed_ sorted by username using bubble sort
based on Comparator ( std::less or std::greater ),
from least to greatest or greatest to least.
*/
template<typename Comparator>
LinkedList<Post*> bSortByUsername(Comparator comp, int* i);
protected:
static const int DEFAULT_CAPACITY = 200; //max size of network_
ItemType* network_[DEFAULT_CAPACITY]; // Array of bag items
int account_count_;
LinkedList<Post*> feed_;
/**
@param username to be found in network_
@return either the index target in the array network_ or -1,
if the array does not containthe target account.
**/
int getIndexOf(const std::string username) const;
}; // end Network
#include "Network.cpp"
#endif