일단 이제 자잘한 버그만 고치면 될 듯?
This commit is contained in:
488
Client/src/ClientManager/ClientManager.cpp
Normal file
488
Client/src/ClientManager/ClientManager.cpp
Normal file
@@ -0,0 +1,488 @@
|
||||
#include "ClientManager/ClientManager.hpp"
|
||||
#include "Utils/ConfigManager.hpp"
|
||||
#include "Utils/StringTokenizer.hpp"
|
||||
#include "Socket/Log.hpp"
|
||||
#include <iostream>
|
||||
|
||||
namespace Chattr {
|
||||
|
||||
void ClientManager::_IOCPClient(Chattr::ThreadPool* thread, Chattr::IOCPPASSINDATA* data) {
|
||||
Chattr::Packet pack;
|
||||
int packetSize = data->transferredbytes;
|
||||
|
||||
if (data->event == IOCPEVENT::WRITE && data->transferredbytes >= data->wsabuf.len) {
|
||||
data->event = IOCPEVENT::READ;
|
||||
data->wsabuf.len = 1500;
|
||||
data->IOCPInstance->recv(data, 1);
|
||||
return;
|
||||
}
|
||||
|
||||
memcpy(pack.serialized, data->wsabuf.buf, data->wsabuf.len);
|
||||
|
||||
std::uint16_t packetLength = ::ntohs(pack.__data.packetLength);
|
||||
|
||||
if (data->event == IOCPEVENT::READ && data->transferredbytes < packetLength + 8) {
|
||||
data->IOCPInstance->recv(data, 1);
|
||||
data->wsabuf.len = 1500;
|
||||
return;
|
||||
}
|
||||
|
||||
pack.convToH();
|
||||
PacketSet packetSet = packetParser(pack);
|
||||
pack.convToN();
|
||||
switch (packetSet) {
|
||||
case PacketSet::LOGINRESPONSE:
|
||||
case PacketSet::ROOMCREATERESPONSE:
|
||||
case PacketSet::ROOMLISTRESPONSE:
|
||||
case PacketSet::ROOMJOINRESPONSE:
|
||||
case PacketSet::ROOMEXITRESPONSE:
|
||||
case PacketSet::USERSLISTRESPONSE:
|
||||
case PacketSet::RESPONSE: {
|
||||
ResponsePacket responsePacket;
|
||||
std::memcpy(&responsePacket.serialized, &pack.serialized, 8 + packetLength);
|
||||
responsePacket.convToH();
|
||||
processresponsePacket(responsePacket, data);
|
||||
}
|
||||
break;
|
||||
case PacketSet::DATAPOST: {
|
||||
DataPostPacket dataPostPacket;
|
||||
std::memcpy(&dataPostPacket.serialized, &pack.serialized, 8 + packetLength);
|
||||
dataPostPacket.convToH();
|
||||
processDataPostPacket(dataPostPacket, data);
|
||||
}
|
||||
break;
|
||||
case PacketSet::CONTINUE: {
|
||||
ContinuePacket continuePacket;
|
||||
std::memcpy(&continuePacket.serialized, &pack.serialized, 8 + packetLength);
|
||||
continuePacket.convToH();
|
||||
processContinuePacket(continuePacket, data);
|
||||
}
|
||||
break;
|
||||
case PacketSet::INVALID:
|
||||
default: {
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
PacketSet ClientManager::packetParser(Packet Packet) {
|
||||
if (Packet.__data.packetLength < 0 || Packet.__data.packetLength > 1492)
|
||||
return PacketSet::INVALID;
|
||||
|
||||
switch (Packet.__data.packetType) {
|
||||
case PacketCategory::PACKET_POST:
|
||||
if (Packet.__data.requestType != RequestType::DATA) {
|
||||
return PacketSet::INVALID;
|
||||
}
|
||||
switch (Packet.__data.dataType) {
|
||||
case DataType::TEXT:
|
||||
case DataType::BINARY:
|
||||
return PacketSet::DATAPOST;
|
||||
default:
|
||||
return PacketSet::INVALID;
|
||||
}
|
||||
break;
|
||||
case PacketCategory::PACKET_REQUEST:
|
||||
switch (Packet.__data.requestType) {
|
||||
case RequestType::LOGIN:
|
||||
return PacketSet::LOGINREQUEST;
|
||||
case RequestType::ROOM_CREATE:
|
||||
return PacketSet::ROOMCREATEREQUEST;
|
||||
case RequestType::ROOM_LIST:
|
||||
return PacketSet::ROOMLISTREQUEST;
|
||||
case RequestType::ROOM_JOIN:
|
||||
return PacketSet::ROOMJOINREQUEST;
|
||||
case RequestType::ROOM_EXIT:
|
||||
return PacketSet::ROOMEXITREQUEST;
|
||||
case RequestType::USERS_LIST:
|
||||
return PacketSet::USERSLISTREQUEST;
|
||||
case RequestType::DATA:
|
||||
return PacketSet::INVALID;
|
||||
}
|
||||
break;
|
||||
case PacketCategory::PACKET_RESPONSE:
|
||||
switch (Packet.__data.requestType) {
|
||||
case RequestType::LOGIN:
|
||||
return PacketSet::LOGINRESPONSE;
|
||||
case RequestType::ROOM_CREATE:
|
||||
return PacketSet::ROOMCREATERESPONSE;
|
||||
case RequestType::ROOM_LIST:
|
||||
return PacketSet::ROOMLISTRESPONSE;
|
||||
case RequestType::ROOM_JOIN:
|
||||
return PacketSet::ROOMJOINRESPONSE;
|
||||
case RequestType::ROOM_EXIT:
|
||||
return PacketSet::ROOMEXITRESPONSE;
|
||||
case RequestType::USERS_LIST:
|
||||
return PacketSet::USERSLISTRESPONSE;
|
||||
case RequestType::DATA:
|
||||
return PacketSet::RESPONSE;
|
||||
default:
|
||||
return PacketSet::INVALID;
|
||||
}
|
||||
break;
|
||||
case PacketCategory::PACKET_CONTINUE:
|
||||
return PacketSet::CONTINUE;
|
||||
default:
|
||||
return PacketSet::INVALID;
|
||||
}
|
||||
|
||||
return PacketSet::INVALID;
|
||||
}
|
||||
|
||||
void ClientManager::processresponsePacket(ResponsePacket responsePacket, IOCPPASSINDATA* data) {
|
||||
responsePacket;
|
||||
// std::string userName(
|
||||
// (char*)loginResponsePacket.__data.data,
|
||||
// loginResponsePacket.__data.packetLength);
|
||||
// registerUser(userName);
|
||||
|
||||
// LoginResponsePacket loginResponsePacket;
|
||||
// loginResponsePacket.__data.packetType = Chattr::PacketCategory::PACKET_RESPONSE;
|
||||
// loginResponsePacket.__data.requestType = Chattr::RequestType::LOGIN;
|
||||
// loginResponsePacket.__data.dataType = Chattr::DataType::BINARY;
|
||||
// loginResponsePacket.__data.packetLength = sizeof(Chattr::ResponseStatusCode) + sizeof(Snowflake);
|
||||
// loginResponsePacket.__data.responseStatusCode = Chattr::ResponseStatusCode::OK;
|
||||
// Snowflake yourId = userSocket2UID_[data->socket];
|
||||
// ::memcpy(loginResponsePacket.__data.yourId, &yourId, sizeof(Snowflake));
|
||||
|
||||
// loginResponsePacket.convToN();
|
||||
// memcpy(data->wsabuf.buf, loginResponsePacket.serialized, 18);
|
||||
// data->sendbytes = 18;
|
||||
// data->wsabuf.len = 18;
|
||||
// data->IOCPInstance->send(data, 1, 0);
|
||||
}
|
||||
|
||||
void ClientManager::processRoomCreateResponsePacket(RoomCreateResponsePacket roomCreateResponsePacket, Chattr::IOCPPASSINDATA* data) {
|
||||
// std::string roomName(
|
||||
// (char*)roomCreateResponsePacket.__data.data,
|
||||
// roomCreateResponsePacket.__data.packetLength);
|
||||
// Snowflake RID = createRoom(roomName);
|
||||
|
||||
// RoomCreateResponsePacket roomCreateResponsePacket;
|
||||
// roomCreateResponsePacket.__data.packetType = Chattr::PacketCategory::PACKET_RESPONSE;
|
||||
// roomCreateResponsePacket.__data.requestType = Chattr::RequestType::ROOM_CREATE;
|
||||
// roomCreateResponsePacket.__data.dataType = Chattr::DataType::BINARY;
|
||||
// roomCreateResponsePacket.__data.packetLength = sizeof(Chattr::ResponseStatusCode) + sizeof(Snowflake);
|
||||
// roomCreateResponsePacket.__data.responseStatusCode = Chattr::ResponseStatusCode::OK;
|
||||
// ::memcpy(roomCreateResponsePacket.__data.createdRoomId, &RID, sizeof(Snowflake));
|
||||
|
||||
// roomCreateResponsePacket.convToN();
|
||||
// memcpy(data->wsabuf.buf, roomCreateResponsePacket.serialized, 18);
|
||||
// data->sendbytes = 18;
|
||||
// data->wsabuf.len = 18;
|
||||
// data->IOCPInstance->send(data, 1, 0);
|
||||
}
|
||||
|
||||
void ClientManager::processRoomListResponse(RoomListResponsePacket roomListResponsePacket, Chattr::IOCPPASSINDATA* data) {
|
||||
// auto roomsList = getRoomList();
|
||||
|
||||
// for (auto room : roomsList) {
|
||||
// RoomListResponsePacket roomListResponsePacket;
|
||||
// roomListResponsePacket.__data.packetType = Chattr::PacketCategory::PACKET_RESPONSE;
|
||||
// roomListResponsePacket.__data.requestType = Chattr::RequestType::ROOM_LIST;
|
||||
// roomListResponsePacket.__data.dataType = Chattr::DataType::BINARY;
|
||||
// roomListResponsePacket.__data.packetLength = sizeof(Chattr::ResponseStatusCode) + sizeof(std::uint32_t) + sizeof(Snowflake) + room.second.size();
|
||||
// roomListResponsePacket.__data.responseStatusCode = Chattr::ResponseStatusCode::OK;
|
||||
// roomListResponsePacket.__data.roomCount = roomsList.size();
|
||||
// ::memcpy(roomListResponsePacket.__data.roomId, &room.first, sizeof(Snowflake));
|
||||
// ::memcpy(roomListResponsePacket.__data.name, room.second.c_str(), room.second.size());
|
||||
|
||||
// int packetLength = roomListResponsePacket.__data.packetLength;
|
||||
|
||||
// Chattr::IOCPPASSINDATA* ptr = new Chattr::IOCPPASSINDATA;
|
||||
// ::memset(&ptr->overlapped, 0, sizeof(OVERLAPPED));
|
||||
// ptr->socket = data->socket;
|
||||
// ptr->recvbytes = ptr->sendbytes = 0;
|
||||
// ptr->wsabuf.buf = ptr->buf;
|
||||
// ptr->wsabuf.len = packetLength + 8;
|
||||
// ptr->IOCPInstance = data->IOCPInstance;
|
||||
|
||||
// roomListResponsePacket.convToN();
|
||||
// memcpy(ptr->wsabuf.buf, roomListResponsePacket.serialized, packetLength + 8);
|
||||
// data->sendbytes = packetLength + 8;
|
||||
// data->IOCPInstance->send(ptr, 1, 0);
|
||||
// }
|
||||
}
|
||||
|
||||
void ClientManager::processRoomJoinResponsePacket(RoomJoinResponsePacket roomJoinResponsePacket, Chattr::IOCPPASSINDATA* data) {
|
||||
// Snowflake myID, roomID;
|
||||
// ::memcpy(&myID.snowflake, roomJoinResponsePacket.__data.myId, sizeof(Snowflake));
|
||||
// ::memcpy(&roomID.snowflake, roomJoinResponsePacket.__data.roomId, sizeof(Snowflake));
|
||||
|
||||
// joinRoom(myID, roomID);
|
||||
|
||||
// RoomJoinResponsePacket roomJoinResponsePacket;
|
||||
// roomJoinResponsePacket.__data.packetType = Chattr::PacketCategory::PACKET_RESPONSE;
|
||||
// roomJoinResponsePacket.__data.requestType = Chattr::RequestType::ROOM_JOIN;
|
||||
// roomJoinResponsePacket.__data.dataType = Chattr::DataType::BINARY;
|
||||
// roomJoinResponsePacket.__data.packetLength = sizeof(Chattr::ResponseStatusCode);
|
||||
// roomJoinResponsePacket.__data.responseStatusCode = Chattr::ResponseStatusCode::OK;
|
||||
|
||||
// int packetLength = roomJoinResponsePacket.__data.packetLength;
|
||||
|
||||
// roomJoinResponsePacket.convToN();
|
||||
// ::memcpy(data->wsabuf.buf, roomJoinResponsePacket.serialized, 10);
|
||||
// data->sendbytes = 10;
|
||||
// data->wsabuf.len = 10;
|
||||
// data->IOCPInstance->send(data, 1, 0);
|
||||
}
|
||||
|
||||
void ClientManager::processRoomExitResponsePacket(RoomExitResponsePacket roomExitResponsePacket, Chattr::IOCPPASSINDATA* data) {
|
||||
// Snowflake myID, roomID;
|
||||
// ::memcpy(&myID.snowflake, roomExitResponsePacket.__data.myId, sizeof(Snowflake));
|
||||
// ::memcpy(&roomID.snowflake, roomExitResponsePacket.__data.roomId, sizeof(Snowflake));
|
||||
|
||||
// exitRoom(myID, roomID);
|
||||
|
||||
// RoomExitResponsePacket roomExitResponsePacket;
|
||||
// roomExitResponsePacket.__data.packetType = Chattr::PacketCategory::PACKET_RESPONSE;
|
||||
// roomExitResponsePacket.__data.requestType = Chattr::RequestType::ROOM_EXIT;
|
||||
// roomExitResponsePacket.__data.dataType = Chattr::DataType::BINARY;
|
||||
// roomExitResponsePacket.__data.packetLength = sizeof(Chattr::ResponseStatusCode);
|
||||
// roomExitResponsePacket.__data.responseStatusCode = Chattr::ResponseStatusCode::OK;
|
||||
|
||||
// int packetLength = roomExitResponsePacket.__data.packetLength;
|
||||
|
||||
// roomExitResponsePacket.convToN();
|
||||
// ::memcpy(data->wsabuf.buf, roomExitResponsePacket.serialized, 10);
|
||||
// data->sendbytes = 10;
|
||||
// data->wsabuf.len = 10;
|
||||
// data->IOCPInstance->send(data, 1, 0);
|
||||
}
|
||||
|
||||
void ClientManager::processUsersListResponsePacket(UsersListResponsePacket usersListResponsePacket, Chattr::IOCPPASSINDATA* data) {
|
||||
// auto usersList = getUserList();
|
||||
|
||||
// for (auto user : usersList) {
|
||||
// UsersListResponsePacket usersListResponsePacket;
|
||||
// usersListResponsePacket.__data.packetType = Chattr::PacketCategory::PACKET_RESPONSE;
|
||||
// usersListResponsePacket.__data.requestType = Chattr::RequestType::USERS_LIST;
|
||||
// usersListResponsePacket.__data.dataType = Chattr::DataType::BINARY;
|
||||
// usersListResponsePacket.__data.packetLength = sizeof(Chattr::ResponseStatusCode) + sizeof(std::uint32_t) + sizeof(Snowflake) + user.second.size();
|
||||
// usersListResponsePacket.__data.responseStatusCode = Chattr::ResponseStatusCode::OK;
|
||||
// usersListResponsePacket.__data.usersCount = usersList.size();
|
||||
// ::memcpy(usersListResponsePacket.__data.userId, &user.first, sizeof(Snowflake));
|
||||
// ::memcpy(usersListResponsePacket.__data.name, user.second.c_str(), user.second.size());
|
||||
|
||||
// int packetLength = usersListResponsePacket.__data.packetLength;
|
||||
|
||||
// Chattr::IOCPPASSINDATA* ptr = new Chattr::IOCPPASSINDATA;
|
||||
// ::memset(&ptr->overlapped, 0, sizeof(OVERLAPPED));
|
||||
// ptr->socket = data->socket;
|
||||
// ptr->recvbytes = ptr->sendbytes = 0;
|
||||
// ptr->wsabuf.buf = ptr->buf;
|
||||
// ptr->wsabuf.len = packetLength + 8;
|
||||
// ptr->IOCPInstance = data->IOCPInstance;
|
||||
|
||||
// usersListResponsePacket.convToN();
|
||||
// memcpy(ptr->wsabuf.buf, usersListResponsePacket.serialized, packetLength + 8);
|
||||
// data->sendbytes = packetLength + 8;
|
||||
// data->IOCPInstance->send(ptr, 1, 0);
|
||||
// }
|
||||
}
|
||||
|
||||
void ClientManager::processDataPostPacket(DataPostPacket dataPostPacket, IOCPPASSINDATA* data) {
|
||||
Snowflake destID;
|
||||
::memcpy(&destID.snowflake, dataPostPacket.__data.destId, sizeof(Snowflake));
|
||||
|
||||
std::vector<std::shared_ptr<TCPSocket>> destinationSockets;
|
||||
|
||||
if (userNames_.find(destID) != userNames_.end())
|
||||
destinationSockets.push_back(UID2userSocket_[destID]);
|
||||
else
|
||||
for (auto user : rooms_[destID])
|
||||
destinationSockets.push_back(user.second);
|
||||
|
||||
spdlog::info("Received [{}] from : [{}] to : [{}]",
|
||||
std::string((char*)dataPostPacket.__data.data, dataPostPacket.__data.packetLength - (sizeof(std::uint16_t) * 5)),
|
||||
(std::string)data->socket->remoteAddr,
|
||||
destID.snowflake);
|
||||
|
||||
ResponsePacket responsePacket;
|
||||
responsePacket.__data.packetType = Chattr::PacketCategory::PACKET_RESPONSE;
|
||||
responsePacket.__data.requestType = Chattr::RequestType::DATA;
|
||||
responsePacket.__data.dataType = Chattr::DataType::TEXT;
|
||||
responsePacket.__data.packetLength = sizeof(Chattr::ResponseStatusCode);
|
||||
responsePacket.__data.responseStatusCode = Chattr::ResponseStatusCode::OK;
|
||||
|
||||
responsePacket.convToN();
|
||||
memcpy(data->wsabuf.buf, responsePacket.serialized, 10);
|
||||
data->sendbytes = 10;
|
||||
data->wsabuf.len = 10;
|
||||
data->IOCPInstance->send(data, 1, 0);
|
||||
|
||||
int packetLength = dataPostPacket.__data.packetLength;
|
||||
|
||||
for (auto dest : destinationSockets) {
|
||||
|
||||
Chattr::IOCPPASSINDATA* ptr = new Chattr::IOCPPASSINDATA;
|
||||
::memset(&ptr->overlapped, 0, sizeof(OVERLAPPED));
|
||||
ptr->socket = dest;
|
||||
ptr->recvbytes = ptr->sendbytes = 0;
|
||||
ptr->wsabuf.buf = ptr->buf;
|
||||
ptr->wsabuf.len = packetLength + 6;
|
||||
ptr->IOCPInstance = data->IOCPInstance;
|
||||
|
||||
dataPostPacket.convToN();
|
||||
memcpy(ptr->wsabuf.buf, dataPostPacket.serialized, packetLength + 6);
|
||||
data->sendbytes = packetLength + 6;
|
||||
data->IOCPInstance->send(ptr, 1, 0);
|
||||
}
|
||||
}
|
||||
|
||||
void ClientManager::processContinuePacket(ContinuePacket continuePacket, IOCPPASSINDATA* data) {
|
||||
Snowflake destID;
|
||||
::memcpy(&destID.snowflake, continuePacket.__data.destId, sizeof(Snowflake));
|
||||
|
||||
std::vector<std::shared_ptr<TCPSocket>> destinationSockets;
|
||||
|
||||
if (userNames_.find(destID) != userNames_.end())
|
||||
destinationSockets.push_back(UID2userSocket_[destID]);
|
||||
else
|
||||
for (auto user : rooms_[destID])
|
||||
destinationSockets.push_back(user.second);
|
||||
|
||||
spdlog::info("Received [{}] from : [{}] to : [{}]",
|
||||
std::string((char*)continuePacket.__data.data, continuePacket.__data.packetLength - (sizeof(std::uint16_t) * 5)),
|
||||
(std::string)data->socket->remoteAddr,
|
||||
destID.snowflake);
|
||||
|
||||
ResponsePacket responsePacket;
|
||||
responsePacket.__data.packetType = Chattr::PacketCategory::PACKET_RESPONSE;
|
||||
responsePacket.__data.requestType = Chattr::RequestType::DATA;
|
||||
responsePacket.__data.dataType = Chattr::DataType::TEXT;
|
||||
responsePacket.__data.packetLength = sizeof(Chattr::ResponseStatusCode);
|
||||
responsePacket.__data.responseStatusCode = Chattr::ResponseStatusCode::OK;
|
||||
|
||||
responsePacket.convToN();
|
||||
memcpy(data->wsabuf.buf, responsePacket.serialized, 10);
|
||||
data->sendbytes = 10;
|
||||
data->wsabuf.len = 10;
|
||||
data->IOCPInstance->send(data, 1, 0);
|
||||
|
||||
int packetLength = continuePacket.__data.packetLength;
|
||||
|
||||
for (auto dest : destinationSockets) {
|
||||
Chattr::IOCPPASSINDATA* ptr = new Chattr::IOCPPASSINDATA;
|
||||
::memset(&ptr->overlapped, 0, sizeof(OVERLAPPED));
|
||||
ptr->socket = dest;
|
||||
ptr->recvbytes = ptr->sendbytes = 0;
|
||||
ptr->wsabuf.buf = ptr->buf;
|
||||
ptr->wsabuf.len = packetLength + 6;
|
||||
ptr->IOCPInstance = data->IOCPInstance;
|
||||
|
||||
continuePacket.convToN();
|
||||
memcpy(ptr->wsabuf.buf, continuePacket.serialized, packetLength + 6);
|
||||
data->sendbytes = packetLength + 6;
|
||||
data->IOCPInstance->send(ptr, 1, 0);
|
||||
}
|
||||
}
|
||||
|
||||
void ClientManager::registerUser(std::string userName) {
|
||||
Chattr::LoginRequestPacket loginRequestPacket;
|
||||
loginRequestPacket.__data.packetType = Chattr::PacketCategory::PACKET_REQUEST;
|
||||
loginRequestPacket.__data.requestType = Chattr::RequestType::LOGIN;
|
||||
loginRequestPacket.__data.dataType = Chattr::DataType::BINARY;
|
||||
loginRequestPacket.__data.packetLength = userName.size();
|
||||
memcpy(loginRequestPacket.__data.data, userName.c_str(), userName.size());
|
||||
|
||||
int packetLength = loginRequestPacket.__data.packetLength;
|
||||
|
||||
data_->recvbytes = data_->sendbytes = 0;
|
||||
data_->wsabuf.len = packetLength + 8;
|
||||
|
||||
loginRequestPacket.convToN();
|
||||
memcpy(data_->wsabuf.buf, loginRequestPacket.serialized, packetLength + 8);
|
||||
data_->sendbytes = packetLength + 8;
|
||||
iocp_.send(data_, 1, 0, true);
|
||||
}
|
||||
|
||||
void ClientManager::deleteUser(Snowflake UID) {
|
||||
std::lock_guard<std::mutex> lock(resourceMutex_);
|
||||
userNames_.erase(UID);
|
||||
std::shared_ptr<TCPSocket> sock = UID2userSocket_[UID];
|
||||
UID2userSocket_.erase(UID);
|
||||
userSocket2UID_.erase(sock);
|
||||
}
|
||||
|
||||
std::vector<std::pair<Snowflake, std::string>> ClientManager::getUserList() {
|
||||
std::lock_guard<std::mutex> lock(resourceMutex_);
|
||||
std::vector<std::pair<Snowflake, std::string>> userList;
|
||||
userList.reserve(userNames_.size());
|
||||
|
||||
for (auto user : userNames_)
|
||||
userList.push_back(user);
|
||||
|
||||
return userList;
|
||||
}
|
||||
|
||||
Snowflake ClientManager::createRoom(std::string roomName) {
|
||||
std::lock_guard<std::mutex> lock(resourceMutex_);
|
||||
Snowflake RID = GenerateID();
|
||||
roomNames_[RID] = roomName;
|
||||
rooms_[RID] = std::unordered_map<Snowflake, std::shared_ptr<TCPSocket>>();
|
||||
return RID;
|
||||
}
|
||||
|
||||
void ClientManager::deleteRoom(Snowflake RID) {
|
||||
std::lock_guard<std::mutex> lock(resourceMutex_);
|
||||
roomNames_.erase(RID);
|
||||
rooms_.erase(RID);
|
||||
}
|
||||
|
||||
std::vector<std::pair<Snowflake, std::string>> ClientManager::getRoomList() {
|
||||
std::lock_guard<std::mutex> lock(resourceMutex_);
|
||||
std::vector<std::pair<Snowflake, std::string>> roomList;
|
||||
roomList.reserve(roomNames_.size());
|
||||
|
||||
for (auto user : roomNames_)
|
||||
roomList.push_back(user);
|
||||
|
||||
return roomList;
|
||||
}
|
||||
|
||||
void ClientManager::joinRoom(Snowflake UID, Snowflake RID) {
|
||||
std::lock_guard<std::mutex> lock(resourceMutex_);
|
||||
std::shared_ptr<TCPSocket> sock = UID2userSocket_[UID];
|
||||
rooms_[RID][UID] = sock;
|
||||
}
|
||||
|
||||
void ClientManager::exitRoom(Snowflake UID, Snowflake RID) {
|
||||
std::lock_guard<std::mutex> lock(resourceMutex_);
|
||||
rooms_[RID].erase(UID);
|
||||
}
|
||||
|
||||
void ClientManager::run() {
|
||||
StringTokenizer tokenizer;
|
||||
std::string nickname;
|
||||
|
||||
std::cout << "Please enter your nickname: ";
|
||||
std::getline(std::cin, nickname);
|
||||
tokenizer.set(nickname.c_str(), nickname.size());
|
||||
|
||||
registerUser(tokenizer.get()[0]);
|
||||
|
||||
std::cout << "Commads:" << std::endl;
|
||||
std::cout << "/w <username> : Send direct message to specified user" << std::endl;
|
||||
std::cout << "/join <roomname> : Enter specified room" << std::endl;
|
||||
std::cout << "/exit : Exit current room" << std::endl;
|
||||
std::cout << "/create <roomname> : Create room" << std::endl;
|
||||
std::cout << "/list : Print all registred users" << std::endl;
|
||||
std::cout << "/exit : Terminate this program (When you are not in room)" << std::endl;
|
||||
|
||||
while (true) {
|
||||
std::string input;
|
||||
|
||||
if (inRoom_) {
|
||||
std::cout << "[" << nickname << "@" << roomNames_[myRoomID_] << "]" << " ";
|
||||
}
|
||||
else {
|
||||
std::cout << "[" << nickname << "]" << " ";
|
||||
}
|
||||
|
||||
std::getline(std::cin, input);
|
||||
tokenizer.set(input.c_str(), input.size());
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user